Variables

[
  {
    file: 'projects/forms/input/phone-input/countries.ts',
    value: 'United States',
    note: 'default row of CNGX_PHONE_COUNTRIES, replaced wholesale via CngxPhoneInput [countries]',
  },
  {
    file: 'projects/forms/input/phone-input/countries.ts',
    value: 'United Kingdom',
    note: 'default row of CNGX_PHONE_COUNTRIES, replaced wholesale via CngxPhoneInput [countries]',
  },
  {
    file: 'projects/forms/input/phone-input/countries.ts',
    value: 'Germany',
    note: 'default row of CNGX_PHONE_COUNTRIES, replaced wholesale via CngxPhoneInput [countries]',
  },
  {
    file: 'projects/forms/input/phone-input/countries.ts',
    value: 'Austria',
    note: 'default row of CNGX_PHONE_COUNTRIES, replaced wholesale via CngxPhoneInput [countries]',
  },
  {
    file: 'projects/forms/input/phone-input/countries.ts',
    value: 'Switzerland',
    note: 'default row of CNGX_PHONE_COUNTRIES, replaced wholesale via CngxPhoneInput [countries]',
  },
  {
    file: 'projects/forms/input/phone-input/countries.ts',
    value: 'France',
    note: 'default row of CNGX_PHONE_COUNTRIES, replaced wholesale via CngxPhoneInput [countries]',
  },
  {
    file: 'projects/forms/input/phone-input/countries.ts',
    value: 'Italy',
    note: 'default row of CNGX_PHONE_COUNTRIES, replaced wholesale via CngxPhoneInput [countries]',
  },
  {
    file: 'projects/forms/input/phone-input/countries.ts',
    value: 'Spain',
    note: 'default row of CNGX_PHONE_COUNTRIES, replaced wholesale via CngxPhoneInput [countries]',
  },
  {
    file: 'projects/forms/input/phone-input/countries.ts',
    value: 'Slovenia',
    note: 'default row of CNGX_PHONE_COUNTRIES, replaced wholesale via CngxPhoneInput [countries]',
  },
  {
    file: 'projects/forms/input/phone-input/countries.ts',
    value: 'Croatia',
    note: 'default row of CNGX_PHONE_COUNTRIES, replaced wholesale via CngxPhoneInput [countries]',
  },
  {
    file: 'projects/forms/input/phone-input/countries.ts',
    value: 'Poland',
    note: 'default row of CNGX_PHONE_COUNTRIES, replaced wholesale via CngxPhoneInput [countries]',
  },
  {
    file: 'projects/forms/input/phone-input/countries.ts',
    value: 'Japan',
    note: 'default row of CNGX_PHONE_COUNTRIES, replaced wholesale via CngxPhoneInput [countries]',
  },
  {
    file: 'projects/forms/input/phone-input/countries.ts',
    value: 'Brazil',
    note: 'default row of CNGX_PHONE_COUNTRIES, replaced wholesale via CngxPhoneInput [countries]',
  },
  {
    file: 'projects/ui/action-button/action-button.ts',
    value: 'Action succeeded',
    note: 'overridden per instance by [succeededAnnouncement] then [succeededLabel]',
  },
  {
    file: 'projects/ui/action-button/action-button.ts',
    value: 'Action failed',
    note: 'overridden per instance by [failedAnnouncement] then [failedLabel]',
  },
]

[
  {
    file: 'projects/common/interactive/guard/can-deactivate.ts',
    value: 'You have unsaved changes. Leave anyway?',
    note: 'default parameter of canDeactivateWhenClean - the caller passes its own message',
  },
]

(a: PasswordStrengthResult, b: PasswordStrengthResult): boolean =>
a.score === b.score && a.label === b.label

(deps) => {
  function schedule(
    freq: number,
    durationMs: number,
    opts: ToneOptions | undefined,
    whenSec: number,
  ): void {
    const ctx = deps.context();
    const dest = deps.destination();
    const start = ctx.currentTime + whenSec + (opts?.when ?? 0);
    const durSec = Math.max(durationMs / 1000, MIN_DURATION_SEC);
    const peak = opts?.gain ?? DEFAULT_TONE_GAIN;

    const osc = ctx.createOscillator();
    osc.type = opts?.type ?? 'sine';
    osc.frequency.setValueAtTime(freq, start);

    const env = ctx.createGain();
    const holdStart = start + ATTACK_SEC;
    const releaseStart = start + durSec - RELEASE_SEC;
    env.gain.setValueAtTime(0, start);
    env.gain.linearRampToValueAtTime(peak, holdStart);
    env.gain.setValueAtTime(peak, releaseStart);
    env.gain.linearRampToValueAtTime(0, start + durSec);

    osc.connect(env);
    env.connect(dest);
    osc.start(start);
    osc.stop(start + durSec);
    osc.onended = () => {
      osc.disconnect();
      env.disconnect();
    };
  }

  return {
    tone(freq, durationMs, opts) {
      schedule(freq, durationMs, opts, 0);
    },
    sequence(steps) {
      let offsetSec = 0;
      for (const step of steps) {
        offsetSec += (step.delay ?? 0) / 1000;
        schedule(step.freq, step.duration, { type: step.type, gain: step.gain }, offsetSec);
        offsetSec += Math.max(step.duration / 1000, MIN_DURATION_SEC);
      }
    },
  };
}

