@intlayer/core 9.4.3 → 9.5.0

package/README.md

@@ -69,8 +69,6 @@ With **per-locale content files**, **TypeScript autocompletion**, **tree-shakabl
 | <img src="https://github.com/aymericzip/intlayer/blob/main/docs/assets/interoperability.png?raw=true" alt="Feature" width="700">                    | **Interoperability**<br><br>Allow interoperability with react-i18next, next-i18next, next-intl, react-intl, vue-i18n. <br><br> - [Intlayer and react-intl](https://intlayer.org/blog/intlayer-with-react-intl) <br> - [Intlayer and next-intl](https://intlayer.org/blog/intlayer-with-next-intl) <br> - [Intlayer and next-i18next](https://intlayer.org/blog/intlayer-with-next-i18next) <br> - [Intlayer and vue-i18n](https://intlayer.org/blog/intlayer-with-vue-i18n) <br> - [Intlayer compat adapters](https://intlayer.org/doc/compatibility) |
 | <img src="https://github.com/aymericzip/intlayer/blob/main/docs/assets/benchmark.png?raw=true" alt="Feature" width="700">                           | **Performances & Benchmark**<br><br>Uses advanced tree-shaking and dynamic loading to boost performances and keep the solution as light as possible. <br><br> - [Performances & Benchmark](https://intlayer.org/doc/benchmark)                                                                                                                                                                                                                                                                                                                        |
 
----
-
 ## 📦 Installation
 
 Start your journey with Intlayer today and experience a smoother, more powerful approach to internationalization.

package/dist/cjs/dictionaryManipulator/qualifiedDictionary.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"qualifiedDictionary.cjs","names":[],"sources":["../../../src/dictionaryManipulator/qualifiedDictionary.ts"],"sourcesContent":["import type {\n  Dictionary,\n  DictionaryQualifierType,\n  DictionarySelector,\n  DictionaryVariantChain,\n  DictionaryVariantValue,\n  ProviderVariant,\n  ProviderVariantMap,\n  QualifiedDictionaryGroup,\n} from '@intlayer/types/dictionary';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\n\n/**\n * Separator joining per-dimension ids into a composite entry id. Also used as\n * the chunk path separator in dynamic mode.\n */\nexport const COMPOSITE_ID_SEPARATOR = '/';\n\n/**\n * Identity of the implicit fallback variant. A selector that pins no variant\n * resolves to it, and a variant that declares no entry of its own falls back to\n * it — so a key only has to ship the entries that actually differ.\n */\nexport const DEFAULT_VARIANT_ID = 'default';\n\n/**\n * Characters kept verbatim in an encoded qualifier segment. Everything else is\n * percent-encoded so a segment can never contain the composite-id separator\n * (`/`), path-hostile characters (`\\` `:` `*` `?` `\"` `<` `>` `|`, control\n * chars), or characters that would break the generated loader modules (`'`).\n */\nconst SEGMENT_UNSAFE_CHARS = /[^A-Za-z0-9._&=-]/g;\n\n/**\n * Stricter set for the components of an object variant: also encodes `&` and\n * `=` so the `field=value&field=value` serialization stays unambiguous.\n */\nconst COMPONENT_UNSAFE_CHARS = /[^A-Za-z0-9._-]/g;\n\n/** Percent-encodes one UTF-16 code unit as a fixed-width `%XXXX` run. */\nconst percentEncodeChar = (char: string): string =>\n  `%${char.charCodeAt(0).toString(16).toUpperCase().padStart(4, '0')}`;\n\nconst encodeSegmentText = (raw: string, unsafeChars: RegExp): string => {\n  // Bare '%' cannot be produced by encoding (every encoded run is %XXXX),\n  // so it is a safe stand-in for the empty string.\n  if (raw === '') return '%';\n\n  const encoded = raw.replace(unsafeChars, percentEncodeChar);\n\n  // '.' and '..' are path navigation on every filesystem — encode the dots.\n  if (encoded === '.' || encoded === '..') {\n    return encoded.replace(/\\./g, '%002E');\n  }\n\n  return encoded;\n};\n\n/**\n * Canonical serialization of a single variant value into its identity string —\n * the variant segment of a composite id, the chunk directory name in dynamic\n * mode, and the runtime matching key.\n *\n * - `undefined` → `'default'` (the implicit fallback variant)\n * - a string → the string itself (a named variant)\n * - an object → its sorted `key=value` pairs joined by `&`\n *   (e.g. `{ userId: '123', id: 'abc' }` → `'id=abc&userId=123'`)\n *\n * Characters that are unsafe in file paths or generated code are\n * percent-encoded (fixed-width `%XXXX` runs, injective). Common names —\n * letters, digits, `-` `_` `.` — are left untouched. Both the declaration and\n * the selector go through this function, so encoding never affects matching.\n *\n * Two variants resolve to the same entry iff their serializations are equal, so\n * an object variant in a selector must equal the one declared on the dictionary.\n */\nexport const serializeVariant = (\n  variant: DictionaryVariantValue | undefined\n): string => {\n  if (variant === undefined) return DEFAULT_VARIANT_ID;\n  if (typeof variant === 'string') {\n    return encodeSegmentText(variant, SEGMENT_UNSAFE_CHARS);\n  }\n\n  return Object.keys(variant)\n    .sort()\n    .map(\n      (field) =>\n        `${encodeSegmentText(field, COMPONENT_UNSAFE_CHARS)}=${encodeSegmentText(String(variant[field]), COMPONENT_UNSAFE_CHARS)}`\n    )\n    .join('&');\n};\n\n/**\n * Serializes the variant coordinate of a selector into the ordered list of\n * candidate ids to try, so a single value and a preference chain share one code\n * path downstream.\n *\n * - `undefined` → `['default']`\n * - a single value → its one serialization\n * - a chain → one serialization per entry, order preserved\n *\n * An empty chain is treated as \"no variant pinned\" (`['default']`) rather than\n * as an unsatisfiable request.\n */\nexport const serializeVariantChain = (\n  variant: DictionaryVariantChain | undefined\n): string[] => {\n  if (!Array.isArray(variant)) {\n    return [serializeVariant(variant as DictionaryVariantValue | undefined)];\n  }\n\n  if (variant.length === 0) return [DEFAULT_VARIANT_ID];\n\n  return variant.map(serializeVariant);\n};\n\n/**\n * Resolves the variant id a selector actually targets among the ids a key\n * declares — the sparse-override fallback.\n *\n * Candidates are tried in order and the first one the key declares wins.\n * Otherwise the key falls back to its `default` entry, so a variant only has to\n * be declared where its wording differs. When the key declares no `default`\n * either, the first candidate is returned unchanged and the caller resolves to\n * `null` / `[]`.\n *\n * @param requestedVariantIds - The serialized ids the selector asks for, in\n *                              preference order (a single value is a 1-element\n *                              list).\n * @param isVariantIdDeclared - Whether the key declares an entry for an id.\n */\nexport const resolveEffectiveVariantId = (\n  requestedVariantIds: string[],\n  isVariantIdDeclared: (variantId: string) => boolean\n): string => {\n  for (const requestedVariantId of requestedVariantIds) {\n    if (isVariantIdDeclared(requestedVariantId)) return requestedVariantId;\n  }\n\n  return isVariantIdDeclared(DEFAULT_VARIANT_ID)\n    ? DEFAULT_VARIANT_ID\n    : (requestedVariantIds[0] ?? DEFAULT_VARIANT_ID);\n};\n\n/**\n * Tests whether a composite entry id matches a selector across every declared\n * dimension. Segments are compared in their encoded form (both the stored id\n * and the selector go through {@link serializeVariant}). The `item` dimension\n * matches any value when the selector does not provide one (open collection\n * axis); the `variant` dimension is compared against the already-resolved\n * effective id, so the fallback is applied consistently across dimensions.\n */\nconst compositeIdMatchesSelector = (\n  compositeId: string,\n  qualifierTypes: DictionaryQualifierType[],\n  selector: DictionarySelector | undefined,\n  effectiveVariantId: string\n): boolean => {\n  const segments = compositeId.split(COMPOSITE_ID_SEPARATOR);\n\n  return qualifierTypes.every((qualifierType, index) => {\n    if (qualifierType === 'variant') {\n      return segments[index] === effectiveVariantId;\n    }\n\n    // qualifierType === 'item'\n    return (\n      selector?.item === undefined || segments[index] === String(selector.item)\n    );\n  });\n};\n\n/**\n * Type guard discriminating a `QualifiedDictionaryGroup` (merge output of a\n * qualified key) from a plain `Dictionary`. Both carry a `content` field; only\n * the group declares `qualifierTypes`, which is therefore the discriminator.\n */\nexport const isQualifiedDictionaryGroup = (\n  value: unknown\n): value is QualifiedDictionaryGroup =>\n  typeof value === 'object' &&\n  value !== null &&\n  'qualifierTypes' in value &&\n  Array.isArray((value as { qualifierTypes: unknown }).qualifierTypes) &&\n  'content' in value;\n\n/**\n * Reconstructs a resolvable {@link Dictionary} from a single entry of a\n * qualified group: the content node stored under its composite id, plus the\n * qualifier coordinates decoded from that id (`variant`, `item`).\n *\n * This keeps the resolver's transform code unchanged: it still sees a\n * `{ key, content, variant?, item? }` shape, even though the stored format no\n * longer duplicates those fields per entry. The `variant` coordinate stays in\n * its serialized (encoded) form, e.g. `'id=abc&userId=123'` — matching happens\n * on the composite id segments, never on this reconstructed field.\n */\nexport const reconstructQualifiedEntry = (\n  group: QualifiedDictionaryGroup,\n  compositeId: string\n): Dictionary => {\n  const segments = compositeId.split(COMPOSITE_ID_SEPARATOR);\n\n  const entry = {\n    key: group.key,\n    content: group.content[compositeId],\n  } as Dictionary;\n\n  group.qualifierTypes.forEach((qualifierType, index) => {\n    if (qualifierType === 'variant') {\n      entry.variant = segments[index];\n    } else if (qualifierType === 'item') {\n      entry.item = Number(segments[index]);\n    }\n  });\n\n  return entry;\n};\n\n/**\n * Resolves a dictionary (or qualified dictionary group) against a selector,\n * across every declared dimension.\n *\n * - Plain dictionary → returned as-is (selector ignored)\n * - `item` declared but not selected → every matching entry ordered by index\n * - `item` selected → the matching entry or null\n * - `variant` defaults to the `default` entry when not selected, and falls back\n *   to it when the selected variant declares no entry of its own; an object\n *   variant resolves only when the selector provides an equal object (or, again,\n *   through the `default` fallback)\n *\n * Dimensions compose: e.g. a variant × item key with `{ variant: 'promo' }`\n * returns every promo item as an array; adding `{ item: 2 }` narrows to one.\n */\nexport const resolveQualifiedDictionary = (\n  dictionaryOrGroup: Dictionary | QualifiedDictionaryGroup,\n  selector?: DictionarySelector\n): Dictionary | Dictionary[] | null => {\n  if (!isQualifiedDictionaryGroup(dictionaryOrGroup)) {\n    return dictionaryOrGroup;\n  }\n\n  const { qualifierTypes, content } = dictionaryOrGroup;\n\n  const itemAxisOpen =\n    qualifierTypes.includes('item') && selector?.item === undefined;\n\n  const compositeIds = Object.keys(content);\n  const variantIndex = qualifierTypes.indexOf('variant');\n\n  const effectiveVariantId =\n    variantIndex === -1\n      ? DEFAULT_VARIANT_ID\n      : resolveEffectiveVariantId(\n          serializeVariantChain(selector?.variant),\n          (variantId) =>\n            compositeIds.some(\n              (compositeId) =>\n                compositeId.split(COMPOSITE_ID_SEPARATOR)[variantIndex] ===\n                variantId\n            )\n        );\n\n  const matchedEntries = compositeIds\n    .filter((compositeId) =>\n      compositeIdMatchesSelector(\n        compositeId,\n        qualifierTypes,\n        selector,\n        effectiveVariantId\n      )\n    )\n    .map((compositeId) =>\n      reconstructQualifiedEntry(dictionaryOrGroup, compositeId)\n    );\n\n  if (itemAxisOpen) {\n    return matchedEntries.sort(\n      (left, right) => (left.item ?? 0) - (right.item ?? 0)\n    );\n  }\n\n  return matchedEntries[0] ?? null;\n};\n\n/**\n * Splits the second argument of `getIntlayer` / `getDictionary` into the\n * effective locale and the selector object (if any).\n */\nexport const parseDictionarySelector = <L extends LocalesValues>(\n  localeOrSelector?: L | DictionarySelector\n): { locale?: L; selector?: DictionarySelector } => {\n  if (typeof localeOrSelector === 'object' && localeOrSelector !== null) {\n    return {\n      locale: localeOrSelector.locale as L | undefined,\n      selector: localeOrSelector,\n    };\n  }\n\n  return { locale: localeOrSelector };\n};\n\n/**\n * Resolves the variant a provider pins for one dictionary key.\n *\n * A string or a chain applies to every key as-is. A plain object is the per-key\n * map: the entry for `dictionaryKey` wins, falling back to the reserved\n * `default` entry, and `undefined` when neither is present (the key then\n * resolves to its own `default` variant, i.e. the behaviour without a provider\n * variant at all).\n *\n * A plain object is **always** the map here — never a structured variant value,\n * which is why a structured variant has to be nested (`{ default: { id } }`).\n *\n * @param providerVariant - The `variant` prop of the surrounding provider.\n * @param dictionaryKey - The key being read.\n */\nexport const resolveProviderVariant = (\n  providerVariant: ProviderVariant | undefined,\n  dictionaryKey: string\n): DictionaryVariantChain | undefined => {\n  if (providerVariant === undefined) return undefined;\n\n  if (typeof providerVariant === 'string' || Array.isArray(providerVariant)) {\n    return providerVariant as DictionaryVariantChain;\n  }\n\n  const variantMap = providerVariant as ProviderVariantMap;\n\n  return variantMap[dictionaryKey] ?? variantMap[DEFAULT_VARIANT_ID];\n};\n\n/**\n * Builds the effective second argument of a dictionary read by layering the\n * provider defaults under the call-site one — the single place the `locale` and\n * `variant` context defaults are applied, shared by every framework binding.\n *\n * Precedence, per dimension independently:\n * - a call-site selector always wins; `{ variant: 'x' }` **replaces** the\n *   provider chain rather than extending it\n * - otherwise the provider value applies\n *\n * Returns a bare locale (not a selector object) whenever no variant is in play,\n * so the existing fast path — and the cache keys built from it — are unchanged\n * for projects that never use variants.\n */\nexport const resolveDictionaryArgument = (params: {\n  localeOrSelector?: LocalesValues | DictionarySelector;\n  contextLocale?: LocalesValues;\n  contextVariant?: ProviderVariant;\n  dictionaryKey: string;\n}): LocalesValues | DictionarySelector | undefined => {\n  const { localeOrSelector, contextLocale, contextVariant, dictionaryKey } =\n    params;\n\n  const callSelector =\n    typeof localeOrSelector === 'object' && localeOrSelector !== null\n      ? localeOrSelector\n      : undefined;\n\n  const callLocale = callSelector\n    ? callSelector.locale\n    : (localeOrSelector as LocalesValues | undefined);\n\n  // The context locale is typed as widely as the runtime allows, while a\n  // selector narrows `locale` to the declared ones — the value is the same.\n  const locale = (callLocale ?? contextLocale) as DictionarySelector['locale'];\n\n  // A call-site variant is authoritative; the provider only fills the gap.\n  const variant =\n    callSelector?.variant ??\n    resolveProviderVariant(contextVariant, dictionaryKey);\n\n  if (variant === undefined) {\n    // Nothing to add: keep the argument in its original shape so the identity\n    // built from it stays byte-identical to the pre-variant behaviour.\n    return callSelector\n      ? { ...callSelector, locale }\n      : (locale as LocalesValues | undefined);\n  }\n\n  return { ...callSelector, locale, variant };\n};\n\n/**\n * Builds a stable string identity of a selector (excluding `locale`), suitable\n * for cache keys and memoization dependencies.\n */\nexport const getDictionarySelectorCacheKey = (\n  selector?: DictionarySelector\n): string => {\n  if (!selector) return '';\n\n  return Object.keys(selector)\n    .filter((selectorKey) => selectorKey !== 'locale')\n    .sort()\n    .map((selectorKey) => {\n      const value = selector[selectorKey as keyof DictionarySelector];\n      const serialized =\n        selectorKey === 'variant'\n          ? serializeVariantChain(\n              value as DictionaryVariantChain | undefined\n            ).join(',')\n          : String(value);\n      return `${selectorKey}:${serialized}`;\n    })\n    .join('|');\n};\n"],"mappings":"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"}
+{"version":3,"file":"qualifiedDictionary.cjs","names":[],"sources":["../../../src/dictionaryManipulator/qualifiedDictionary.ts"],"sourcesContent":["import type {\n  Dictionary,\n  DictionaryQualifierType,\n  DictionarySelector,\n  DictionaryVariantChain,\n  DictionaryVariantValue,\n  ProviderVariantBase,\n  ProviderVariantMap,\n  QualifiedDictionaryGroup,\n} from '@intlayer/types/dictionary';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\n\n/**\n * Separator joining per-dimension ids into a composite entry id. Also used as\n * the chunk path separator in dynamic mode.\n */\nexport const COMPOSITE_ID_SEPARATOR = '/';\n\n/**\n * Identity of the implicit fallback variant. A selector that pins no variant\n * resolves to it, and a variant that declares no entry of its own falls back to\n * it — so a key only has to ship the entries that actually differ.\n */\nexport const DEFAULT_VARIANT_ID = 'default';\n\n/**\n * Characters kept verbatim in an encoded qualifier segment. Everything else is\n * percent-encoded so a segment can never contain the composite-id separator\n * (`/`), path-hostile characters (`\\` `:` `*` `?` `\"` `<` `>` `|`, control\n * chars), or characters that would break the generated loader modules (`'`).\n */\nconst SEGMENT_UNSAFE_CHARS = /[^A-Za-z0-9._&=-]/g;\n\n/**\n * Stricter set for the components of an object variant: also encodes `&` and\n * `=` so the `field=value&field=value` serialization stays unambiguous.\n */\nconst COMPONENT_UNSAFE_CHARS = /[^A-Za-z0-9._-]/g;\n\n/** Percent-encodes one UTF-16 code unit as a fixed-width `%XXXX` run. */\nconst percentEncodeChar = (char: string): string =>\n  `%${char.charCodeAt(0).toString(16).toUpperCase().padStart(4, '0')}`;\n\nconst encodeSegmentText = (raw: string, unsafeChars: RegExp): string => {\n  // Bare '%' cannot be produced by encoding (every encoded run is %XXXX),\n  // so it is a safe stand-in for the empty string.\n  if (raw === '') return '%';\n\n  const encoded = raw.replace(unsafeChars, percentEncodeChar);\n\n  // '.' and '..' are path navigation on every filesystem — encode the dots.\n  if (encoded === '.' || encoded === '..') {\n    return encoded.replace(/\\./g, '%002E');\n  }\n\n  return encoded;\n};\n\n/**\n * Canonical serialization of a single variant value into its identity string —\n * the variant segment of a composite id, the chunk directory name in dynamic\n * mode, and the runtime matching key.\n *\n * - `undefined` → `'default'` (the implicit fallback variant)\n * - a string → the string itself (a named variant)\n * - an object → its sorted `key=value` pairs joined by `&`\n *   (e.g. `{ userId: '123', id: 'abc' }` → `'id=abc&userId=123'`)\n *\n * Characters that are unsafe in file paths or generated code are\n * percent-encoded (fixed-width `%XXXX` runs, injective). Common names —\n * letters, digits, `-` `_` `.` — are left untouched. Both the declaration and\n * the selector go through this function, so encoding never affects matching.\n *\n * Two variants resolve to the same entry iff their serializations are equal, so\n * an object variant in a selector must equal the one declared on the dictionary.\n */\nexport const serializeVariant = (\n  variant: DictionaryVariantValue | undefined\n): string => {\n  if (variant === undefined) return DEFAULT_VARIANT_ID;\n  if (typeof variant === 'string') {\n    return encodeSegmentText(variant, SEGMENT_UNSAFE_CHARS);\n  }\n\n  return Object.keys(variant)\n    .sort()\n    .map(\n      (field) =>\n        `${encodeSegmentText(field, COMPONENT_UNSAFE_CHARS)}=${encodeSegmentText(String(variant[field]), COMPONENT_UNSAFE_CHARS)}`\n    )\n    .join('&');\n};\n\n/**\n * Serializes the variant coordinate of a selector into the ordered list of\n * candidate ids to try, so a single value and a preference chain share one code\n * path downstream.\n *\n * - `undefined` → `['default']`\n * - a single value → its one serialization\n * - a chain → one serialization per entry, order preserved\n *\n * An empty chain is treated as \"no variant pinned\" (`['default']`) rather than\n * as an unsatisfiable request.\n */\nexport const serializeVariantChain = (\n  variant: DictionaryVariantChain | undefined\n): string[] => {\n  if (!Array.isArray(variant)) {\n    return [serializeVariant(variant as DictionaryVariantValue | undefined)];\n  }\n\n  if (variant.length === 0) return [DEFAULT_VARIANT_ID];\n\n  return variant.map(serializeVariant);\n};\n\n/**\n * Resolves the variant id a selector actually targets among the ids a key\n * declares — the sparse-override fallback.\n *\n * Candidates are tried in order and the first one the key declares wins.\n * Otherwise the key falls back to its `default` entry, so a variant only has to\n * be declared where its wording differs. When the key declares no `default`\n * either, the first candidate is returned unchanged and the caller resolves to\n * `null` / `[]`.\n *\n * @param requestedVariantIds - The serialized ids the selector asks for, in\n *                              preference order (a single value is a 1-element\n *                              list).\n * @param isVariantIdDeclared - Whether the key declares an entry for an id.\n */\nexport const resolveEffectiveVariantId = (\n  requestedVariantIds: string[],\n  isVariantIdDeclared: (variantId: string) => boolean\n): string => {\n  for (const requestedVariantId of requestedVariantIds) {\n    if (isVariantIdDeclared(requestedVariantId)) return requestedVariantId;\n  }\n\n  return isVariantIdDeclared(DEFAULT_VARIANT_ID)\n    ? DEFAULT_VARIANT_ID\n    : (requestedVariantIds[0] ?? DEFAULT_VARIANT_ID);\n};\n\n/**\n * Tests whether a composite entry id matches a selector across every declared\n * dimension. Segments are compared in their encoded form (both the stored id\n * and the selector go through {@link serializeVariant}). The `item` dimension\n * matches any value when the selector does not provide one (open collection\n * axis); the `variant` dimension is compared against the already-resolved\n * effective id, so the fallback is applied consistently across dimensions.\n */\nconst compositeIdMatchesSelector = (\n  compositeId: string,\n  qualifierTypes: DictionaryQualifierType[],\n  selector: DictionarySelector | undefined,\n  effectiveVariantId: string\n): boolean => {\n  const segments = compositeId.split(COMPOSITE_ID_SEPARATOR);\n\n  return qualifierTypes.every((qualifierType, index) => {\n    if (qualifierType === 'variant') {\n      return segments[index] === effectiveVariantId;\n    }\n\n    // qualifierType === 'item'\n    return (\n      selector?.item === undefined || segments[index] === String(selector.item)\n    );\n  });\n};\n\n/**\n * Type guard discriminating a `QualifiedDictionaryGroup` (merge output of a\n * qualified key) from a plain `Dictionary`. Both carry a `content` field; only\n * the group declares `qualifierTypes`, which is therefore the discriminator.\n */\nexport const isQualifiedDictionaryGroup = (\n  value: unknown\n): value is QualifiedDictionaryGroup =>\n  typeof value === 'object' &&\n  value !== null &&\n  'qualifierTypes' in value &&\n  Array.isArray((value as { qualifierTypes: unknown }).qualifierTypes) &&\n  'content' in value;\n\n/**\n * Reconstructs a resolvable {@link Dictionary} from a single entry of a\n * qualified group: the content node stored under its composite id, plus the\n * qualifier coordinates decoded from that id (`variant`, `item`).\n *\n * This keeps the resolver's transform code unchanged: it still sees a\n * `{ key, content, variant?, item? }` shape, even though the stored format no\n * longer duplicates those fields per entry. The `variant` coordinate stays in\n * its serialized (encoded) form, e.g. `'id=abc&userId=123'` — matching happens\n * on the composite id segments, never on this reconstructed field.\n */\nexport const reconstructQualifiedEntry = (\n  group: QualifiedDictionaryGroup,\n  compositeId: string\n): Dictionary => {\n  const segments = compositeId.split(COMPOSITE_ID_SEPARATOR);\n\n  const entry = {\n    key: group.key,\n    content: group.content[compositeId],\n  } as Dictionary;\n\n  group.qualifierTypes.forEach((qualifierType, index) => {\n    if (qualifierType === 'variant') {\n      entry.variant = segments[index];\n    } else if (qualifierType === 'item') {\n      entry.item = Number(segments[index]);\n    }\n  });\n\n  return entry;\n};\n\n/**\n * Resolves a dictionary (or qualified dictionary group) against a selector,\n * across every declared dimension.\n *\n * - Plain dictionary → returned as-is (selector ignored)\n * - `item` declared but not selected → every matching entry ordered by index\n * - `item` selected → the matching entry or null\n * - `variant` defaults to the `default` entry when not selected, and falls back\n *   to it when the selected variant declares no entry of its own; an object\n *   variant resolves only when the selector provides an equal object (or, again,\n *   through the `default` fallback)\n *\n * Dimensions compose: e.g. a variant × item key with `{ variant: 'promo' }`\n * returns every promo item as an array; adding `{ item: 2 }` narrows to one.\n */\nexport const resolveQualifiedDictionary = (\n  dictionaryOrGroup: Dictionary | QualifiedDictionaryGroup,\n  selector?: DictionarySelector\n): Dictionary | Dictionary[] | null => {\n  if (!isQualifiedDictionaryGroup(dictionaryOrGroup)) {\n    return dictionaryOrGroup;\n  }\n\n  const { qualifierTypes, content } = dictionaryOrGroup;\n\n  const itemAxisOpen =\n    qualifierTypes.includes('item') && selector?.item === undefined;\n\n  const compositeIds = Object.keys(content);\n  const variantIndex = qualifierTypes.indexOf('variant');\n\n  const effectiveVariantId =\n    variantIndex === -1\n      ? DEFAULT_VARIANT_ID\n      : resolveEffectiveVariantId(\n          serializeVariantChain(selector?.variant),\n          (variantId) =>\n            compositeIds.some(\n              (compositeId) =>\n                compositeId.split(COMPOSITE_ID_SEPARATOR)[variantIndex] ===\n                variantId\n            )\n        );\n\n  const matchedEntries = compositeIds\n    .filter((compositeId) =>\n      compositeIdMatchesSelector(\n        compositeId,\n        qualifierTypes,\n        selector,\n        effectiveVariantId\n      )\n    )\n    .map((compositeId) =>\n      reconstructQualifiedEntry(dictionaryOrGroup, compositeId)\n    );\n\n  if (itemAxisOpen) {\n    return matchedEntries.sort(\n      (left, right) => (left.item ?? 0) - (right.item ?? 0)\n    );\n  }\n\n  return matchedEntries[0] ?? null;\n};\n\n/**\n * Splits the second argument of `getIntlayer` / `getDictionary` into the\n * effective locale and the selector object (if any).\n */\nexport const parseDictionarySelector = <L extends LocalesValues>(\n  localeOrSelector?: L | DictionarySelector\n): { locale?: L; selector?: DictionarySelector } => {\n  if (typeof localeOrSelector === 'object' && localeOrSelector !== null) {\n    return {\n      locale: localeOrSelector.locale as L | undefined,\n      selector: localeOrSelector,\n    };\n  }\n\n  return { locale: localeOrSelector };\n};\n\n/**\n * Resolves the variant a provider pins for one dictionary key.\n *\n * A string or a chain applies to every key as-is. A plain object is the per-key\n * map: the entry for `dictionaryKey` wins, falling back to the reserved\n * `default` entry, and `undefined` when neither is present (the key then\n * resolves to its own `default` variant, i.e. the behaviour without a provider\n * variant at all).\n *\n * A plain object is **always** the map here — never a structured variant value,\n * which is why a structured variant has to be nested (`{ default: { id } }`).\n *\n * @param providerVariant - The `variant` prop of the surrounding provider.\n * @param dictionaryKey - The key being read.\n */\nexport const resolveProviderVariant = (\n  providerVariant: ProviderVariantBase | undefined,\n  dictionaryKey: string\n): DictionaryVariantChain | undefined => {\n  if (providerVariant === undefined) return undefined;\n\n  if (typeof providerVariant === 'string' || Array.isArray(providerVariant)) {\n    return providerVariant as DictionaryVariantChain;\n  }\n\n  const variantMap = providerVariant as ProviderVariantMap;\n\n  return variantMap[dictionaryKey] ?? variantMap[DEFAULT_VARIANT_ID];\n};\n\n/**\n * Builds the effective second argument of a dictionary read by layering the\n * provider defaults under the call-site one — the single place the `locale` and\n * `variant` context defaults are applied, shared by every framework binding.\n *\n * Precedence, per dimension independently:\n * - a call-site selector always wins; `{ variant: 'x' }` **replaces** the\n *   provider chain rather than extending it\n * - otherwise the provider value applies\n *\n * Returns a bare locale (not a selector object) whenever no variant is in play,\n * so the existing fast path — and the cache keys built from it — are unchanged\n * for projects that never use variants.\n */\nexport const resolveDictionaryArgument = (params: {\n  localeOrSelector?: LocalesValues | DictionarySelector;\n  contextLocale?: LocalesValues;\n  contextVariant?: ProviderVariantBase;\n  dictionaryKey: string;\n}): LocalesValues | DictionarySelector | undefined => {\n  const { localeOrSelector, contextLocale, contextVariant, dictionaryKey } =\n    params;\n\n  const callSelector =\n    typeof localeOrSelector === 'object' && localeOrSelector !== null\n      ? localeOrSelector\n      : undefined;\n\n  const callLocale = callSelector\n    ? callSelector.locale\n    : (localeOrSelector as LocalesValues | undefined);\n\n  // The context locale is typed as widely as the runtime allows, while a\n  // selector narrows `locale` to the declared ones — the value is the same.\n  const locale = (callLocale ?? contextLocale) as DictionarySelector['locale'];\n\n  // A call-site variant is authoritative; the provider only fills the gap.\n  const variant =\n    callSelector?.variant ??\n    resolveProviderVariant(contextVariant, dictionaryKey);\n\n  if (variant === undefined) {\n    // Nothing to add: keep the argument in its original shape so the identity\n    // built from it stays byte-identical to the pre-variant behaviour.\n    return callSelector\n      ? { ...callSelector, locale }\n      : (locale as LocalesValues | undefined);\n  }\n\n  return { ...callSelector, locale, variant };\n};\n\n/**\n * Builds a stable string identity of a selector (excluding `locale`), suitable\n * for cache keys and memoization dependencies.\n */\nexport const getDictionarySelectorCacheKey = (\n  selector?: DictionarySelector\n): string => {\n  if (!selector) return '';\n\n  return Object.keys(selector)\n    .filter((selectorKey) => selectorKey !== 'locale')\n    .sort()\n    .map((selectorKey) => {\n      const value = selector[selectorKey as keyof DictionarySelector];\n      const serialized =\n        selectorKey === 'variant'\n          ? serializeVariantChain(\n              value as DictionaryVariantChain | undefined\n            ).join(',')\n          : String(value);\n      return `${selectorKey}:${serialized}`;\n    })\n    .join('|');\n};\n"],"mappings":"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"}

package/dist/cjs/formatters/list.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"list.cjs","names":["getCachedIntl","internationalization"],"sources":["../../../src/formatters/list.ts"],"sourcesContent":["import { internationalization } from '@intlayer/config/built';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport { getCachedIntl } from '../utils/intl';\n\n/** Locally defined subset of Intl.ListFormatOptions so consumers don't need ES2021.Intl in their lib. */\ntype ListFormatOptions = {\n  localeMatcher?: 'lookup' | 'best fit';\n  type?: 'conjunction' | 'disjunction' | 'unit';\n  style?: 'long' | 'short' | 'narrow';\n};\n\n/**\n * Formats an array of values into a localized list string using the Intl API.\n *\n * @example\n * list(['apple', 'banana', 'orange']);\n * // \"apple, banana, and orange\"\n *\n * @example\n * list(['red', 'green', 'blue'], { locale: Locales.FRENCH, type: 'disjunction' });\n * // \"rouge, vert ou bleu\"\n *\n * @example\n * list([1, 2, 3], { type: 'unit' });\n * // \"1, 2, 3\"\n */\nexport const list = (\n  values: (string | number)[],\n  options?: ListFormatOptions & { locale?: LocalesValues }\n): string =>\n  getCachedIntl(\n    'ListFormat',\n    options?.locale ?? internationalization?.defaultLocale,\n\n    {\n      type: options?.type ?? 'conjunction',\n      style: options?.style ?? 'long',\n      ...options,\n    }\n  ).format(values.map(String));\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AA0BA,MAAa,QACX,QACA,YAEAA,iCACE,cACA,SAAS,UAAUC,6CAAsB,eAEzC;CACE,MAAM,SAAS,QAAQ;CACvB,OAAO,SAAS,SAAS;CACzB,GAAG;AACL,CACF,CAAC,CAAC,OAAO,OAAO,IAAI,MAAM,CAAC"}
+{"version":3,"file":"list.cjs","names":["getCachedIntl","internationalization"],"sources":["../../../src/formatters/list.ts"],"sourcesContent":["import { internationalization } from '@intlayer/config/built';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport { getCachedIntl } from '../utils/intl';\n\n/** Locally defined subset of Intl.ListFormatOptions so consumers don't need ES2021.Intl in their lib. */\nexport type ListFormatOptions = {\n  localeMatcher?: 'lookup' | 'best fit';\n  type?: 'conjunction' | 'disjunction' | 'unit';\n  style?: 'long' | 'short' | 'narrow';\n};\n\n/**\n * Formats an array of values into a localized list string using the Intl API.\n *\n * @example\n * list(['apple', 'banana', 'orange']);\n * // \"apple, banana, and orange\"\n *\n * @example\n * list(['red', 'green', 'blue'], { locale: Locales.FRENCH, type: 'disjunction' });\n * // \"rouge, vert ou bleu\"\n *\n * @example\n * list([1, 2, 3], { type: 'unit' });\n * // \"1, 2, 3\"\n */\nexport const list = (\n  values: (string | number)[],\n  options?: ListFormatOptions & { locale?: LocalesValues }\n): string =>\n  getCachedIntl(\n    'ListFormat',\n    options?.locale ?? internationalization?.defaultLocale,\n\n    {\n      type: options?.type ?? 'conjunction',\n      style: options?.style ?? 'long',\n      ...options,\n    }\n  ).format(values.map(String));\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AA0BA,MAAa,QACX,QACA,YAEAA,iCACE,cACA,SAAS,UAAUC,6CAAsB,eAEzC;CACE,MAAM,SAAS,QAAQ;CACvB,OAAO,SAAS,SAAS;CACzB,GAAG;AACL,CACF,CAAC,CAAC,OAAO,OAAO,IAAI,MAAM,CAAC"}

package/dist/cjs/index.cjs

@@ -131,8 +131,6 @@ exports.CODE_INLINE_R = require_markdown_constants.CODE_INLINE_R;
 exports.COMPOSITE_ID_SEPARATOR = require_dictionaryManipulator_qualifiedDictionary.COMPOSITE_ID_SEPARATOR;
 exports.CONSECUTIVE_NEWLINE_R = require_markdown_constants.CONSECUTIVE_NEWLINE_R;
 exports.CR_NEWLINE_R = require_markdown_constants.CR_NEWLINE_R;
-exports.CUSTOM_COMPONENT_OPENING_TAG_R = require_markdown_constants.CUSTOM_COMPONENT_OPENING_TAG_R;
-exports.CUSTOM_COMPONENT_R = require_markdown_constants.CUSTOM_COMPONENT_R;
 exports.CachedIntl = require_utils_intl.CachedIntl;
 exports.Intl = require_utils_intl.CachedIntl;
 exports.DEFAULT_VARIANT_ID = require_dictionaryManipulator_qualifiedDictionary.DEFAULT_VARIANT_ID;
@@ -146,14 +144,10 @@ exports.GFM_TASK_R = require_markdown_constants.GFM_TASK_R;
 exports.HEADING_ATX_COMPLIANT_R = require_markdown_constants.HEADING_ATX_COMPLIANT_R;
 exports.HEADING_R = require_markdown_constants.HEADING_R;
 exports.HEADING_SETEXT_R = require_markdown_constants.HEADING_SETEXT_R;
-exports.HTML_BLOCK_ELEMENT_R = require_markdown_constants.HTML_BLOCK_ELEMENT_R;
-exports.HTML_BLOCK_OPENING_TAG_R = require_markdown_constants.HTML_BLOCK_OPENING_TAG_R;
 exports.HTML_CHAR_CODE_R = require_markdown_constants.HTML_CHAR_CODE_R;
 exports.HTML_COMMENT_R = require_markdown_constants.HTML_COMMENT_R;
 exports.HTML_CUSTOM_ATTR_R = require_markdown_constants.HTML_CUSTOM_ATTR_R;
 exports.HTML_LEFT_TRIM_AMOUNT_R = require_markdown_constants.HTML_LEFT_TRIM_AMOUNT_R;
-exports.HTML_SELF_CLOSING_ELEMENT_R = require_markdown_constants.HTML_SELF_CLOSING_ELEMENT_R;
-exports.HTML_SELF_CLOSING_OPENING_TAG_R = require_markdown_constants.HTML_SELF_CLOSING_OPENING_TAG_R;
 exports.HTML_TAGS = require_transpiler_html_htmlTags.HTML_TAGS;
 exports.INLINE_SKIP_R = require_markdown_constants.INLINE_SKIP_R;
 exports.INTERPOLATION_R = require_markdown_constants.INTERPOLATION_R;
@@ -164,7 +158,6 @@ exports.LocaleStorage = require_utils_localeStorage.LocaleStorage;
 exports.LocaleStorageClient = require_utils_localeStorage.LocaleStorageClient;
 exports.LocaleStorageServer = require_utils_localeStorage.LocaleStorageServer;
 exports.NAMED_CODES_TO_UNICODE = require_markdown_constants.NAMED_CODES_TO_UNICODE;
-exports.NORMALIZE_WHITESPACE_R = require_markdown_constants.NORMALIZE_WHITESPACE_R;
 exports.NP_TABLE_R = require_markdown_constants.NP_TABLE_R;
 exports.ORDERED = require_markdown_constants.ORDERED;
 exports.ORDERED_LIST_BULLET = require_markdown_constants.ORDERED_LIST_BULLET;
@@ -180,7 +173,11 @@ exports.QUALIFIER_ORDER = require_dictionaryManipulator_qualifiedDictionaryDecla
 exports.REFERENCE_IMAGE_OR_LINK = require_markdown_constants.REFERENCE_IMAGE_OR_LINK;
 exports.REFERENCE_IMAGE_R = require_markdown_constants.REFERENCE_IMAGE_R;
 exports.REFERENCE_LINK_R = require_markdown_constants.REFERENCE_LINK_R;
+exports.RuleScope = require_markdown_constants.RuleScope;
 exports.RuleType = require_markdown_constants.RuleType;
+exports.SCOPE_BLOCK = require_markdown_constants.SCOPE_BLOCK;
+exports.SCOPE_BOTH = require_markdown_constants.SCOPE_BOTH;
+exports.SCOPE_INLINE = require_markdown_constants.SCOPE_INLINE;
 exports.SHORTCODE_R = require_markdown_constants.SHORTCODE_R;
 exports.SHOULD_RENDER_AS_BLOCK_R = require_markdown_constants.SHOULD_RENDER_AS_BLOCK_R;
 exports.TABLE_CENTER_ALIGN = require_markdown_constants.TABLE_CENTER_ALIGN;
@@ -192,7 +189,6 @@ exports.TEXT_BOLD_R = require_markdown_constants.TEXT_BOLD_R;
 exports.TEXT_EMPHASIZED_R = require_markdown_constants.TEXT_EMPHASIZED_R;
 exports.TEXT_ESCAPED_R = require_markdown_constants.TEXT_ESCAPED_R;
 exports.TEXT_MARKED_R = require_markdown_constants.TEXT_MARKED_R;
-exports.TEXT_PLAIN_R = require_markdown_constants.TEXT_PLAIN_R;
 exports.TEXT_STRIKETHROUGHED_R = require_markdown_constants.TEXT_STRIKETHROUGHED_R;
 exports.TRIM_STARTING_NEWLINES = require_markdown_constants.TRIM_STARTING_NEWLINES;
 exports.UNESCAPE_R = require_markdown_constants.UNESCAPE_R;
@@ -313,6 +309,7 @@ exports.getPreloadedDictionary = require_dictionaryManipulator_preloadedDynamicL
 exports.getReplacedValuesContent = require_deepTransformPlugins_getReplacedValuesContent.getReplacedValuesContent;
 exports.getRewritePath = require_localization_rewriteUtils.getRewritePath;
 exports.getRewriteRules = require_localization_rewriteMatch.getRewriteRules;
+exports.getRuleSet = require_markdown_compiler.getRuleSet;
 exports.getSelect = require_interpreter_getSelect.getSelect;
 exports.getSplittedContent = require_deepTransformPlugins_getSplittedContent.getSplittedContent;
 exports.getSplittedDictionaryContent = require_deepTransformPlugins_getSplittedContent.getSplittedDictionaryContent;

package/dist/cjs/interpreter/getPlural.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"getPlural.cjs","names":["getCachedIntl"],"sources":["../../../src/interpreter/getPlural.ts"],"sourcesContent":["import type { DeclaredLocales } from '@intlayer/types';\nimport type { LocalesValues } from 'intlayer';\nimport { getCachedIntl } from '../formatters';\nimport type {\n  PluralCategory,\n  PluralContentState,\n} from '../transpiler/plural/plural';\n\n/**\n * Picks content from a plural map based on a count and locale, using CLDR\n * pluralization rules (`Intl.PluralRules`).\n *\n * Falls back to the `other` category when no specific category matches.\n *\n * @example\n * ```ts\n * getPlural({\n *   one: 'one item',\n *   other: '{{count}} items',\n * }, 5, 'en');\n * // '{{count}} items'\n * ```\n */\nexport const getPlural = <const L extends LocalesValues = DeclaredLocales>(\n  pluralContent: PluralContentState<string>,\n  count: number,\n  locale: L\n): string => {\n  const category = getCachedIntl('PluralRules', locale).select(\n    count\n  ) as PluralCategory;\n\n  return pluralContent[category] ?? pluralContent.other;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAuBA,MAAa,aACX,eACA,OACA,WACW;CAKX,OAAO,cAJUA,iCAAc,eAAe,MAAM,CAAC,CAAC,OACpD,KAG0B,MAAM,cAAc;AAClD"}
+{"version":3,"file":"getPlural.cjs","names":["getCachedIntl"],"sources":["../../../src/interpreter/getPlural.ts"],"sourcesContent":["import type { DeclaredLocales } from '@intlayer/types';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport { getCachedIntl } from '../formatters';\nimport type {\n  PluralCategory,\n  PluralContentState,\n} from '../transpiler/plural/plural';\n\n/**\n * Picks content from a plural map based on a count and locale, using CLDR\n * pluralization rules (`Intl.PluralRules`).\n *\n * Falls back to the `other` category when no specific category matches.\n *\n * @example\n * ```ts\n * getPlural({\n *   one: 'one item',\n *   other: '{{count}} items',\n * }, 5, 'en');\n * // '{{count}} items'\n * ```\n */\nexport const getPlural = <const L extends LocalesValues = DeclaredLocales>(\n  pluralContent: PluralContentState<string>,\n  count: number,\n  locale: L\n): string => {\n  const category = getCachedIntl('PluralRules', locale).select(\n    count\n  ) as PluralCategory;\n\n  return pluralContent[category] ?? pluralContent.other;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAuBA,MAAa,aACX,eACA,OACA,WACW;CAKX,OAAO,cAJUA,iCAAc,eAAe,MAAM,CAAC,CAAC,OACpD,KAG0B,MAAM,cAAc;AAClD"}