bernova 0.0.2

package/src/app.js

@@ -0,0 +1,176 @@
+const path = require('path');
+const {
+  generateBaseCss,
+  compileThemes,
+  generateCSS,
+  compileConfig,
+  writeDoc,
+  generateProvider,
+  processMediaConfig,
+  generateThemeRegister,
+  generateCssDoc,
+  handlerForeignThemes,
+} = require('./lib');
+const {
+  validatePreviouslyExists,
+  processCssWithPostcss,
+} = require('./lib/generateCss/helpers');
+const { compilerTypeValid } = require('./constants');
+const {
+  generateTypesTools,
+} = require('./lib/generateTypesTools/generateTypesTools.utils');
+const { generateTools } = require('./lib/generateTools/generateTools.utils');
+
+/**
+ * Main function to compile Bernova styles based on configuration
+ * Processes themes, generates CSS, and creates necessary files for the styling system
+ *
+ * @param {string} compilerType - The type of compilation to perform:
+ *   - 'foundationOnly': Generate only foundation styles (variables, base styles)
+ *   - 'componentOnly': Generate only component/theme styles
+ *   - 'full': Generate both foundation and component styles (default)
+ * @returns {Promise<void>} Resolves when all styles have been compiled and written
+ */
+async function bernovaStyles(compilerType) {
+  const dir = process.cwd();
+  const themeRegister = {};
+  const { default: ora } = await import('ora');
+  const spinner = ora('Starting BernovaStyled process...').start();
+
+  // Load and validate configuration from bernova.config.json
+  const { themes, provider } = await compileConfig({ dir });
+
+  // Process each theme configuration sequentially
+  for (const themeConfig of themes) {
+    const {
+      themeCss,
+      fonts,
+      resetCss,
+      bvTools,
+      name,
+      stylesPath,
+      typesTools,
+      foreignThemes,
+      prefix,
+    } = compileThemes({
+      themeConfig,
+      dir,
+    });
+
+    const baseCss = await generateBaseCss({ fonts, resetCss, stylesPath });
+
+    const { theme, media, ...withoutTheme } = themeCss;
+    const source = (() => {
+      switch (compilerType) {
+        case compilerTypeValid.foundationOnly:
+          return withoutTheme;
+        case compilerTypeValid.componentOnly:
+          return { theme, media };
+        default:
+          return themeCss;
+      }
+    })();
+    const { stylesCss, foundationsCss, stylesDocs, rootDocs, globalDocs } =
+      await generateCSS({
+        source,
+        baseCss,
+        compilerType,
+        prefix,
+      });
+
+    const stylesDir = stylesPath
+      ? path.resolve(dir, stylesPath)
+      : path.resolve(dir, 'styles');
+
+    const { cssDir, cssMinifiedDir, oldData } = await validatePreviouslyExists({
+      stylesDir,
+      compilerType,
+      name,
+    });
+
+    const finalCss = generateCssDoc({
+      compilerType,
+      stylesCss,
+      foundationsCss,
+      oldData,
+    });
+
+    const cssContent = await processCssWithPostcss(finalCss, false, null);
+    const cssMinified = await processCssWithPostcss(finalCss, true, null);
+
+    // Write both regular and minified CSS files
+    spinner.start(`Writing CSS to file for theme: ${name}...`);
+    await writeDoc(cssDir, cssContent, 'css');
+    await writeDoc(cssMinifiedDir, cssMinified, 'css minified');
+    spinner.succeed(`CSS written to file for theme: ${name}.`);
+
+    spinner.start(`Compiling register for theme: ${name}...`);
+    // Register compilation is handled internally by theme processing
+    spinner.succeed(`Register compiled for theme: ${name}.`);
+
+    // Generate TypeScript type definitions if configured
+    spinner.start('Verifying types tools...');
+    if (typesTools) {
+      spinner.succeed(`Types tools verified for theme: ${name}.`);
+      await generateTypesTools({
+        dir,
+        typesTools,
+        mediaConfig: media,
+        stylesDocs,
+      });
+    } else {
+      spinner.succeed(`No types tools found for theme: ${name}.`);
+    }
+
+    const mediaDocs = processMediaConfig({ mediaConfig: media });
+
+    // Generate development tools if configured (bvTools)
+    spinner.start(`Processing bvTools for theme: ${name}...`);
+    if (bvTools) {
+      spinner.succeed(`bvTools found for theme: ${name}.`);
+      await generateTools({
+        bvTools,
+        compilerType,
+        name,
+        dir,
+        stylesDir,
+        stylesDocs,
+        rootDocs,
+        globalDocs,
+        mediaDocs,
+      });
+    } else {
+      spinner.succeed(`No bvTools found for theme: ${name}.`);
+    }
+
+    const { themeByPosition, variablesExtracted, classesExtracted } =
+      await handlerForeignThemes({ dir, foreignThemes });
+
+    themeRegister[name] = generateThemeRegister({
+      cssPath: path.resolve(dir, stylesDir, `${name}.css`),
+      rootDocs,
+      stylesDocs,
+      globalDocs,
+      mediaDocs,
+      foreignStyles: classesExtracted,
+      foreignVars: variablesExtracted,
+      foreignBeforeFiles: themeByPosition.before,
+      foreignAfterFiles: themeByPosition.after,
+    });
+  }
+
+  // Generate React/framework provider if configured
+  if (provider) {
+    spinner.start('Provider configuration found, generating tools...');
+    await generateProvider({
+      dir: path.resolve(dir, provider.path),
+      providerDocs: themeRegister,
+      declarationHelp: provider.declarationHelp,
+      providerName: provider.name,
+      compilerType,
+    });
+    spinner.succeed('Provider tools generated successfully.');
+  }
+}
+
+module.exports = { bernovaStyles };

