@documental-xyz/core 0.1.0

package/src/assets/scripts/utils/ScrollObserver.js

@@ -0,0 +1,166 @@
+export default class ScrollObserver {
+  constructor(options = {}) {
+    this.options = {
+      threshold: options.threshold || [0, 1],
+      rootMargin: options.rootMargin || '0px',
+      throttleWait: options.throttleWait || 10 // ms entre atualizações do scroll
+    };
+    
+    this.observers = new Map();
+    this.scrollListeners = new Map();
+    this.visibleElements = new Set();
+  }
+
+  // Função de throttle para otimizar o scroll
+  throttle(func, wait) {
+    let timeout = null;
+    let previous = 0;
+    
+    return function(...args) {
+      const now = Date.now();
+      const remaining = wait - (now - previous);
+      
+      if (remaining <= 0 || remaining > wait) {
+        if (timeout) {
+          clearTimeout(timeout);
+          timeout = null;
+        }
+        previous = now;
+        func.apply(this, args);
+      } else if (!timeout) {
+        timeout = setTimeout(() => {
+          previous = Date.now();
+          timeout = null;
+          func.apply(this, args);
+        }, remaining);
+      }
+    };
+  }
+
+  // Observa um elemento específico
+  observe(element, callback) {
+    if (!element || !(element instanceof Element)) {
+      console.error('Elemento inválido');
+      return;
+    }
+
+    // Remove observadores existentes
+    this.unobserve(element);
+
+    // Cria o intersection observer
+    const intersectionObserver = new IntersectionObserver((entries) => {
+      entries.forEach((entry) => {
+        const isVisible = entry.isIntersecting;
+        
+        if (isVisible) {
+          // Quando o elemento se torna visível
+          this.visibleElements.add(element);
+          this.startScrollTracking(element, callback);
+        } else {
+          // Quando o elemento sai da vista
+          this.visibleElements.delete(element);
+          this.stopScrollTracking(element);
+        }
+
+        // Callback inicial com dados da intersecção
+        const data = {
+          isVisible,
+          intersectionRatio: entry.intersectionRatio,
+          boundingRect: entry.boundingClientRect,
+          element: entry.target,
+          scrollPosition: window.scrollY
+        };
+        
+        callback(data);
+      });
+    }, this.options);
+
+    // Armazena o observer
+    this.observers.set(element, intersectionObserver);
+    
+    // Inicia a observação
+    intersectionObserver.observe(element);
+  }
+
+  // Inicia o tracking de scroll para um elemento
+  startScrollTracking(element, callback) {
+    const handleScroll = () => {
+      if (this.visibleElements.has(element)) {
+        const boundingRect = element.getBoundingClientRect();
+        const data = {
+          isVisible: true,
+          intersectionRatio: this.calculateVisibleRatio(boundingRect),
+          boundingRect,
+          element,
+          scrollPosition: window.scrollY
+        };
+        callback(data);
+      }
+    };
+
+    // Cria versão throttled do handler
+    const throttledHandler = this.throttle(handleScroll, this.options.throttleWait);
+    
+    // Armazena referência ao listener
+    this.scrollListeners.set(element, throttledHandler);
+    
+    // Adiciona event listener
+    window.addEventListener('scroll', throttledHandler, { passive: true });
+  }
+
+  // Calcula quanto do elemento está visível
+  calculateVisibleRatio(boundingRect) {
+    const windowHeight = window.innerHeight;
+    const elementHeight = boundingRect.height;
+    
+    // Se o elemento estiver completamente fora da vista
+    if (boundingRect.bottom < 0 || boundingRect.top > windowHeight) {
+      return 0;
+    }
+    
+    // Se estiver completamente visível
+    if (boundingRect.top >= 0 && boundingRect.bottom <= windowHeight) {
+      return 1;
+    }
+    
+    // Calcula a parte visível
+    const visibleHeight = Math.min(boundingRect.bottom, windowHeight) - 
+                         Math.max(boundingRect.top, 0);
+    return visibleHeight / elementHeight;
+  }
+
+  // Para o tracking de scroll para um elemento
+  stopScrollTracking(element) {
+    const scrollHandler = this.scrollListeners.get(element);
+    if (scrollHandler) {
+      window.removeEventListener('scroll', scrollHandler);
+      this.scrollListeners.delete(element);
+    }
+  }
+
+  // Para de observar um elemento
+  unobserve(element) {
+    // Remove intersection observer
+    const observer = this.observers.get(element);
+    if (observer) {
+      observer.disconnect();
+      this.observers.delete(element);
+    }
+    
+    // Remove scroll listener
+    this.stopScrollTracking(element);
+    this.visibleElements.delete(element);
+  }
+
+  // Desconecta todos os observers e listeners
+  disconnectAll() {
+    this.observers.forEach((observer) => observer.disconnect());
+    this.observers.clear();
+    
+    this.scrollListeners.forEach((listener, element) => {
+      window.removeEventListener('scroll', listener);
+    });
+    this.scrollListeners.clear();
+    this.visibleElements.clear();
+  }
+}