{
  selected: 'Selected',
  deselected: 'Deselected',
  loading: 'Loading',
}

{
  labels: {
    axes: {
      density: 'Spacing',
      textScale: 'Text size',
      motion: 'Motion',
      contrast: 'Contrast',
    },
    reset: 'Reset to defaults',
    heading: 'Accessibility',
    resetMessage: 'Preferences reset to defaults',
  },
  axes: [
    {
      axis: 'density',
      reset: 'comfortable',
      options: [
        { value: 'compact', label: 'Compact' },
        { value: 'comfortable', label: 'Comfortable' },
        { value: 'spacious', label: 'Spacious' },
      ],
    },
    {
      axis: 'textScale',
      reset: 'md',
      options: [
        { value: 'sm', label: 'Small' },
        { value: 'md', label: 'Default' },
        { value: 'lg', label: 'Large' },
      ],
    },
    {
      axis: 'motion',
      reset: 'auto',
      options: [
        { value: 'full', label: 'Full' },
        { value: 'reduced', label: 'Reduced' },
        { value: 'auto', label: 'System' },
      ],
    },
    {
      axis: 'contrast',
      reset: 'auto',
      options: [
        { value: 'normal', label: 'Normal' },
        { value: 'more', label: 'More' },
        { value: 'auto', label: 'System' },
      ],
    },
  ],
}

{
  muted: false,
  volume: 1,
  respectReducedMotion: true,
  debounceMs: 100,
  earcons: {},
}

[
  'click',
  'focus',
  'blur',
  'pointerenter',
  'pointerleave',
  'submit',
  'change',
  'input',
] as const

[
  'pending',
  'succeeded',
  'failed',
  'loading',
  'refreshing',
  'success',
  'error',
  'idle',
] as const

[
  'click',
  'focus',
  'blur',
  'pointerenter',
  'pointerleave',
  'submit',
  'change',
  'input',
] as const

{
  idle: 'idle',
  loading: 'loading',
  pending: 'pending',
  refreshing: 'refreshing',
  success: 'success',
  succeeded: 'success',
  error: 'error',
  failed: 'error',
}

new Map<string, CngxFilterOperatorDef>([
  // Labels for the builtins live in the default i18n bundle
  // (DEFAULT_I18N.operators) - def.label is the tier for
  // consumer-registered keys only, so the string exists once.
  ['eq', { evaluate: (itemValue, exprValue) => Object.is(itemValue, exprValue) }],
  ['neq', { evaluate: (itemValue, exprValue) => !Object.is(itemValue, exprValue) }],
  ['isEmpty', { valueless: true, evaluate: (itemValue) => itemValue == null || itemValue === '' }],
  [
    'isNotEmpty',
    { valueless: true, evaluate: (itemValue) => itemValue != null && itemValue !== '' },
  ],
  ['contains', substringDef((a, b) => a.includes(b))],
  ['startsWith', substringDef((a, b) => a.startsWith(b))],
  ['endsWith', substringDef((a, b) => a.endsWith(b))],
  ['gt', { evaluate: (a, b) => compare(a, b) > 0 }],
  ['gte', { evaluate: (a, b) => compare(a, b) >= 0 }],
  ['lt', { evaluate: (a, b) => compare(a, b) < 0 }],
  ['lte', { evaluate: (a, b) => compare(a, b) <= 0 }],
  [
    'between',
    {
      // Value shape [min, max]. A non-array (or wrong-arity) value is a
      // wiring bug -> conservative false; a nullish bound means the range
      // editor is half-filled -> no-op true, mirroring the empty-value
      // guard that cannot see inside arrays.
      evaluate: (itemValue, exprValue) => {
        if (!Array.isArray(exprValue) || exprValue.length !== 2) {
          return false;
        }
        const [min, max] = exprValue as [unknown, unknown];
        if (min == null || max == null) {
          return true;
        }
        return compare(itemValue, min) >= 0 && compare(itemValue, max) <= 0;
      },
    },
  ],
  [
    'in',
    {
      // An empty list is an unfilled editor, not "match nothing" - the
      // no-op guard cannot see inside arrays, so the def honours the
      // unfilled-row contract itself (mirrors the between bound guard).
      evaluate: (itemValue, exprValue) => {
        if (!Array.isArray(exprValue)) {
          return false;
        }
        if (exprValue.length === 0) {
          return true;
        }
        return exprValue.some((v) => Object.is(v, itemValue));
      },
    },
  ],
  [
    'notIn',
    {
      evaluate: (itemValue, exprValue) => {
        if (!Array.isArray(exprValue)) {
          return false;
        }
        if (exprValue.length === 0) {
          return true;
        }
        return !exprValue.some((v) => Object.is(v, itemValue));
      },
    },
  ],
])