package/src/constants/__tests__/compilerType.test.js

@@ -0,0 +1,20 @@
+import { describe, it, expect } from 'vitest';
+import { compilerTypeValid } from '../compilerType.js';
+
+describe('compilerTypeValid constants', () => {
+  it('should have all required compiler types', () => {
+    expect(compilerTypeValid).toHaveProperty('foundationOnly');
+    expect(compilerTypeValid).toHaveProperty('componentOnly');
+    expect(compilerTypeValid).toHaveProperty('full');
+  });
+
+  it('should have correct string values', () => {
+    expect(compilerTypeValid.foundationOnly).toBe('foundationOnly');
+    expect(compilerTypeValid.componentOnly).toBe('componentOnly');
+    expect(compilerTypeValid.full).toBe('full');
+  });
+
+  it('should be immutable object structure', () => {
+    expect(Object.keys(compilerTypeValid)).toHaveLength(3);
+  });
+});

package/src/constants/__tests__/cssAdvancedSelectors.test.js

@@ -0,0 +1,38 @@
+import { describe, it, expect } from 'vitest';
+import { cssAdvancedSelectors } from '../cssAdvancedSelectors.js';
+
+describe('cssAdvancedSelectors constants', () => {
+  it('should have all required selector types', () => {
+    expect(cssAdvancedSelectors).toHaveProperty('adjacent');
+    expect(cssAdvancedSelectors).toHaveProperty('child');
+    expect(cssAdvancedSelectors).toHaveProperty('descendant');
+    expect(cssAdvancedSelectors).toHaveProperty('near');
+    expect(cssAdvancedSelectors).toHaveProperty('concat');
+    expect(cssAdvancedSelectors).toHaveProperty('column');
+  });
+
+  it('should have correct CSS combinator values', () => {
+    expect(cssAdvancedSelectors.adjacent).toBe(' + ');
+    expect(cssAdvancedSelectors.child).toBe(' > ');
+    expect(cssAdvancedSelectors.descendant).toBe(' ');
+    expect(cssAdvancedSelectors.near).toBe(' ~ ');
+    expect(cssAdvancedSelectors.concat).toBe('');
+    expect(cssAdvancedSelectors.column).toBe(' || ');
+  });
+
+  it('should be immutable object structure', () => {
+    expect(Object.keys(cssAdvancedSelectors)).toHaveLength(6);
+  });
+
+  it('should have proper spacing for combinators', () => {
+    // Adjacent and near should have spaces around operators
+    expect(cssAdvancedSelectors.adjacent).toMatch(/^\s\+\s$/);
+    expect(cssAdvancedSelectors.near).toMatch(/^\s~\s$/);
+
+    // Child should have spaces around operator
+    expect(cssAdvancedSelectors.child).toMatch(/^\s>\s$/);
+
+    // Descendant should be just a space
+    expect(cssAdvancedSelectors.descendant).toBe(' ');
+  });
+});

