meno-core 1.0.53 → 1.1.0

package/lib/shared/i18n.ts

@@ -10,9 +10,7 @@ import type { I18nValue, I18nConfig, LocaleConfig } from './types/components';
  */
 export const DEFAULT_I18N_CONFIG: I18nConfig = {
   defaultLocale: 'en',
-  locales: [
-    { code: 'en', name: 'English', nativeName: 'English', langTag: 'en-US' }
-  ],
+  locales: [{ code: 'en', name: 'English', nativeName: 'English', langTag: 'en-US' }],
 };
 
 // ============================================
@@ -23,21 +21,21 @@ export const DEFAULT_I18N_CONFIG: I18nConfig = {
  * Get array of locale codes from config
  */
 export function getLocaleCodes(config: I18nConfig): string[] {
-  return config.locales.map(loc => loc.code);
+  return config.locales.map((loc) => loc.code);
 }
 
 /**
  * Find a locale config by its code
  */
 export function findLocaleByCode(config: I18nConfig, code: string): LocaleConfig | undefined {
-  return config.locales.find(loc => loc.code === code);
+  return config.locales.find((loc) => loc.code === code);
 }
 
 /**
  * Check if a locale code is valid/exists in config
  */
 export function isValidLocaleCode(config: I18nConfig, code: string): boolean {
-  return config.locales.some(loc => loc.code === code);
+  return config.locales.some((loc) => loc.code === code);
 }
 
 // ============================================
@@ -112,11 +110,7 @@ export function isI18nValue(value: unknown): value is I18nValue {
  * Fallback order: exact locale -> default locale -> first available -> empty
  * Works with any value type (strings, arrays for list props, etc.)
  */
-export function resolveTranslation(
-  value: I18nValue,
-  locale: string,
-  config: I18nConfig
-): unknown {
+export function resolveTranslation(value: I18nValue, locale: string, config: I18nConfig): unknown {
   // Try exact locale match (any type - string, array, etc.)
   if (locale in value && value[locale] !== undefined && locale !== '_i18n') {
     return value[locale];
@@ -136,9 +130,7 @@ export function resolveTranslation(
 
   // Return empty string for string i18n, empty array for list i18n
   // Check if any value is an array to determine the type
-  const hasArrayValue = Object.entries(value).some(
-    ([k, v]) => k !== '_i18n' && Array.isArray(v)
-  );
+  const hasArrayValue = Object.entries(value).some(([k, v]) => k !== '_i18n' && Array.isArray(v));
   return hasArrayValue ? [] : '';
 }
 
@@ -146,11 +138,7 @@ export function resolveTranslation(
  * Resolve a value that might be an I18nValue or a regular value
  * Returns the original value if not an I18nValue
  */
-export function resolveI18nValue(
-  value: unknown,
-  locale: string,
-  config: I18nConfig
-): unknown {
+export function resolveI18nValue(value: unknown, locale: string, config: I18nConfig): unknown {
   if (isI18nValue(value)) {
     return resolveTranslation(value, locale, config);
   }
@@ -163,7 +151,7 @@ export function resolveI18nValue(
 export function resolveI18nInProps(
   props: Record<string, unknown>,
   locale: string,
-  config: I18nConfig
+  config: I18nConfig,
 ): Record<string, unknown> {
   const resolved: Record<string, unknown> = {};
 
@@ -171,16 +159,10 @@ export function resolveI18nInProps(
     if (isI18nValue(value)) {
       resolved[key] = resolveTranslation(value, locale, config);
     } else if (Array.isArray(value)) {
-      resolved[key] = value.map((item) =>
-        isI18nValue(item) ? resolveTranslation(item, locale, config) : item
-      );
+      resolved[key] = value.map((item) => (isI18nValue(item) ? resolveTranslation(item, locale, config) : item));
     } else if (typeof value === 'object' && value !== null) {
       // Recursively resolve nested objects (but not I18nValue which is already handled)
-      resolved[key] = resolveI18nInProps(
-        value as Record<string, unknown>,
-        locale,
-        config
-      );
+      resolved[key] = resolveI18nInProps(value as Record<string, unknown>, locale, config);
     } else {
       resolved[key] = value;
     }
@@ -195,15 +177,16 @@ export function resolveI18nInProps(
  */
 export function extractLocaleFromPath(
   path: string,
-  config: I18nConfig
+  config: I18nConfig,
 ): { locale: string | null; pathWithoutLocale: string } {
   // Remove leading slash and split
   const cleanPath = path.startsWith('/') ? path.slice(1) : path;
   const segments = cleanPath.split('/');
 
-  if (segments.length > 0 && isValidLocaleCode(config, segments[0])) {
-    const locale = segments[0];
-    const pathWithoutLocale = '/' + segments.slice(1).join('/');
+  const firstSegment = segments[0];
+  if (firstSegment !== undefined && isValidLocaleCode(config, firstSegment)) {
+    const locale = firstSegment;
+    const pathWithoutLocale = `/${segments.slice(1).join('/')}`;
     return { locale, pathWithoutLocale: pathWithoutLocale || '/' };
   }
 
@@ -215,7 +198,7 @@ export function extractLocaleFromPath(
  * e.g., ('/about', 'pl') -> '/pl/about'
  */
 export function buildLocalizedPath(path: string, locale: string): string {
-  const cleanPath = path.startsWith('/') ? path : '/' + path;
+  const cleanPath = path.startsWith('/') ? path : `/${path}`;
   return `/${locale}${cleanPath === '/' ? '' : cleanPath}`;
 }
 
@@ -235,17 +218,14 @@ export interface LocaleContext {
  * Parse locale from path and return full context with effective locale
  * Combines extractLocaleFromPath + defaultLocale resolution in one call
  */
-export function parseLocaleFromPath(
-  path: string,
-  config: I18nConfig
-): LocaleContext {
+export function parseLocaleFromPath(path: string, config: I18nConfig): LocaleContext {
   const { locale, pathWithoutLocale } = extractLocaleFromPath(path, config);
   const effectiveLocale = locale || config.defaultLocale;
 
   return {
     locale: effectiveLocale,
     pathWithoutLocale,
-    isDefaultLocale: effectiveLocale === config.defaultLocale
+    isDefaultLocale: effectiveLocale === config.defaultLocale,
   };
 }
 

package/lib/shared/index.ts

@@ -26,6 +26,10 @@ export * from './viewportUnits';
 export * from './colorProperties';
 export * from './cssNamedColors';
 export * from './utilityClassMapper';
+export { splitVariantPrefix, normalizeBreakpointVariant } from './utilityClassNames';
+// Utility-class catalog pieces — the seed for the Styles panel's class-bar autocomplete (§13 Phase 5).
+// Selective (not `export *`) to keep the barrel collision-free.
+export { propertyMap, staticUtilityReverse, keywordValues, presetClassReverse } from './utilityClassConfig';
 export * from './elementClassName';
 export * from './styleValueRegistry';
 
@@ -86,8 +90,17 @@ export {
   CommentThreadEntrySchema,
   CommentNodeIdentitySchema,
   validateComment,
+  // Permissions validators
+  PermissionRoleSchema,
+  PermissionRuleSchema,
+  PermissionGrantSchema,
+  PermissionsPolicySchema,
+  validatePermissionsPolicy,
 } from './validation';
 
+// Permission resolver (pure)
+export * from './permissions';
+
 // Utils
 export * from './utils';
 
@@ -116,6 +129,10 @@ export { isSupportedTemplateExpression } from './expressionEvaluator';
 // Path security utilities
 export * from './pathSecurity';
 
+// Netlify locale-scoped 404 rules + the managed netlify.toml block (shared by
+// every netlify.toml producer and the studio save-config sync)
+export * from './netlifyLocale404';
+
 // Interactive style mapping utilities
 export * from './interactiveStyleMappings';
 
@@ -126,6 +143,16 @@ export * from './richtext';
 export * from './errors';
 export * from './friendlyError';
 export { logRuntimeError, logNetworkError, setErrorHandler } from './errorLogger';
+export {
+  createLogger,
+  logger,
+  setLogLevel,
+  getLogLevel,
+  setLogSink,
+  type Logger,
+  type LogLevel,
+  type LogRecord,
+} from './logger';
 
 // Global template context
 export * from './globalTemplateContext';

package/lib/shared/inlineSvgStyleRules.ts

@@ -53,29 +53,30 @@ function rewriteSvgBlock(svgBlock: string): string {
   const classDeclarations = new Map<string, string>();
   const styleBlocksHandled: string[] = [];
 
-  let m: RegExpExecArray | null;
-  while ((m = styleBlockRe.exec(svgBlock)) !== null) {
+  let m: RegExpExecArray | null = styleBlockRe.exec(svgBlock);
+  while (m !== null) {
     const fullStyleTag = m[0];
-    const rawContent = m[1];
+    const rawContent = m[1] ?? '';
+    m = styleBlockRe.exec(svgBlock);
     // Strip CDATA wrapper if present (DOMPurify already unwraps it, but the
     // pre-sanitize call path may see one).
-    const content = stripCssComments(
-      rawContent.replace(/^\s*<!\[CDATA\[/, '').replace(/\]\]>\s*$/, '')
-    );
+    const content = stripCssComments(rawContent.replace(/^\s*<!\[CDATA\[/, '').replace(/\]\]>\s*$/, ''));
 
     // Pull out every simple `.cls { ... }` rule we can match.
     const localClasses = new Map<string, string>();
     let remaining = content;
-    let ruleMatch: RegExpExecArray | null;
     const ruleRe = new RegExp(RULE_RE.source, 'g');
-    while ((ruleMatch = ruleRe.exec(content)) !== null) {
-      const className = ruleMatch[1];
-      const body = ruleMatch[2].trim().replace(/;\s*$/, '');
+    let ruleMatch: RegExpExecArray | null = ruleRe.exec(content);
+    while (ruleMatch !== null) {
+      const className = ruleMatch[1] ?? '';
+      const body = (ruleMatch[2] ?? '').trim().replace(/;\s*$/, '');
+      const matchedRule = ruleMatch[0];
+      ruleMatch = ruleRe.exec(content);
       // Skip rules whose body contains a `{` — that means we mis-bracketed.
       if (body.includes('{')) continue;
       const prev = localClasses.get(className);
       localClasses.set(className, prev ? mergeIntoStyleAttr(prev, body) : body);
-      remaining = remaining.replace(ruleMatch[0], '');
+      remaining = remaining.replace(matchedRule, '');
     }
 
     // If anything non-trivial is left in the <style> body, leave the block
@@ -99,12 +100,12 @@ function rewriteSvgBlock(svgBlock: string): string {
   for (const [className, decls] of classDeclarations) {
     const elementRe = new RegExp(
       `(<[A-Za-z][\\w-]*\\b[^>]*?\\sclass="[^"]*\\b${escapeForRegex(className)}\\b[^"]*"[^>]*?)(/?>)`,
-      'g'
+      'g',
     );
     out = out.replace(elementRe, (_full, openHead: string, closing: string) => {
       const styleAttrMatch = openHead.match(/\sstyle="([^"]*)"/);
       if (styleAttrMatch) {
-        const merged = mergeIntoStyleAttr(styleAttrMatch[1], decls);
+        const merged = mergeIntoStyleAttr(styleAttrMatch[1] ?? '', decls);
         return openHead.replace(/\sstyle="[^"]*"/, ` style="${merged}"`) + closing;
       }
       return `${openHead} style="${decls}"${closing}`;

package/lib/shared/interactiveStyleMappings.test.ts

@@ -46,9 +46,7 @@ describe('interactiveStyleMappings', () => {
     });
 
     it('returns false when no mappings present', () => {
-      const styles: InteractiveStyles = [
-        { postfix: ':hover', style: { base: { backgroundColor: '#0070f3' } } },
-      ];
+      const styles: InteractiveStyles = [{ postfix: ':hover', style: { base: { backgroundColor: '#0070f3' } } }];
       expect(hasInteractiveStyleMappings(styles)).toBe(false);
     });
 
@@ -89,9 +87,7 @@ describe('interactiveStyleMappings', () => {
 
   describe('extractInteractiveStyleMappings', () => {
     it('returns unchanged styles when no mappings', () => {
-      const styles: InteractiveStyles = [
-        { postfix: ':hover', style: { base: { backgroundColor: '#0070f3' } } },
-      ];
+      const styles: InteractiveStyles = [{ postfix: ':hover', style: { base: { backgroundColor: '#0070f3' } } }];
 
       const { resolvedStyles, mappings } = extractInteractiveStyleMappings(styles);
 
@@ -106,9 +102,7 @@ describe('interactiveStyleMappings', () => {
         values: { primary: '#0070f3', secondary: '#gray' },
       };
 
-      const styles: InteractiveStyles = [
-        { postfix: ':hover', style: { backgroundColor: mapping } },
-      ];
+      const styles: InteractiveStyles = [{ postfix: ':hover', style: { backgroundColor: mapping } }];
 
       const { resolvedStyles, mappings } = extractInteractiveStyleMappings(styles);
 
@@ -121,7 +115,7 @@ describe('interactiveStyleMappings', () => {
         variableIndex: 0,
       });
 
-      expect(resolvedStyles[0].style).toEqual({
+      expect(resolvedStyles[0]!.style).toEqual({
         backgroundColor: 'var(--is-0)',
       });
     });
@@ -133,17 +127,15 @@ describe('interactiveStyleMappings', () => {
         values: { primary: '#0070f3' },
       };
 
-      const styles: InteractiveStyles = [
-        { postfix: ':hover', style: { base: { backgroundColor: mapping } } },
-      ];
+      const styles: InteractiveStyles = [{ postfix: ':hover', style: { base: { backgroundColor: mapping } } }];
 
       const { resolvedStyles, mappings } = extractInteractiveStyleMappings(styles);
 
       expect(mappings).toHaveLength(1);
-      expect(mappings[0].breakpoint).toBe('base');
-      expect(mappings[0].variableIndex).toBe(0);
+      expect(mappings[0]!.breakpoint).toBe('base');
+      expect(mappings[0]!.variableIndex).toBe(0);
 
-      expect((resolvedStyles[0].style as any).base).toEqual({
+      expect((resolvedStyles[0]!.style as any).base).toEqual({
         backgroundColor: 'var(--is-0)',
       });
     });
@@ -179,14 +171,14 @@ describe('interactiveStyleMappings', () => {
       const { resolvedStyles, mappings } = extractInteractiveStyleMappings(styles);
 
       expect(mappings).toHaveLength(3);
-      expect(mappings[0].breakpoint).toBe('base');
-      expect(mappings[0].variableIndex).toBe(0);
-      expect(mappings[1].breakpoint).toBe('tablet');
-      expect(mappings[1].variableIndex).toBe(1);
-      expect(mappings[2].breakpoint).toBe('mobile');
-      expect(mappings[2].variableIndex).toBe(2);
-
-      const resolved = resolvedStyles[0].style as any;
+      expect(mappings[0]!.breakpoint).toBe('base');
+      expect(mappings[0]!.variableIndex).toBe(0);
+      expect(mappings[1]!.breakpoint).toBe('tablet');
+      expect(mappings[1]!.variableIndex).toBe(1);
+      expect(mappings[2]!.breakpoint).toBe('mobile');
+      expect(mappings[2]!.variableIndex).toBe(2);
+
+      const resolved = resolvedStyles[0]!.style as any;
       expect(resolved.base.backgroundColor).toBe('var(--is-0)');
       expect(resolved.tablet.backgroundColor).toBe('var(--is-1)');
       expect(resolved.mobile.backgroundColor).toBe('var(--is-2)');
@@ -216,7 +208,7 @@ describe('interactiveStyleMappings', () => {
       expect(mappings).toHaveLength(2);
       // Note: order depends on Object.entries iteration order
 
-      const resolved = resolvedStyles[0].style as any;
+      const resolved = resolvedStyles[0]!.style as any;
       expect(resolved.base.backgroundColor).toMatch(/var\(--is-\d+\)/);
       expect(resolved.base.color).toMatch(/var\(--is-\d+\)/);
     });
@@ -245,7 +237,7 @@ describe('interactiveStyleMappings', () => {
 
       expect(mappings).toHaveLength(1);
 
-      const resolved = resolvedStyles[0].style as any;
+      const resolved = resolvedStyles[0]!.style as any;
       expect(resolved.base.backgroundColor).toBe('var(--is-0)');
       expect(resolved.base.transform).toBe('scale(1.05)');
       expect(resolved.base.opacity).toBe('0.9');
@@ -271,13 +263,13 @@ describe('interactiveStyleMappings', () => {
       const { resolvedStyles, mappings } = extractInteractiveStyleMappings(styles);
 
       expect(mappings).toHaveLength(2);
-      expect(mappings[0].ruleIndex).toBe(0);
-      expect(mappings[0].variableIndex).toBe(0);
-      expect(mappings[1].ruleIndex).toBe(1);
-      expect(mappings[1].variableIndex).toBe(1);
+      expect(mappings[0]!.ruleIndex).toBe(0);
+      expect(mappings[0]!.variableIndex).toBe(0);
+      expect(mappings[1]!.ruleIndex).toBe(1);
+      expect(mappings[1]!.variableIndex).toBe(1);
 
-      expect((resolvedStyles[0].style as any).base.backgroundColor).toBe('var(--is-0)');
-      expect((resolvedStyles[1].style as any).base.backgroundColor).toBe('var(--is-1)');
+      expect((resolvedStyles[0]!.style as any).base.backgroundColor).toBe('var(--is-0)');
+      expect((resolvedStyles[1]!.style as any).base.backgroundColor).toBe('var(--is-1)');
     });
 
     it('preserves postfix in resolved styles', () => {
@@ -287,13 +279,11 @@ describe('interactiveStyleMappings', () => {
         values: { primary: '#0070f3' },
       };
 
-      const styles: InteractiveStyles = [
-        { postfix: ':hover', style: { base: { backgroundColor: mapping } } },
-      ];
+      const styles: InteractiveStyles = [{ postfix: ':hover', style: { base: { backgroundColor: mapping } } }];
 
       const { resolvedStyles } = extractInteractiveStyleMappings(styles);
 
-      expect(resolvedStyles[0].postfix).toBe(':hover');
+      expect(resolvedStyles[0]!.postfix).toBe(':hover');
     });
   });
 
@@ -305,9 +295,7 @@ describe('interactiveStyleMappings', () => {
         values: { primary: '#0070f3', secondary: '#gray' },
       };
 
-      const styles: InteractiveStyles = [
-        { postfix: ':hover', style: { base: { backgroundColor: mapping } } },
-      ];
+      const styles: InteractiveStyles = [{ postfix: ':hover', style: { base: { backgroundColor: mapping } } }];
 
       const { mappings } = extractInteractiveStyleMappings(styles);
       const cssVariables = resolveExtractedMappings(mappings, { variant: 'primary' });
@@ -351,9 +339,7 @@ describe('interactiveStyleMappings', () => {
         values: { primary: '#0070f3', secondary: '#gray' },
       };
 
-      const styles: InteractiveStyles = [
-        { postfix: ':hover', style: { base: { backgroundColor: mapping } } },
-      ];
+      const styles: InteractiveStyles = [{ postfix: ':hover', style: { base: { backgroundColor: mapping } } }];
 
       const { mappings } = extractInteractiveStyleMappings(styles);
       const cssVariables = resolveExtractedMappings(mappings, { variant: 'purple' });
@@ -368,9 +354,7 @@ describe('interactiveStyleMappings', () => {
         values: { primary: '#0070f3' },
       };
 
-      const styles: InteractiveStyles = [
-        { postfix: ':hover', style: { base: { backgroundColor: mapping } } },
-      ];
+      const styles: InteractiveStyles = [{ postfix: ':hover', style: { base: { backgroundColor: mapping } } }];
 
       const { mappings } = extractInteractiveStyleMappings(styles);
       const cssVariables = resolveExtractedMappings(mappings, {});
@@ -385,9 +369,7 @@ describe('interactiveStyleMappings', () => {
         values: { primary: '#0070f3' },
       };
 
-      const styles: InteractiveStyles = [
-        { postfix: ':hover', style: { base: { backgroundColor: mapping } } },
-      ];
+      const styles: InteractiveStyles = [{ postfix: ':hover', style: { base: { backgroundColor: mapping } } }];
 
       const { mappings } = extractInteractiveStyleMappings(styles);
       const cssVariables = resolveExtractedMappings(mappings, { variant: null });
@@ -402,9 +384,7 @@ describe('interactiveStyleMappings', () => {
         values: { true: '0.5', false: '1' },
       };
 
-      const styles: InteractiveStyles = [
-        { postfix: ':hover', style: { base: { opacity: mapping } } },
-      ];
+      const styles: InteractiveStyles = [{ postfix: ':hover', style: { base: { opacity: mapping } } }];
 
       const { mappings } = extractInteractiveStyleMappings(styles);
       const cssVariables = resolveExtractedMappings(mappings, { disabled: true });
@@ -419,9 +399,7 @@ describe('interactiveStyleMappings', () => {
         values: { '1': '10px', '2': '20px', '3': '30px' },
       };
 
-      const styles: InteractiveStyles = [
-        { postfix: ':hover', style: { base: { padding: mapping } } },
-      ];
+      const styles: InteractiveStyles = [{ postfix: ':hover', style: { base: { padding: mapping } } }];
 
       const { mappings } = extractInteractiveStyleMappings(styles);
       const cssVariables = resolveExtractedMappings(mappings, { size: 2 });

package/lib/shared/interactiveStyleMappings.ts

@@ -12,13 +12,7 @@
  * // resolvedStyles[0].style.base.backgroundColor === 'var(--is-0)'
  */
 
-import type {
-  InteractiveStyles,
-  InteractiveStyleRule,
-  StyleMapping,
-  StyleObject,
-  ResponsiveStyleObject,
-} from './types/styles';
+import type { InteractiveStyles, StyleMapping, StyleObject, ResponsiveStyleObject } from './types/styles';
 import type { PropDefinition } from './types/components';
 
 /**
@@ -26,10 +20,7 @@ import type { PropDefinition } from './types/components';
  */
 export function isStyleMapping(value: unknown): value is StyleMapping {
   return (
-    typeof value === 'object' &&
-    value !== null &&
-    '_mapping' in value &&
-    (value as StyleMapping)._mapping === true
+    typeof value === 'object' && value !== null && '_mapping' in value && (value as StyleMapping)._mapping === true
   );
 }
 
@@ -72,9 +63,8 @@ export function getVariableName(index: number): string {
  */
 function hasAnyMappings(style: StyleObject | ResponsiveStyleObject): boolean {
   // Check if it's a responsive style (has 'base' or known breakpoint keys)
-  const isResponsive = 'base' in style || Object.keys(style).some(key =>
-    key === 'base' || key === 'tablet' || key === 'mobile'
-  );
+  const isResponsive =
+    'base' in style || Object.keys(style).some((key) => key === 'base' || key === 'tablet' || key === 'mobile');
 
   if (isResponsive) {
     const responsive = style as ResponsiveStyleObject;
@@ -111,9 +101,7 @@ export function hasInteractiveStyleMappings(interactiveStyles: InteractiveStyles
  * @param interactiveStyles - Array of interactive style rules
  * @returns Object with resolved styles (var() references) and extracted mappings
  */
-export function extractInteractiveStyleMappings(
-  interactiveStyles: InteractiveStyles
-): ExtractionResult {
+export function extractInteractiveStyleMappings(interactiveStyles: InteractiveStyles): ExtractionResult {
   const mappings: ExtractedMapping[] = [];
   let variableIndex = 0;
 
@@ -121,9 +109,8 @@ export function extractInteractiveStyleMappings(
     const style = rule.style;
 
     // Check if it's a responsive style
-    const isResponsive = 'base' in style || Object.keys(style).some(key =>
-      key === 'base' || key === 'tablet' || key === 'mobile'
-    );
+    const isResponsive =
+      'base' in style || Object.keys(style).some((key) => key === 'base' || key === 'tablet' || key === 'mobile');
 
     if (isResponsive) {
       const responsive = style as ResponsiveStyleObject;
@@ -203,7 +190,7 @@ export function extractInteractiveStyleMappings(
  */
 export function resolveExtractedMappings(
   mappings: ExtractedMapping[],
-  props: Record<string, unknown>
+  props: Record<string, unknown>,
 ): Record<string, string> {
   const cssVariables: Record<string, string> = {};
 
@@ -250,7 +237,7 @@ export function resolveExtractedMappings(
  */
 export function createStyleMappingFromProps(
   componentPropDefs: Record<string, PropDefinition>,
-  currentValue: string | number
+  currentValue: string | number,
 ): StyleMapping | null {
   // Find a prop to map to (prefer 'variant' if it exists, otherwise use first prop)
   const propToMap = componentPropDefs.variant ? 'variant' : Object.keys(componentPropDefs)[0];
@@ -273,12 +260,12 @@ export function createStyleMappingFromProps(
     });
   } else {
     // No options, create a default mapping
-    mappingValues['default'] = currentValue;
+    mappingValues.default = currentValue;
   }
 
   return {
     _mapping: true,
     prop: propToMap,
-    values: mappingValues
+    values: mappingValues,
   };
 }