'a[href], button:not(:disabled), input:not(:disabled), select:not(:disabled), textarea:not(:disabled), [tabindex]:not([tabindex="-1"])'

{
  ariaLabels: {
    loading: 'Loading',
    empty: 'Nothing here yet',
    error: 'Failed to load',
    pageError: 'Failed to load more',
    retry: 'Retry',
    endReached: (total) => `All ${total} loaded`,
    loadedMore: (count, total) => `${count} more loaded. ${total} total.`,
  },
}

{
  showDelay: 120,
  minDwell: 400,
  spinnerVsSkeletonCutoff: 800,
} as const satisfies CngxLoadingConfig

{
  indent: 12,
  singleAccordion: false,
  animationDuration: 150,
}

{
  ariaLabels: {
    label: 'Pagination',
    first: 'First page',
    previous: 'Previous page',
    next: 'Next page',
    last: 'Last page',
    page: (page) => `Page ${page}`,
    morePages: 'More pages',
    itemsPerPage: 'Items per page',
    goToPage: 'Go to page',
    pageOfPages: 'Select page',
    loadMore: 'Load more',
    allLoaded: (total) => `All ${total} loaded`,
    bucket: (label) => label,
    emptyBucket: (label) => `${label}, no items`,
    bucketGroup: 'Categories',
    railPosition: 'Page position',
  },
  announcements: {
    pageChange: (page, totalPages) => `Page ${page} of ${totalPages}`,
    loading: 'Loading',
    updated: 'Updated',
  },
  formats: {
    // The readout segments render the formatter output as sanitised HTML, so the
    // current value (the page, or the item range) is emphasised with `<b>`;
    // Angular's sanitiser keeps `<b>` and strips anything dangerous.
    range: (start, end, total) => `<b>${start}-${end}</b> of ${total}`,
    pageStatus: (page, totalPages) => `Page <b>${page}</b> of ${totalPages}`,
  },
  // Includes the brain's default pageSize (10) so the trigger value is always a
  // member of the panel; a common data-table ladder, locale-neutral.
  pageSizeOptions: [10, 25, 50, 100],
}

{
  /** First-page nav (double left-pointing angle quotation mark). */
  first: '«',
  /** Previous-page nav (single left-pointing angle quotation mark). */
  previous: '‹',
  /** Next-page nav (single right-pointing angle quotation mark). */
  next: '›',
  /** Last-page nav (double right-pointing angle quotation mark). */
  last: '»',
  /** Ellipsis trigger that opens the hidden-pages overflow menu. */
  more: '…',
  /** Dropdown caret on the page-size / page-of-pages select triggers. */
  caret: '▾',
} as const

<div cngxPopover [positionTryFallbacks]="CNGX_SUBMENU_TRY_FALLBACKS">
  <!-- submenu items -->
</div>

Object.freeze([
  'flip-inline',
  'flip-block',
  'flip-block flip-inline',
] as const)

createPreferenceAxis({
  token: CNGX_CONTRAST,
  attribute: 'data-contrast',
  removeValue: 'auto',
})