package/src/constants/__tests__/cssProps.test.js

@@ -0,0 +1,331 @@
+import { describe, it, expect } from 'vitest';
+import { cssProps } from '../cssProps.js';
+
+describe('cssProps', () => {
+  it('should have the correct CSS properties', () => {
+    const expectedProps = {
+      // Scrollbar properties
+      scrollbar_width: 'scrollbar-width',
+      scrollbar_color: 'scrollbar-color',
+      scrollbar_gutter: 'scrollbar-gutter',
+      scroll_behavior: 'scroll-behavior',
+      scroll_margin: 'scroll-margin',
+      scroll_padding: 'scroll-padding',
+      scroll_snap_align: 'scroll-snap-align',
+      scroll_snap_stop: 'scroll-snap-stop',
+      scroll_snap_type: 'scroll-snap-type',
+      webkit_scrollbar: 'webkit-scrollbar',
+      scroll_container: 'scroll-container',
+      scrollbar_aria_role: 'scrollbar-aria-role',
+
+      // Background properties
+      background: 'background',
+      background_color: 'background-color',
+      background_image: 'background-image',
+      background_position: 'background-position',
+      background_repeat: 'background-repeat',
+      background_size: 'background-size',
+      background_attachment: 'background-attachment',
+      background_blend_mode: 'background-blend-mode',
+      background_clip: 'background-clip',
+      background_origin: 'background-origin',
+
+      // Border properties
+      border: 'border',
+      border_top: 'border-top',
+      border_right: 'border-right',
+      border_bottom: 'border-bottom',
+      border_left: 'border-left',
+      border_radius: 'border-radius',
+      border_width: 'border-width',
+      border_left_width: 'border-left-width',
+      border_right_width: 'border-right-width',
+      border_top_width: 'border-top-width',
+      border_bottom_width: 'border-bottom-width',
+      border_color: 'border-color',
+      border_left_color: 'border-left-color',
+      border_right_color: 'border-right-color',
+      border_top_color: 'border-top-color',
+      border_bottom_color: 'border-bottom-color',
+      border_top_left_radius: 'border-top-left-radius',
+      border_top_right_radius: 'border-top-right-radius',
+      border_bottom_left_radius: 'border-bottom-left-radius',
+      border_bottom_right_radius: 'border-bottom-right-radius',
+      border_style: 'border-style',
+      border_left_style: 'border-left-style',
+      border_top_style: 'border-top-style',
+      border_right_style: 'border-right-style',
+      border_bottom_style: 'border-bottom-style',
+
+      // Outline properties
+      outline: 'outline',
+      outline_style: 'outline-style',
+      outline_color: 'outline-color',
+      outline_width: 'outline-width',
+      outline_offset: 'outline-offset',
+
+      // Display properties
+      display: 'display',
+      opacity: 'opacity',
+      visibility: 'visibility',
+
+      // Overflow properties
+      overflow: 'overflow',
+      overflow_x: 'overflow-x',
+      overflow_y: 'overflow-y',
+      overflow_block: 'overflow-block',
+      overflow_inline: 'overflow-inline',
+      overflow_clip_margin: 'overflow-clip-margin',
+
+      // Flexbox properties
+      flex: 'flex',
+      flex_direction: 'flex-direction',
+      flex_wrap: 'flex-wrap',
+      flex_flow: 'flex-flow',
+      flex_grow: 'flex-grow',
+      flex_shrink: 'flex-shrink',
+      flex_basis: 'flex-basis',
+      justify_content: 'justify-content',
+      justify_items: 'justify-items',
+      align_items: 'align-items',
+      align_self: 'align-self',
+      align_content: 'align-content',
+      order: 'order',
+      gap: 'gap',
+      row_gap: 'row-gap',
+      column_gap: 'column-gap',
+
+      // Grid properties
+      grid: 'grid',
+      grid_area: 'grid-area',
+      grid_template: 'grid-template',
+      grid_template_areas: 'grid-template-areas',
+      grid_template_rows: 'grid-template-rows',
+      grid_template_columns: 'grid-template-columns',
+      grid_row: 'grid-row',
+      grid_row_start: 'grid-row-start',
+      grid_row_end: 'grid-row-end',
+      grid_column: 'grid-column',
+      grid_column_start: 'grid-column-start',
+      grid_column_end: 'grid-column-end',
+      grid_gap: 'grid-gap',
+      grid_row_gap: 'grid-row-gap',
+      grid_column_gap: 'grid-column-gap',
+      grid_auto_flow: 'grid-auto-flow',
+      grid_auto_rows: 'grid-auto-rows',
+      grid_auto_columns: 'grid-auto-columns',
+
+      // Margin properties
+      margin: 'margin',
+      margin_left: 'margin-left',
+      margin_right: 'margin-right',
+      margin_top: 'margin-top',
+      margin_bottom: 'margin-bottom',
+
+      // Padding properties
+      padding: 'padding',
+      padding_left: 'padding-left',
+      padding_right: 'padding-right',
+      padding_top: 'padding-top',
+      padding_bottom: 'padding-bottom',
+
+      // Box properties
+      box_sizing: 'box-sizing',
+      box_shadow: 'box-shadow',
+
+      // Size properties
+      width: 'width',
+      min_width: 'min-width',
+      max_width: 'max-width',
+      height: 'height',
+      min_height: 'min-height',
+      max_height: 'max-height',
+
+      // Position properties
+      position: 'position',
+      top: 'top',
+      right: 'right',
+      bottom: 'bottom',
+      left: 'left',
+      z_index: 'z-index',
+
+      // Float properties
+      float: 'float',
+      clear: 'clear',
+
+      // Transform properties
+      transform: 'transform',
+      transform_origin: 'transform-origin',
+      transform_style: 'transform-style',
+      translate: 'translate',
+
+      // Font properties
+      font: 'font',
+      font_family: 'font-family',
+      font_size: 'font-size',
+      font_weight: 'font-weight',
+      font_style: 'font-style',
+      font_variant: 'font-variant',
+      font_stretch: 'font-stretch',
+      font_size_adjust: 'font-size-adjust',
+      font_synthesis: 'font-synthesis',
+      font_feature_settings: 'font-feature-settings',
+      font_kerning: 'font-kerning',
+      font_language_override: 'font-language-override',
+      font_optical_sizing: 'font-optical-sizing',
+      font_variant_alternates: 'font-variant-alternates',
+      font_variant_caps: 'font-variant-caps',
+      font_variant_east_asian: 'font-variant-east-asian',
+      font_variant_ligatures: 'font-variant-ligatures',
+      font_variant_numeric: 'font-variant-numeric',
+      font_variant_position: 'font-variant-position',
+
+      // Text properties
+      line_height: 'line-height',
+      letter_spacing: 'letter-spacing',
+      text_align: 'text-align',
+      text_decoration: 'text-decoration',
+      text_transform: 'text-transform',
+      white_space: 'white-space',
+      word_break: 'word-break',
+      word_wrap: 'word-wrap',
+      text_overflow: 'text-overflow',
+      text_shadow: 'text-shadow',
+      text_indent: 'text-indent',
+      text_justify: 'text-justify',
+      text_orientation: 'text-orientation',
+      text_rendering: 'text-rendering',
+      text_size_adjust: 'text-size-adjust',
+      text_combine_upright: 'text-combine-upright',
+      text_emphasis: 'text-emphasis',
+      text_emphasis_color: 'text-emphasis-color',
+      text_emphasis_position: 'text-emphasis-position',
+      text_emphasis_style: 'text-emphasis-style',
+      text_decoration_color: 'text-decoration-color',
+      text_decoration_line: 'text-decoration-line',
+      text_decoration_skip: 'text-decoration-skip',
+      text_decoration_skip_ink: 'text-decoration-skip-ink',
+      text_decoration_style: 'text-decoration-style',
+      text_underline_position: 'text-underline-position',
+      list_style: 'list-style',
+      list_style_type: 'list-style-type',
+      list_style_position: 'list-style-position',
+      list_style_image: 'list-style-image',
+
+      // Color properties
+      color: 'color',
+      accent_color: 'accent-color',
+
+      // Cursor properties
+      cursor: 'cursor',
+      pointer_events: 'pointer-events',
+
+      // Miscellaneous properties
+      vertical_align: 'vertical-align',
+      inset: 'inset',
+      inset_block: 'inset-block',
+      inset_block_start: 'inset-block-start',
+      inset_block_end: 'inset-block-end',
+      inset_inline: 'inset-inline',
+      inset_inline_start: 'inset-inline-start',
+      inset_inline_end: 'inset-inline-end',
+      // transitions
+      transition: 'transition',
+      transition_property: 'transition-property',
+      transition_duration: 'transition-duration',
+      transition_timing_function: 'transition-timing-function',
+      transition_delay: 'transition-delay',
+      // animation
+      animation: 'animation',
+      animation_name: 'animation-name',
+      animation_duration: 'animation-duration',
+      animation_timing_function: 'animation-timing-function',
+      animation_delay: 'animation-delay',
+      animation_iteration_count: 'animation-iteration-count',
+      animation_direction: 'animation-direction',
+      animation_fill_mode: 'animation-fill-mode',
+      animation_play_state: 'animation-play-state',
+      animation_timeline: 'animation-timeline',
+      // customizations
+      appearance: 'appearance',
+      user_select: 'user-select',
+      aspect_ratio: 'aspect-ratio',
+      resize: 'resize',
+      caret: 'caret',
+      caret_animation: 'caret-animation',
+      caret_shape: 'caret-shape',
+      caret_color: 'caret-color',
+      backdrop_filter: 'backdrop-filter',
+      backface_visibility: 'backface-visibility',
+      block_size: 'block-size',
+      writing_mode: 'writing-mode',
+      break_before: 'break-before',
+      break_after: 'break-after',
+      break_inside: 'break-inside',
+      clip: 'clip',
+      clip_path: 'clip-path',
+      clip_rule: 'clip-rule',
+      filter: 'filter',
+      float_offset: 'float-offset',
+      float_defer: 'float-defer',
+      hyphens: 'hyphens',
+      image_rendering: 'image-rendering',
+      image_orientation: 'image-orientation',
+      image_resolution: 'image-resolution',
+      isolation: 'isolation',
+      mix_blend_mode: 'mix-blend-mode',
+      object_fit: 'object-fit',
+      object_position: 'object-position',
+      overscroll_behavior: 'overscroll-behavior',
+      overscroll_behavior_x: 'overscroll-behavior-x',
+      overscroll_behavior_y: 'overscroll-behavior-y',
+      perspective: 'perspective',
+      perspective_origin: 'perspective-origin',
+      scroll_snap_margin: 'scroll-snap-margin',
+      scroll_snap_align: 'scroll-snap-align',
+      caption_side: 'caption-side',
+      empty_cells: 'empty-cells',
+      // svg and graphics
+      fill: 'fill',
+      fill_rule: 'fill-rule',
+      flood_color: 'flood-color',
+      flood_opacity: 'flood-opacity',
+      lighting_color: 'lighting-color',
+      marker_end: 'marker-end',
+      marker_mid: 'marker-mid',
+      marker_start: 'marker-start',
+      shape_rendering: 'shape-rendering',
+      stop_color: 'stop-color',
+      stop_opacity: 'stop-opacity',
+      stroke: 'stroke',
+      stroke_dasharray: 'stroke-dasharray',
+      stroke_dashoffset: 'stroke-dashoffset',
+      stroke_linecap: 'stroke-linecap',
+      stroke_linejoin: 'stroke-linejoin',
+      stroke_miterlimit: 'stroke-miterlimit',
+      stroke_opacity: 'stroke-opacity',
+      mask: 'mask',
+      mask_type: 'mask-type',
+      mask_image: 'mask-image',
+      mask_mode: 'mask-mode',
+      mask_repeat: 'mask-repeat',
+      mask_position: 'mask-position',
+      mask_clip: 'mask-clip',
+      mask_origin: 'mask-origin',
+      mask_size: 'mask-size',
+      mask_composite: 'mask-composite',
+      mask_border: 'mask-border',
+      mask_border_source: 'mask-border-source',
+      mask_border_mode: 'mask-border-mode',
+      mask_border_slice: 'mask-border-slice',
+      mask_border_width: 'mask-border-width',
+      mask_border_outset: 'mask-border-outset',
+      mask_border_repeat: 'mask-border-repeat',
+
+      //? only for pseudo-elements. Is the equivalent of content for ::before and ::after
+      $content: 'content',
+    };
+
+    expect(cssProps).toEqual(expectedProps);
+  });
+});