package/src/assets/styles/config/_breakpoints.scss

@@ -0,0 +1,37 @@
+$breakpoints: (
+	'c': ('breakpoint': false,
+		'gutter': 30px,
+		'margin': 30px,
+		'cols': 4,
+	),
+	'xs': ('breakpoint': 321px,
+		'gutter': 30px,
+		'margin': 30px,
+		'cols': 4,
+	),
+	's': ('breakpoint': 576px,
+		'gutter': 30px,
+		'margin': 30px,
+		'cols': 4,
+	),
+	'm': ('breakpoint': 768px,
+		'gutter': 40px,
+		'margin': 40px,
+		'cols': 12,
+	),
+	'l': ('breakpoint': 992px,
+		'gutter': 40px,
+		'margin': 40px,
+		'cols': 12,
+	),
+	'x': ('breakpoint': 1280px,
+		'gutter': 40px,
+		'margin': 40px,
+		'cols': 12,
+	),
+	'xl': ('breakpoint': 1440px,
+		'gutter': 40px,
+		'margin': 40px,
+		'cols': 12,
+	),
+);

package/src/assets/styles/config/_colors.scss

@@ -0,0 +1,8 @@
+$colors: (
+    'black': (#000000, #FFFFFF),
+    'white': (#FFFFFF,#000000),
+    'highlight': (#FF7967, #FF7967),
+    'bg-highlight':  (#000000, #FFFFFF),
+) !default;
+
+$color-var-prefix: "clr";

package/src/assets/styles/config/_config.scss

@@ -0,0 +1,5 @@
+@forward 'breakpoints';
+@forward 'functions';
+@forward 'mixins';
+@forward '../globals/grrr';
+@forward 'vars';

package/src/assets/styles/config/_functions.scss

@@ -0,0 +1,90 @@
+@use "sass:color";
+@use "sass:list";
+@use "sass:map";
+
+@use "./colors" as *;
+
+@function pxToRem($px) {
+	$remUnit: 0.0625;
+	$rem: $px * $remUnit * 1rem;
+	@return $rem;
+}
+
+@function pxToVw($px, $viewportWidth: 1440) {
+	@return calc(100vw / $viewportWidth * $px);
+}
+
+@function sqrt($r) {
+	$x0: 1;
+	$x1: $x0;
+	@for $i from 1 through 10 {
+		$x1: $x0 - calc(($x0 * $x0 - abs($r)) / (2 * $x0));
+		$x0: $x1;
+	}
+	@return $x1;
+}
+
+@function strip-unit($number) {
+	@if type-of($number)=='number' and not unitless($number) {
+		$n: $number * 0 + 1;
+		@return calc($number / $n);
+	}
+	@return $number;
+}
+
+@function str-split($string, $separator) {
+	$split-arr: ();
+	$index : str-index($string, $separator);
+	@while $index !=null {
+		$item: str-slice($string, 1, $index - 1);
+		$split-arr: append($split-arr, $item);
+		$string: str-slice($string, $index + 1);
+		$index : str-index($string, $separator);
+	}
+	$split-arr: append($split-arr, $string);
+	@return $split-arr;
+}
+
+@function str-replace($string, $search, $replace: '') {
+	$index: str-index($string, $search);
+	@if $index {
+		@return str-slice($string, 1, $index - 1) + $replace + str-replace( str-slice($string, $index + str-length($search)), $search, $replace);
+	}
+	@return $string;
+}
+
+@function hex_to_rgb_values($hex) {
+  @return #{color.channel($hex, "red", rgb)}, #{color.channel($hex, "green", rgb)}, #{color.channel($hex, "blue", rgb)};
+}
+
+@function color($color, $alpha: 1) {
+  @if not map.get($colors, $color) {
+    @warn '-> "' + #{$color} + '" is not defined in colors configs';
+  }
+  @return rgba(var(--#{$color-var-prefix}-#{$color}-rgb), $alpha);
+}
+
+@function colorHex($color, $index: 1) {
+	@if not map.get($colors, $color) {
+    @warn '-> "' + #{$color} + '" is not defined in colors configs';
+  }
+
+	@return list.nth(map.get($colors, $color), $index);
+}
+
+@function columnsSize($cols, $gridCols: false, $grid-config: $grid-config) {
+  $name: map.get($map: $grid-config, $key: 'name' );
+  $colsSize: calcColumnSize($gridCols, var(--#{$name}-gutter));
+
+  @if($gridCols == false) {
+    $colsSize: var(--#{$name}-col-size);
+  }
+
+  @return calc(($colsSize + var(--#{$name}-gutter)) * $cols);
+}
+
+@function calcColumnSize($gridCols, $gutter, $width: 100%) {
+  $gutter-calc: calc(#{$gutter} * (#{$gridCols} - 1) / #{$gridCols});
+
+  @return calc(#{$width} / #{$gridCols} - #{$gutter-calc});
+}

package/src/assets/styles/config/_grrr.configs.scss

@@ -0,0 +1,7 @@
+@use './breakpoints' as *;
+
+$grrr-config: (
+  'name': 'atnl', // id que será usada como prefixo das classes
+  'board-max': 1356px, // tamanho máximo do board,
+  'breakpoints': $breakpoints, //array de breakpoints
+);

package/src/assets/styles/config/_mixins.scss

@@ -0,0 +1,207 @@
+@use "sass:map";
+@use "sass:list";
+@use './functions' as *;
+@use './breakpoints' as *;
+@use './type' as *;
+@use './colors' as *;
+
+//MIXINS
+//varname: gera uma variável no escopo css ao adicionar o tamanho
+@mixin fontSize($px,$varname: false, $root: false, $responsive: false){
+	@if($varname == false){
+		font-size: $px*1px;
+		font-size: pxToRem($px);
+		@if($responsive == true){ font-size: pxToVw($px);}
+	}@else{
+		@if($root != false){
+			#{--#{$type-var-prefix}-#{$varname}-fs-px}: $px*1px;
+			#{--#{$type-var-prefix}-#{$varname}-fs-rem}: pxToRem($px);
+			@if($responsive == true){ #{--#{$type-var-prefix}-#{$varname}-fs-vw}: pxToVw($px) };
+		}@else{
+			font-size: $px*1px;
+			font-size: var(--#{$type-var-prefix}-#{$varname}-fs-px,$px*1px);
+			font-size: var(--#{$type-var-prefix}-#{$varname}-fs-rem,pxToRem($px));
+			@if($responsive == true){ font-size:var(--#{$type-var-prefix}-#{$varname}-fs-vw,pxToVw($px)) };
+		}
+	}
+}
+
+@mixin lineHeight($pt, $varname:false, $root: false ){
+	@if($varname == false){
+			line-height: calc( round($pt * 1000) / 1000 );
+	}@else{
+			@if($root != false){
+					#{--#{$type-var-prefix}-#{$varname}-lh}: calc( round($pt * 1000) / 1000 );
+			}@else{
+					line-height: var(--#{$type-var-prefix}-#{$varname}-lh, calc( round($pt * 1000) / 1000) );
+			}
+	}
+}
+
+//insira a porcentagem conforme XD, aceita negativos
+@mixin letterSpacing($fontSizeInPx,$letterSpacingPercentage,$varname: false, $root: false, $responsive: false){
+	$ls: calc($fontSizeInPx / 100 ) * $letterSpacingPercentage;
+
+	@if($varname == false){
+		letter-spacing: $ls * 1px;
+		letter-spacing: pxToRem($ls);
+	@if($responsive == true){ letter-spacing: pxToVw($ls);}
+	}@else{
+		@if($root != false){
+			#{--#{$type-var-prefix}-#{$varname}-ls-px}: $ls * 1px;
+			#{--#{$type-var-prefix}-#{$varname}-ls-rem}: pxToRem($ls);
+			@if($responsive == true){ #{--#{$type-var-prefix}-#{$varname}-ls-vw}: pxToVw($ls);}
+		}@else{
+			letter-spacing: $ls * 1px;
+			letter-spacing: var(--#{$type-var-prefix}-#{$varname}-ls-px,$ls * 1px);
+			letter-spacing: var(--#{$type-var-prefix}-#{$varname}-ls-rem,pxToRem($ls));
+			@if($responsive == true){ letter-spacing: var(--#{$type-var-prefix}-#{$varname}-ls-vw,pxToVw($ls)); }
+		}
+	}
+}
+
+@mixin defineFont($varName: false, $fontSizePx: false, $lineHeight: false, $letterSpacing: false, $root: false, $responsive: false){
+	@if( $fontSizePx != false ) { @include fontSize($fontSizePx,$varName,$root,$responsive) };
+	@if( $lineHeight != false ) { @include lineHeight($lineHeight,$varName,$root) };
+	@if( $letterSpacing != false and $fontSizePx != false ) { @include letterSpacing($fontSizePx, $letterSpacing, $varName, $root, $responsive) };
+}
+
+//renderiza variáveis de acordo com objeto types no root
+@mixin typeVars($types:$types){
+	@each $type,$rows in $types{
+		$varName: $type;
+
+		@each $row in $rows{
+			$fontSize: false;
+			$lineHeight: false;
+			$letterSpacing: false;
+			$responsive: false;
+
+			@if( map.get($map: $row, $key: 'font-size') ){$fontSize: map.get($map: $row, $key: 'font-size')};
+			@if( map.get($map: $row, $key: 'line-height') ){$lineHeight: map.get($map: $row, $key: 'line-height')};
+			@if( map.get($map: $row, $key: 'letter-spacing') ){$letterSpacing: map.get($map: $row, $key: 'letter-spacing')};
+			@if( map.get($map: $row, $key: 'responsive') ){$responsive: map.get($map: $row, $key: 'responsive')};
+
+			@if( map.get($map: $row, $key: 'break') == false){
+				@include defineFont($varName, $fontSize, $lineHeight, $letterSpacing, true, $responsive);
+			}@else{
+				$break: map.get($map: $row, $key: 'break');
+				$varNameSufix: $varName + '-' + map.get($map: $break, $key: 'mixin') + '-' + str-replace(map.get($map: $break, $key: 'point'),',','-');
+				@include defineFont($varNameSufix, $fontSize, $lineHeight, $letterSpacing, true, $responsive );
+			}
+		}
+	}
+}
+
+//usado para definir fontes
+@mixin type($name){
+	$type: map.get($map: $types, $key: $name);
+
+	@if($type == null){ @error '-> "' + #{$name} + '" not defined at config/type.scss'; }
+
+	@each $row in $type{
+		$fontSize: false;
+		$lineHeight: false;
+		$letterSpacing: false;
+		$responsive: false;
+
+		@if( map.get($map: $row, $key: 'font-size') ){$fontSize: map.get($map: $row, $key: 'font-size')};
+		@if( map.get($map: $row, $key: 'line-height') ){$lineHeight: map.get($map: $row, $key: 'line-height')};
+		@if( map.get($map: $row, $key: 'letter-spacing') ){$letterSpacing: map.get($map: $row, $key: 'letter-spacing')};
+		@if( map.get($map: $row, $key: 'responsive') ){$responsive: map.get($map: $row, $key: 'responsive')};
+
+		$break: map.get($map: $row, $key: 'break');
+		@if( $break == false){
+			@include defineFont($name, $fontSize,  $lineHeight, $letterSpacing, false, $responsive);
+			@include typeValues($row);
+		}
+
+		@if( $break != false and map.get($map: $break, $key: 'mixin') == 'down'){
+			@include media-break-down( map.get($map: $break, $key: 'point'), map.get($map: $break, $key: 'vars')){
+				$varNameSufix: $name + '-' + map.get($map: $break, $key: 'mixin') + '-' + map.get($map: $break, $key: 'point');
+				@include defineFont($varNameSufix, $fontSize,  $lineHeight, $letterSpacing, false, $responsive);
+				@include typeValues($row);
+			};
+		}
+
+		@if( $break != false and map.get($map: $break, $key: 'mixin') == 'up'){
+			@include media-break-up( map.get($map: $break, $key: 'point'), map.get($map: $break, $key: 'vars')){
+				$varNameSufix: $name + '-' + map.get($map: $break, $key: 'mixin') + '-' + map.get($map: $break, $key: 'point');
+				@include defineFont($varNameSufix, $fontSize,  $lineHeight, $letterSpacing, false, $responsive);
+				@include typeValues($row);
+			};
+		}
+
+		@if( $break != false and map.get($map: $break, $key: 'mixin') == 'between'){
+			@include media-break-between( list.nth(str-split(map.get($map: $break, $key: 'point'),','),1), list.nth(str-split(map.get($map: $break, $key: 'point'),','),2), map.get($map: $break, $key: 'vars')){
+				$varNameSufix: $name + '-' + map.get($map: $break, $key: 'mixin') + '-' + str-replace(map.get($map: $break, $key: 'point'),',','-');
+				@include defineFont($varNameSufix, $fontSize,  $lineHeight, $letterSpacing, false, $responsive);
+				@include typeValues($row);
+			};
+		}
+	}
+}	
+
+
+//usado para pegar valores de type
+@mixin typeValues($row){
+	@each $key,$val in $row{
+		@if($key != 'font-size' and $key != 'line-height' and $key != 'letter-spacing' and $key != 'break' and $key != 'responsive'){
+			#{$key}: $val;
+		}
+	}
+}
+
+@mixin media-break-up($breakname,$breakpoints: $breakpoints) {
+	$this_break: map.get($map: $breakpoints, $key: $breakname);
+	$break-px: map.get($map: $this_break, $key: 'breakpoint');;
+
+	@media (min-width: $break-px) {
+			@content;
+	}
+}
+
+@mixin media-break-down($breakname,$breakpoints: $breakpoints) {
+	$this_break: map.get($map: $breakpoints, $key: $breakname);
+	$break-px: map.get($map: $this_break, $key: 'breakpoint') - 1px;
+
+	@media (max-width: $break-px) {
+			@content;
+	}
+}
+
+@mixin media-break-between($breakname-lower, $breakname-upper,$breakpoints: $breakpoints) {
+	$break-down: map.get($map: $breakpoints, $key: $breakname-lower);
+	$break-down: map.get($map: $break-down, $key: 'breakpoint');
+	$break-up: map.get($map: $breakpoints, $key: $breakname-upper);
+	$break-up: map.get($map: $break-up, $key: 'breakpoint') - 1px;
+
+	@media (min-width: $break-down ) and (max-width: $break-up ) {
+			@content;
+	}
+}
+
+// insere as varáveis das cores definidas
+@mixin print_colors_vars( $colors: $colors, $user_system_prefs: false){
+  @each $name, $arr in $colors {
+    --#{$color-var-prefix}-#{$name}: #{list.nth($arr,1)};
+    --#{$color-var-prefix}-#{$name}-rgb: #{hex_to_rgb_values(list.nth($arr,1))};
+  }
+
+  &[darkmode] {
+    @each $name,$arr in $colors {
+      --#{$color-var-prefix}-#{$name}: #{list.nth($arr,2)};
+      --#{$color-var-prefix}-#{$name}-rgb: #{hex_to_rgb_values((list.nth($arr,2)))};
+    }
+  }
+
+  @if($user_system_prefs) {
+    @media (prefers-color-scheme: dark) {
+      @each $name,$arr in $colors {
+        --#{$color-var-prefix}-#{$name}: #{list.nth($arr,2)};
+        --#{$color-var-prefix}-#{$name}-rgb: #{hex_to_rgb_values((list.nth($arr,2)))};
+      }
+    }
+  }
+}
+

package/src/assets/styles/config/_type.scss

@@ -0,0 +1,175 @@
+@use './breakpoints' as *;
+
+@import url('https://fonts.googleapis.com/css2?family=Noto+Serif:ital,wght@0,100..900;1,100..900&family=Rubik:ital,wght@0,300..900;1,300..900&display=swap');
+
+//fonts family variables
+$type-var-prefix: "tp";
+$mainfont: "Noto Serif";
+$displayfont: "Rubik";
+
+$types : (	
+	'b-xs': (('break': false,
+			'responsive': false,
+			'font-size': 12,
+			'line-height': 1.333,
+			'font-weight': 400,
+			'font-family': var(--ff-text, $mainfont),
+		),
+	),
+	
+	'b-s': (('break': false,
+			'responsive': false,
+			'font-size': 14,
+			'line-height': 1.42,
+			'font-weight': 400,
+			'font-family': var(--ff-text, $mainfont),
+		),
+	),
+	
+	'b-m': (('break': false,
+			'responsive': false,
+			'font-size': 16,
+			'line-height': 1.5,
+			'font-weight': 400,
+			'font-family': var(--ff-text, $mainfont),
+		),
+	),
+	
+	'c-xs': (('break': false,
+			'responsive': false,
+			'font-size': 12,
+			'line-height': 1.333,
+			'font-weight': 400,
+			'font-family': var(--ff-display, $displayfont),
+		),
+	),
+	
+	'c-s': (('break': false,
+			'responsive': false,
+			'font-size': 14,
+			'line-height': 1.42,
+			'font-weight': 400,
+			'font-family': var(--ff-display, $displayfont),
+		),
+	),
+	
+	'c-m': (('break': false,
+			'responsive': false,
+			'font-size': 16,
+			'line-height': 1.5,
+			'font-weight': 400,
+			'font-family': var(--ff-display, $displayfont),
+		),
+	),
+	
+	'h-xs': (('break': false,
+			'responsive': false,
+			'font-size': 20,
+			'line-height': 1.4,
+			'font-weight': 700,
+			'letter-spacing': -2,
+			'font-family': var(--ff-display, $displayfont),
+		),
+	),
+	
+	'h-s': (('break': false,
+			'responsive': false,
+			'font-size': 24,
+			'line-height': 1.333,
+			'font-weight': 700,
+			'letter-spacing': -2,
+			'font-family': var(--ff-display, $displayfont),
+		),
+	),
+	
+	'h-m': (('break': false,
+			'responsive': false,
+			'font-size': 28,
+			'line-height': 1.28,
+			'font-weight': 700,
+			'letter-spacing': -2,
+			'font-family': var(--ff-display, $displayfont),
+		),
+	),
+	
+	'h-l': (('break': false,
+			'responsive': false,
+			'font-size': 32,
+			'line-height': 1.25,
+			'font-weight': 700,
+			'letter-spacing': -2,
+			'font-family': var(--ff-display, $displayfont),
+		),
+	),
+	
+	'h-xl': (('break': false,
+			'responsive': false,
+			'font-size': 36,
+			'line-height': 1.2222222222,
+			'font-weight': 700,
+			'letter-spacing': -2,
+			'font-family': var(--ff-display, $displayfont),
+		),
+	),
+	
+	'h-xxl': (('break': false,
+			'responsive': false,
+			'font-size': 40,
+			'line-height': 1.2,
+			'font-weight': 700,
+			'letter-spacing': -2,
+			'font-family': var(--ff-display, $displayfont),
+		),
+	),
+	
+	'd-xs': (('break': false,
+			'responsive': false,
+			'font-size': 44,
+			'line-height': 1.18,
+			'font-weight': 700,
+			'letter-spacing': -2,
+			'font-family': var(--ff-display, $displayfont),
+		),
+	),
+	
+	'd-s': (('break': false,
+			'responsive': false,
+			'font-size': 48,
+			'line-height': 1.1666,
+			'font-weight': 700,
+			'letter-spacing': -2,
+			'font-family': var(--ff-display, $displayfont),
+		),
+	),
+	
+	'd-m': (('break': false,
+			'responsive': false,
+			'font-size': 52,
+			'line-height': 1.15,
+			'font-weight': 700,
+			'letter-spacing': -2,
+			'font-family': var(--ff-display, $displayfont),
+		),
+	),
+	
+	'd-l': (('break': false,
+			'responsive': false,
+			'font-size': 56,
+			'line-height': 1.14,
+			'font-weight': 700,
+			'letter-spacing': -2,
+			'font-family': var(--ff-display, $displayfont),
+		),
+	),
+	
+	'd-xl': (('break': false,
+			'responsive': false,
+			'font-size': 60,
+			'line-height': 1.133,
+			'font-weight': 700,
+			'letter-spacing': -2,
+			'font-family': var(--ff-display, $displayfont),
+		),
+	),
+
+) !default;