(options) => {
  const doc = inject(DOCUMENT);
  const destroyRef = inject(DestroyRef);
  const toneGeneratorFactory = inject(CNGX_AUDIO_TONE_GENERATOR_FACTORY);
  const config = injectAudioConfig();
  const reducedMotion = injectMediaQuery('(prefers-reduced-motion: reduce)');

  const muted = signal(config.muted);
  const volume = signal(clampVolume(config.volume));
  const status = signal<AudioStatus>('idle');
  const lastPlayed = signal<string | null>(null);

  const gate = createAutoplayGate({ target: doc, destroyRef });
  const debouncer = createDebouncer({ windowMs: config.debounceMs });
  const earcons = new Map<string, EarconConfig>(
    Object.entries({ ...CNGX_AUDIO_DEFAULT_EARCONS, ...config.earcons }),
  );
  // Dev-only: an unknown earcon name is a fixed authoring mistake, so warn once
  // per name rather than on every (debounced) play attempt.
  const warnedUnknownEarcons = new Set<string>();

  let context: BaseAudioContext | null = null;
  let masterGain: GainNode | null = null;

  const contextFactory =
    options?.contextFactory ??
    ((): BaseAudioContext | null => {
      const view = doc.defaultView as
        | (Window & {
            AudioContext?: typeof AudioContext;
            webkitAudioContext?: typeof AudioContext;
          })
        | null;
      const Ctor = view?.AudioContext ?? view?.webkitAudioContext;
      return Ctor ? new Ctor() : null;
    });

  const toneGenerator = toneGeneratorFactory({
    context: () => context!,
    destination: () => masterGain!,
  });

  // Single source of truth for `status`: the context's own statechange event.
  // Browser-initiated transitions the page never requested (Safari interrupt,
  // OS suspend) flow through here too, and because resume()/suspend() land
  // their result via this listener there is no manual status write left to
  // race - a stale resume resolution cannot clobber a later suspend.
  const onStateChange = (): void => {
    if (context) {
      status.set(mapAudioStatus(context.state));
    }
  };

  function resumeIfArmed(): void {
    if (context && gate.armed() && isSuspendedLike(context.state)) {
      void (context as AudioContext).resume().catch(() => undefined);
    }
  }

  function ensureContext(): BaseAudioContext | null {
    if (context) {
      return context;
    }
    const created = contextFactory();
    if (!created) {
      status.set('unsupported');
      return null;
    }
    context = created;
    masterGain = created.createGain();
    masterGain.gain.value = volume();
    masterGain.connect(created.destination);
    // Born in its current state - no statechange fires for the initial value,
    // so seed it directly; every later transition arrives via onStateChange.
    status.set(mapAudioStatus(created.state));
    created.addEventListener('statechange', onStateChange);
    resumeIfArmed();
    return context;
  }

  function blocked(): boolean {
    return muted() || (config.respectReducedMotion && reducedMotion()) || !gate.armed();
  }

  // Volume is communicated to the master node reactively - the single writer is
  // setVolume(), but binding through an effect keeps the node in sync from any
  // future volume source too.
  effect(() => {
    const v = volume();
    if (masterGain) {
      masterGain.gain.value = v;
    }
  });

  // Suspend on tab hide (frees the audio hardware); resume on return if armed.
  const onVisibility = (): void => {
    if (!context) {
      return;
    }
    if (doc.hidden) {
      if (context.state === 'running') {
        void (context as AudioContext).suspend().catch(() => undefined);
      }
    } else {
      resumeIfArmed();
    }
  };
  doc.addEventListener('visibilitychange', onVisibility);
  destroyRef.onDestroy(() => {
    doc.removeEventListener('visibilitychange', onVisibility);
    context?.removeEventListener('statechange', onStateChange);
    // close() rejects on an already-closed context; swallow it so a double
    // destroy does not surface an unhandled rejection.
    const closing = (context as AudioContext | null)?.close?.();
    void closing?.then(
      () => undefined,
      () => undefined,
    );
  });

  return {
    play(name, scale) {
      if (blocked()) {
        return;
      }
      if (!ensureContext()) {
        return;
      }
      resumeIfArmed();
      if (!debouncer.shouldFire(name)) {
        return;
      }
      const earcon = earcons.get(name);
      if (!earcon) {
        if (isDevMode() && !warnedUnknownEarcons.has(name)) {
          warnedUnknownEarcons.add(name);
          console.warn(
            `[cngxAudio] Unknown earcon "${name}". Register it via withEarcons({...}) or engine.register(name, config).`,
          );
        }
        return;
      }
      toneGenerator.sequence(scaleSteps(earcon.sequence, scale));
      lastPlayed.set(name);
    },
    tone(freq, durationMs, opts, scale) {
      if (blocked() || !ensureContext()) {
        return;
      }
      resumeIfArmed();
      toneGenerator.tone(
        freq,
        durationMs,
        scale === undefined ? opts : { ...opts, gain: scaleGain(opts?.gain, scale) },
      );
    },
    sequence(steps, scale) {
      if (blocked() || !ensureContext()) {
        return;
      }
      resumeIfArmed();
      toneGenerator.sequence(scaleSteps(steps, scale));
    },
    register(name, earconConfig) {
      earcons.set(name, earconConfig);
    },
    armAutoplay() {
      gate.arm();
      resumeIfArmed();
    },
    setMuted(next) {
      muted.set(next);
    },
    setVolume(next) {
      volume.set(clampVolume(next));
    },
    muted: muted.asReadonly(),
    volume: volume.asReadonly(),
    status: status.asReadonly(),
    lastPlayed: lastPlayed.asReadonly(),
  };
}