package/src/constants/__tests__/cssPseudoClasses.test.js

@@ -0,0 +1,48 @@
+import { describe, it, expect } from 'vitest';
+import { cssPseudoClasses } from '../cssPseudoClasses.js';
+
+describe('cssPseudoClasses constants', () => {
+  it('should include common interactive pseudo-classes', () => {
+    expect(cssPseudoClasses).toHaveProperty('hover');
+    expect(cssPseudoClasses).toHaveProperty('focus');
+    expect(cssPseudoClasses).toHaveProperty('active');
+    expect(cssPseudoClasses).toHaveProperty('visited');
+  });
+
+  it('should include form-related pseudo-classes', () => {
+    expect(cssPseudoClasses).toHaveProperty('enabled');
+    expect(cssPseudoClasses).toHaveProperty('disabled');
+    expect(cssPseudoClasses).toHaveProperty('checked');
+    expect(cssPseudoClasses).toHaveProperty('valid');
+    expect(cssPseudoClasses).toHaveProperty('invalid');
+    expect(cssPseudoClasses).toHaveProperty('required');
+    expect(cssPseudoClasses).toHaveProperty('optional');
+  });
+
+  it('should include structural pseudo-classes', () => {
+    expect(cssPseudoClasses).toHaveProperty('first_child');
+    expect(cssPseudoClasses).toHaveProperty('last_child');
+    expect(cssPseudoClasses).toHaveProperty('nth_child');
+    expect(cssPseudoClasses).toHaveProperty('empty');
+  });
+
+  it('should have correct CSS pseudo-class names', () => {
+    expect(cssPseudoClasses.hover).toBe('hover');
+    expect(cssPseudoClasses.first_child).toBe('first-child');
+    expect(cssPseudoClasses.last_child).toBe('last-child');
+    expect(cssPseudoClasses.nth_child).toBe('nth-child');
+    expect(cssPseudoClasses.read_only).toBe('read-only');
+  });
+
+  it('should convert underscores to hyphens in pseudo-class names', () => {
+    // Test that underscore-separated names map to hyphen-separated CSS
+    expect(cssPseudoClasses.placeholder_shown).toBe('placeholder-shown');
+    expect(cssPseudoClasses.out_of_range).toBe('out-of-range');
+    expect(cssPseudoClasses.user_invalid).toBe('user-invalid');
+  });
+
+  it('should be a comprehensive object with many pseudo-classes', () => {
+    const pseudoClassCount = Object.keys(cssPseudoClasses).length;
+    expect(pseudoClassCount).toBeGreaterThan(50); // Should have many pseudo-classes
+  });
+});

package/src/constants/compilerType.js

@@ -0,0 +1,14 @@
+/**
+ * Valid compiler types for Bernova CSS generation
+ * Determines what parts of the CSS will be compiled and output
+ */
+const compilerTypeValid = {
+  /** Generate only foundation styles (CSS variables, base styles, reset CSS) */
+  foundationOnly: 'foundationOnly',
+  /** Generate only component/theme styles (classes, utilities, media queries) */
+  componentOnly: 'componentOnly',
+  /** Generate both foundation and component styles (complete build) */
+  full: 'full',
+};
+
+module.exports = { compilerTypeValid };

package/src/constants/cssAdvancedSelectors.js

@@ -0,0 +1,32 @@
+/**
+ * CSS Advanced Selectors for Bernova
+ *
+ * Defines CSS selector combinators that enable advanced targeting of elements.
+ * These selectors allow for complex CSS relationships and precise element selection.
+ *
+ * @example
+ * // Using adjacent selector: targets next sibling
+ * { $advancedSelectors: [{ adjacent: { color: 'red' }, $target: '.item' }] }
+ * // Generates: .parent + .item { color: red; }
+ */
+const cssAdvancedSelectors = {
+  /** Adjacent sibling selector - targets the immediately following sibling */
+  adjacent: ' + ',
+
+  /** Direct child selector - targets only direct children */
+  child: ' > ',
+
+  /** Descendant selector - targets all nested descendants */
+  descendant: ' ',
+
+  /** General sibling selector - targets all following siblings */
+  near: ' ~ ',
+
+  /** Concatenation - combines selectors without space */
+  concat: '',
+
+  /** Column combinator - targets elements in table columns (CSS4) */
+  column: ' || ',
+};
+
+module.exports = { cssAdvancedSelectors };