(mode, deps) =>
mode === 'svg' ? createSvgRenderer(deps) : createCanvasRenderer(deps)

({ selectedValue, name }) => ({
  selectedValue,
  name,
  select(value) {
    selectedValue.set(value);
  },
})

{
  'de-DE': '00.00.00',
  'de-AT': '00.00.00',
  'de-CH': '00.00.00',
  'fr-FR': '00/00/00',
  'fr-BE': '00/00/00',
  'fr-CH': '00.00.00',
  'fr-CA': '00-00-00',
  'es-ES': '00/00/00',
  'es-MX': '00/00/00',
  'es-AR': '00/00/00',
  'it-IT': '00/00/00',
  'it-CH': '00.00.00',
  'pt-PT': '00/00/00',
  'pt-BR': '00/00/00',
  'nl-NL': '00-00-00',
  'nl-BE': '00/00/00',
  'ru-RU': '00.00.00',
  'ja-JP': '00/00/00',
  'zh-CN': '00-00-00',
  'zh-TW': '00/00/00',
  'zh-HK': '00/00/00',
  'ko-KR': '00.00.00',
  'en-US': '00/00/00',
  'en-GB': '00/00/00',
  'en-AU': '00/00/00',
  'en-CA': '00-00-00',
  'en-IE': '00/00/00',
  'pl-PL': '00.00.00',
  'cs-CZ': '00.00.00',
  'sk-SK': '00.00.00',
  'hu-HU': '00.00.00',
  'ro-RO': '00.00.00',
  'bg-BG': '00.00.00',
  'el-GR': '00/00/00',
  'sv-SE': '00-00-00',
  'nb-NO': '00.00.00',
  'da-DK': '00-00-00',
  'fi-FI': '00.00.00',
  'hr-HR': '00.00.00',
  'sr-RS': '00.00.00',
  'sl-SI': '00.00.00',
  'uk-UA': '00.00.00',
  'lt-LT': '00-00-00',
  'lv-LV': '00.00.00',
  'et-EE': '00.00.00',
  'is-IS': '00.00.00',
  'mt-MT': '00/00/00',
  'ga-IE': '00/00/00',
  'lb-LU': '00.00.00',
  'tr-TR': '00.00.00',
}

memoize(
  (key: string): Intl.DateTimeFormat => {
    const sep = key.indexOf('|');
    return new Intl.DateTimeFormat(
      key.slice(0, sep),
      JSON.parse(key.slice(sep + 1)) as Intl.DateTimeFormatOptions,
    );
  },
  { cacheLimit: DATE_TIME_FORMATTER_CACHE_LIMIT },
)

{
  openShortcut: CNGX_COMMAND_PALETTE_DEFAULTS.openShortcut,
  searchPlaceholder: CNGX_COMMAND_PALETTE_DEFAULTS.searchPlaceholder,
  listboxLabel: CNGX_COMMAND_PALETTE_DEFAULTS.listboxLabel,
  emptyLabel: CNGX_COMMAND_PALETTE_DEFAULTS.emptyLabel,
  loadingLabel: CNGX_COMMAND_PALETTE_DEFAULTS.loadingLabel,
  errorLabel: CNGX_COMMAND_PALETTE_DEFAULTS.errorLabel,
  retryLabel: CNGX_COMMAND_PALETTE_DEFAULTS.retryLabel,
  resultCount: CNGX_COMMAND_PALETTE_DEFAULTS.resultCount,
  footerLegend: CNGX_COMMAND_PALETTE_DEFAULTS.footerLegend,
}

{
  lengthRange: (min, max) => `${min}–${max} characters`,
  minLength: (min) => `Min. ${min} characters`,
  maxLength: (max) => `Max. ${max} characters`,
  valueRange: (min, max) => `${min}–${max}`,
  minValue: (min) => `Min. ${min}`,
  maxValue: (max) => `Max. ${max}`,
  extra: () => [],
}

{
  clear: 'Clear',
  otpGroup: 'One-time code',
  otpSlot: (index, length) => `Digit ${index + 1} of ${length}`,
  otpComplete: 'Code complete',
  copySuccess: 'Copied',
  copyError: 'Copy failed',
  fileDropZone: 'File drop zone',
  capsLockOn: 'Caps Lock is on',
  passwordStrength: (label) => `Password strength: ${label}`,
  inputRejected: 'Character not allowed',
  sensitiveReveal: 'Value revealed',
  sensitiveHide: 'Value hidden',
  ratingValue: (value, max) => `${value} of ${max}`,
  ratingItem: (step, max) => `${step} of ${max}`,
  phoneCountry: 'Country',
}

{
  ariaLabels: {
    submenuOpened: 'Submenu opened',
    submenuClosed: 'Submenu closed',
    itemActivated: 'Item activated',
    itemDisabled: 'Item disabled',
    menuDismissed: 'Menu dismissed',
  },
  typeaheadDebounce: 300,
  submenuOpenDelay: 0,
  submenuCloseDelay: 150,
  closeOnSelect: true,
  dismissOnOutsideClick: true,
  dismissOnScroll: false,
  dismissOnBlur: true,
}

{
  string: ['contains', 'eq', 'neq', 'startsWith', 'endsWith', 'isEmpty', 'isNotEmpty'],
  number: ['eq', 'neq', 'gt', 'gte', 'lt', 'lte', 'isEmpty', 'isNotEmpty'],
  date: ['eq', 'neq', 'gt', 'gte', 'lt', 'lte', 'isEmpty', 'isNotEmpty'],
  boolean: ['eq', 'neq'],
} as const satisfies Record<FilterEditorType, readonly string[]>

(): CngxContextMenuOpenDecision => ({
  open: true,
  context: undefined,
})

{
  behavior: 'smooth',
  block: 'nearest',
  inline: 'center',
}

createPreferenceAxis({
  token: CNGX_DENSITY,
  attribute: 'data-density',
})

{
  close: 'Close dialog',
  errorFallback: 'An error occurred',
  dragHandle: 'Move dialog',
  dragHandleRoleDescription: 'draggable',
  dragInstructions: 'Use arrow keys to move the dialog; Shift for larger steps',
}

{
  start: 0,
  end: 0,
  offsetBefore: 0,
  offsetAfter: 0,
  totalSize: 0,
}

{
  alertsRegionLabel: 'Alerts',
  notificationsRegionLabel: 'Notifications',
  announcements: {
    alertDismissed: 'Alert dismissed',
    alertOverflow: (count) => `Show ${count} more alerts`,
    asyncLoading: 'Loading content',
    asyncLoaded: 'Content loaded',
    asyncError: 'Error loading content',
    asyncRefreshing: 'Refreshing content',
    asyncRefreshed: 'Content refreshed',
    asyncRefreshFailed: 'Refresh failed',
  },
}

(a: readonly boolean[], b: readonly boolean[]): boolean =>
a.length === b.length && a.every((v, i) => v === b[i])

{
  none: '0',
  xs: 'var(--cngx-gap-xs, var(--cngx-space-xs, 4px))',
  sm: 'var(--cngx-gap-sm, var(--cngx-space-sm, 8px))',
  md: 'var(--cngx-gap-md, var(--cngx-space-md, 16px))',
  lg: 'var(--cngx-gap-lg, var(--cngx-space-lg, 24px))',
  xl: 'var(--cngx-gap-xl, var(--cngx-space-xl, 32px))',
}

{
  // DACH
  CH: 'AA00 0000 0000 0000 0000 0', // 21
  DE: 'AA00 0000 0000 0000 0000 00', // 22
  AT: 'AA00 0000 0000 0000 0000', // 20
  // Western Europe
  FR: 'AA00 0000 0000 0000 0000 0000 000', // 27
  BE: 'AA00 0000 0000 0000', // 16, BBAN fully numeric
  NL: 'AA00 AAAA 0000 0000 00', // 18
  LU: 'AA00 0000 0000 0000 0000', // 20
  IE: 'AA00 AAAA 0000 0000 0000 00', // 22, 4-letter bank code + 14 digits
  GB: 'AA00 AAAA 0000 0000 0000 00', // 22
  MT: 'AA00 AAAA 0000 0000 0000 0000 000', // 31, longest IBAN in Europe
  // Southern Europe
  ES: 'AA00 0000 0000 0000 0000 0000', // 24
  IT: 'AA00 A000 0000 0000 0000 0000 000', // 27, 1 letter (CIN check char) at BBAN start
  PT: 'AA00 0000 0000 0000 0000 0000 0', // 25
  GR: 'AA00 0000 0000 0000 0000 0000 000', // 27
  // Northern Europe
  SE: 'AA00 0000 0000 0000 0000 0000', // 24
  NO: 'AA00 0000 0000 000', // 15, shortest in Europe
  DK: 'AA00 0000 0000 0000 00', // 18
  FI: 'AA00 0000 0000 0000 00', // 18
  IS: 'AA00 0000 0000 0000 0000 0000 00', // 26
  // Central Europe
  PL: 'AA00 0000 0000 0000 0000 0000 0000', // 28, fully numeric BBAN
  CZ: 'AA00 0000 0000 0000 0000 0000', // 24
  SK: 'AA00 0000 0000 0000 0000 0000', // 24
  HU: 'AA00 0000 0000 0000 0000 0000 0000', // 28
  // Eastern Europe / Balkans
  RO: 'AA00 AAAA 0000 0000 0000 0000', // 24, account part is alphanumeric
  BG: 'AA00 AAAA 0000 0000 0000 00', // 22
  HR: 'AA00 0000 0000 0000 0000 0', // 21
  RS: 'AA00 0000 0000 0000 0000 00', // 22
  SI: 'AA00 0000 0000 0000 000', // 19
  UA: 'AA00 0000 0000 0000 0000 0000 0000 0', // 29
  LT: 'AA00 0000 0000 0000 0000', // 20
  LV: 'AA00 AAAA 0000 0000 0000 0', // 21
  EE: 'AA00 0000 0000 0000 0000', // 20
  RU: 'AA00 0000 0000 0000 0000 0000 00', // 33, in the IBAN registry since 2021
  TR: 'AA00 0000 0000 0000 0000 0000 00', // 26, 1 reserved digit after the bank code
}

(a: readonly string[], b: readonly string[]): boolean =>
a.length === b.length && a.every((id, i) => id === b[i])

(a: readonly CngxStatSlotKind[], b: readonly CngxStatSlotKind[]): boolean =>
a.length === b.length && a.every((kind, i) => kind === b[i])

createPreferenceAxis({
  token: CNGX_MOTION,
  attribute: 'data-motion',
  removeValue: 'auto',
})

`
  <button
    type="button"
    class="cngx-paginator__button cngx-paginator__nav"
    cngxRipple
    [attr.aria-disabled]="core.disabled() ? 'true' : null"
    (click)="core.activate()"
  >
    <cngx-icon aria-hidden="true">{{ glyph }}</cngx-icon>
    <span class="cngx-paginator__nav-label">{{ core.ariaLabel() }}</span>
  </button>
`

new Set([
  'neutral',
  'success',
  'warning',
  'error',
  'info',
])

[
  { amount: 60, unit: 'seconds' },
  { amount: 60, unit: 'minutes' },
  { amount: 24, unit: 'hours' },
  { amount: 7, unit: 'days' },
  { amount: 4.34524, unit: 'weeks' },
  { amount: 12, unit: 'months' },
]

memoize(
  (locale: string) => new Intl.RelativeTimeFormat(locale, { numeric: 'auto' }),
)

{
  0: 'weak',
  1: 'weak',
  2: 'fair',
  3: 'good',
  4: 'strong',
}

(a: readonly SegmentState[], b: readonly SegmentState[]): boolean =>
a.length === b.length && a.every((s, i) => s === b[i])

{
  positive: 'improved',
  negative: 'declined',
  neutral: 'unchanged',
}

{
  '0': { test: /[0-9]/, optional: false },
  '9': { test: /[0-9]/, optional: true },
  A: { test: /[a-zA-Z]/, optional: false },
  a: { test: /[a-zA-Z]/, optional: true },
  '*': { test: /[a-zA-Z0-9]/, optional: false },
}

{
  compact: 120,
  minimal: 64,
}

{
  defaultOrientation: 'horizontal',
  defaultLoop: true,
  defaultCommitMode: 'optimistic',
  fragmentSyncMode: 'fragment',
  fragmentSyncParam: 'tab',
  // routeMatch stays unset: the host-flavour default is the right answer
  // for both organisms, and pinning one here would silently flip the
  // other. linkAriaCurrent defaults at the link, not here.
  linkAriaCurrent: 'page',
  ariaLabels: {
    tabsRegion: 'Tabs',
  },
  fallbackLabels: {
    // W3C ARIA tablist convention - kept distinct from
    // `i18n.tabsLabel` so AT doesn't read the same string twice
    // back-to-back across `aria-roledescription` and `aria-label`.
    tabRoleDescription: 'tab list',
    tabPanelRoleDescription: 'tab panel',
  },
  overflowStabilizeMs: 100,
  overflowMaxDeferMs: 250,
  templates: {},
}

{
  tabsLabel: 'Tabs',
  selectedTab: (label, position, count) => `Tab ${position} of ${count}: ${label}`,
  tabLabelWithDetail: (label, detail) => `${label}, ${detail}`,
  tabHasErrors: (count) => `${count} error${count === 1 ? '' : 's'}`,
  moreTabsLabel: (count) => `${count} more`,
  previousTab: 'Previous tab',
  nextTab: 'Next tab',
  closeTab: (label) => `Close "${label}"`,
  addTab: 'Add tab',
  closedTab: (label) => (label ? `Closed "${label}"` : 'Tab closed'),
  commitFailedRetry: 'Tab change refused - retry?',
  commitInFlight: 'Switching tab…',
  commitRolledBackTo: (originLabel) => `Could not save changes - reverted to "${originLabel}".`,
}

createPreferenceAxis({
  token: CNGX_TEXT_SCALE,
  attribute: 'data-text-size',
})

{
  labels: {
    timelineRegion: 'Timeline',
    retry: 'Retry',
    errorFallback: 'Could not load the timeline.',
    emptyFallback: 'No events yet.',
    loading: 'Loading timeline',
    refreshing: 'Updating…',
    itemBusy: 'Updating',
    itemErrorFallback: 'Could not load this event.',
    status: {
      done: 'Completed',
      active: 'In progress',
      upcoming: 'Upcoming',
      rejected: 'Rejected',
    },
    groupLabel: (group) => group.start.toLocaleDateString(),
  },
  templates: {},
}

{
  success: '✓',
  warning: '!',
  danger: '✕',
  info: 'i',
  neutral: '•',
}

createPreferenceAxis({
  token: CNGX_TOUCH_TARGET,
  attribute: 'data-touch',
  removeValue: 'auto',
})

{
  // DACH
  DE: '00000',
  AT: '0000',
  CH: '0000',
  // Western Europe
  FR: '00000',
  BE: '0000',
  NL: '0000 AA', // e.g. 1234 AB
  LU: '0000',
  IE: 'A00 0000', // Eircode since 2015; highly irregular
  GB: 'A0A 0AA|AA0 0AA|AA00 0AA|A0 0AA|A00 0AA|AA0A 0AA', // incl. AA0A 0AA (e.g. EC1A 1BB)
  UK: 'A0A 0AA|AA0 0AA|AA00 0AA|A0 0AA|A00 0AA|AA0A 0AA', // back-compat alias of GB
  MT: 'AAA 0000', // e.g. VLT 1117
  // Southern Europe
  ES: '00000',
  IT: '00000',
  PT: '0000-000',
  GR: '000 00',
  // Northern Europe
  SE: '000 00',
  NO: '0000',
  DK: '0000',
  FI: '00000',
  IS: '000', // 3-digit, very small system
  // Central Europe
  PL: '00-000',
  CZ: '000 00',
  SK: '000 00',
  HU: '0000',
  // Eastern Europe / Balkans
  RO: '000000',
  BG: '0000',
  HR: '00000',
  RS: '00000',
  SI: '0000',
  UA: '00000',
  LT: '00000', // often written with an "LT-" prefix
  LV: '0000', // often written with an "LV-" prefix
  EE: '00000',
  RU: '000000',
  TR: '00000',
  // North America
  US: '00000', // ZIP+4 (00000-0000) not modelled here
  CA: 'A0A 0A0', // alternating letter/digit
  MX: '00000',
  // East Asia
  JP: '000-0000',
  CN: '000000',
  KR: '00000', // 5-digit since 2015
  TW: '00000', // modern 5-digit (3+2)
  // Southeast Asia
  SG: '000000',
  MY: '00000',
  TH: '00000',
  VN: '000000',
  PH: '0000',
  ID: '00000',
  // South Asia
  IN: '000 000', // PIN code, also written without the space
  // Middle East
  IL: '0000000',
  SA: '00000-0000', // base 5-digit, "-0000" extension often omitted
  // Africa
  ZA: '0000',
  EG: '00000',
  NG: '000000',
  // Latin America
  AR: 'A0000AAA', // format since 1999 (e.g. C1425CKC); older 4-digit still seen
  CL: '0000000',
  CO: '000000',
  PE: '00000',
  BR: '00000-000',
  // Oceania
  AU: '0000',
  NZ: '0000',
}