auklet 0.0.16 → 0.0.17

package/dist/css/core/styleImports/sourceReference.js

@@ -1,193 +1,173 @@
 import ts from 'typescript';
 export function collectModuleStyleSourceReferences(file, code) {
-  const imports = [];
-  const importBindings = new Map();
-  const localDeclarations = new Set();
-  const sourceFile = ts.createSourceFile(
-    file,
-    code,
-    ts.ScriptTarget.Latest,
-    false,
-    file.endsWith('.tsx') ? ts.ScriptKind.TSX : ts.ScriptKind.TS,
-  );
-  sourceFile.forEachChild((node) => {
-    collectLocalDeclarationNames(node, localDeclarations);
-    if (ts.isImportDeclaration(node)) {
-      collectImportBindings(node, importBindings);
-    }
-  });
-  sourceFile.forEachChild((node) => {
-    if (ts.isImportDeclaration(node)) {
-      if (!ts.isStringLiteral(node.moduleSpecifier)) {
-        return;
-      }
-      imports.push({
-        importPath: node.moduleSpecifier.text,
-        importClause: node.importClause,
-      });
-      return;
-    }
-    if (ts.isExportDeclaration(node)) {
-      collectExportDeclaration(
-        file,
-        node,
-        imports,
-        importBindings,
-        localDeclarations,
-      );
-    }
-  });
-  return imports;
+    const imports = [];
+    const importBindings = new Map();
+    const localDeclarations = new Set();
+    const sourceFile = ts.createSourceFile(file, code, ts.ScriptTarget.Latest, false, file.endsWith('.tsx') ? ts.ScriptKind.TSX : ts.ScriptKind.TS);
+    sourceFile.forEachChild((node) => {
+        collectLocalDeclarationNames(node, localDeclarations);
+        if (ts.isImportDeclaration(node)) {
+            collectImportBindings(node, importBindings);
+        }
+    });
+    sourceFile.forEachChild((node) => {
+        if (ts.isImportDeclaration(node)) {
+            if (!ts.isStringLiteral(node.moduleSpecifier)) {
+                return;
+            }
+            imports.push({
+                importPath: node.moduleSpecifier.text,
+                importClause: node.importClause,
+            });
+            return;
+        }
+        if (ts.isExportDeclaration(node)) {
+            collectExportDeclaration(file, node, imports, importBindings, localDeclarations);
+        }
+    });
+    return imports;
 }
 export function isTypeOnlySourceReference(item) {
-  return isTypeOnlyImportClause(item.importClause) || item.isTypeOnly;
+    return isTypeOnlyImportClause(item.importClause) || item.isTypeOnly;
 }
 export function getSourceReferenceImportedNames(file, item) {
-  if (item.importedNames) {
-    if (item.isTypeOnly) return [];
-    if (item.hasNamespaceImport) {
-      throw createNamespaceImportError(file, item.importPath);
-    }
-    return item.importedNames;
-  }
-  const importClause = item.importClause;
-  if (!importClause || isTypeOnlyImportClause(importClause)) {
-    return [];
-  }
-  const names = [];
-  if (importClause.name) {
-    names.push(importClause.name.text);
-  }
-  const namedBindings = importClause.namedBindings;
-  if (!namedBindings) {
+    if (item.importedNames) {
+        if (item.isTypeOnly)
+            return [];
+        if (item.hasNamespaceImport) {
+            throw createNamespaceImportError(file, item.importPath);
+        }
+        return item.importedNames;
+    }
+    const importClause = item.importClause;
+    if (!importClause || isTypeOnlyImportClause(importClause)) {
+        return [];
+    }
+    const names = [];
+    if (importClause.name) {
+        names.push(importClause.name.text);
+    }
+    const namedBindings = importClause.namedBindings;
+    if (!namedBindings) {
+        return names;
+    }
+    if (ts.isNamespaceImport(namedBindings)) {
+        throw createNamespaceImportError(file, item.importPath);
+    }
+    for (const element of namedBindings.elements) {
+        if (element.isTypeOnly)
+            continue;
+        names.push((element.propertyName ?? element.name).text);
+    }
     return names;
-  }
-  if (ts.isNamespaceImport(namedBindings)) {
-    throw createNamespaceImportError(file, item.importPath);
-  }
-  for (const element of namedBindings.elements) {
-    if (element.isTypeOnly) continue;
-    names.push((element.propertyName ?? element.name).text);
-  }
-  return names;
 }
 const collectLocalDeclarationNames = (node, localDeclarations) => {
-  if (
-    (ts.isFunctionDeclaration(node) ||
-      ts.isClassDeclaration(node) ||
-      ts.isInterfaceDeclaration(node) ||
-      ts.isTypeAliasDeclaration(node) ||
-      ts.isEnumDeclaration(node)) &&
-    node.name
-  ) {
-    localDeclarations.add(node.name.text);
-    return;
-  }
-  if (!ts.isVariableStatement(node)) return;
-  for (const declaration of node.declarationList.declarations) {
-    if (ts.isIdentifier(declaration.name)) {
-      localDeclarations.add(declaration.name.text);
-    }
-  }
+    if ((ts.isFunctionDeclaration(node) ||
+        ts.isClassDeclaration(node) ||
+        ts.isInterfaceDeclaration(node) ||
+        ts.isTypeAliasDeclaration(node) ||
+        ts.isEnumDeclaration(node)) &&
+        node.name) {
+        localDeclarations.add(node.name.text);
+        return;
+    }
+    if (!ts.isVariableStatement(node))
+        return;
+    for (const declaration of node.declarationList.declarations) {
+        if (ts.isIdentifier(declaration.name)) {
+            localDeclarations.add(declaration.name.text);
+        }
+    }
 };
 const collectImportBindings = (node, importBindings) => {
-  if (!ts.isStringLiteral(node.moduleSpecifier) || !node.importClause) {
-    return;
-  }
-  const importPath = node.moduleSpecifier.text;
-  const isTypeOnly = isTypeOnlyImportClause(node.importClause);
-  if (node.importClause.name) {
-    const importedName = node.importClause.name.text;
-    importBindings.set(importedName, {
-      importPath,
-      importedName,
-      isTypeOnly,
-      hasNamespaceImport: false,
-    });
-  }
-  const namedBindings = node.importClause.namedBindings;
-  if (!namedBindings) return;
-  if (ts.isNamespaceImport(namedBindings)) {
-    importBindings.set(namedBindings.name.text, {
-      importPath,
-      importedName: namedBindings.name.text,
-      isTypeOnly,
-      hasNamespaceImport: true,
-    });
-    return;
-  }
-  for (const element of namedBindings.elements) {
-    const importedName = (element.propertyName ?? element.name).text;
-    importBindings.set(element.name.text, {
-      importPath,
-      importedName,
-      isTypeOnly: isTypeOnly || element.isTypeOnly,
-      hasNamespaceImport: false,
-    });
-  }
+    if (!ts.isStringLiteral(node.moduleSpecifier) || !node.importClause) {
+        return;
+    }
+    const importPath = node.moduleSpecifier.text;
+    const isTypeOnly = isTypeOnlyImportClause(node.importClause);
+    if (node.importClause.name) {
+        const importedName = node.importClause.name.text;
+        importBindings.set(importedName, {
+            importPath,
+            importedName,
+            isTypeOnly,
+            hasNamespaceImport: false,
+        });
+    }
+    const namedBindings = node.importClause.namedBindings;
+    if (!namedBindings)
+        return;
+    if (ts.isNamespaceImport(namedBindings)) {
+        importBindings.set(namedBindings.name.text, {
+            importPath,
+            importedName: namedBindings.name.text,
+            isTypeOnly,
+            hasNamespaceImport: true,
+        });
+        return;
+    }
+    for (const element of namedBindings.elements) {
+        const importedName = (element.propertyName ?? element.name).text;
+        importBindings.set(element.name.text, {
+            importPath,
+            importedName,
+            isTypeOnly: isTypeOnly || element.isTypeOnly,
+            hasNamespaceImport: false,
+        });
+    }
 };
-const collectExportDeclaration = (
-  file,
-  node,
-  imports,
-  importBindings,
-  localDeclarations,
-) => {
-  if (node.moduleSpecifier) {
-    if (!ts.isStringLiteral(node.moduleSpecifier)) return;
+const collectExportDeclaration = (file, node, imports, importBindings, localDeclarations) => {
+    if (node.moduleSpecifier) {
+        if (!ts.isStringLiteral(node.moduleSpecifier))
+            return;
+        if (!node.exportClause || !ts.isNamedExports(node.exportClause)) {
+            throw new Error(`[auklet:css] Export-all declarations are not supported for CSS auto import: ${node.moduleSpecifier.text}\n` +
+                `Use named exports instead, for example: export { Component } from '${node.moduleSpecifier.text}'.\n` +
+                `File: ${file}`);
+        }
+        imports.push({
+            importPath: node.moduleSpecifier.text,
+            importedNames: getExportedNames(node),
+            isTypeOnly: node.isTypeOnly,
+        });
+        return;
+    }
     if (!node.exportClause || !ts.isNamedExports(node.exportClause)) {
-      throw new Error(
-        `[auklet:css] Export-all declarations are not supported for CSS auto import: ${node.moduleSpecifier.text}\n` +
-          `Use named exports instead, for example: export { Component } from '${node.moduleSpecifier.text}'.\n` +
-          `File: ${file}`,
-      );
-    }
-    imports.push({
-      importPath: node.moduleSpecifier.text,
-      importedNames: getExportedNames(node),
-      isTypeOnly: node.isTypeOnly,
-    });
-    return;
-  }
-  if (!node.exportClause || !ts.isNamedExports(node.exportClause)) {
-    return;
-  }
-  for (const element of node.exportClause.elements) {
-    if (node.isTypeOnly || element.isTypeOnly) continue;
-    const localName = (element.propertyName ?? element.name).text;
-    const binding = importBindings.get(localName);
-    if (binding) {
-      imports.push({
-        importPath: binding.importPath,
-        importedNames: [binding.importedName],
-        isTypeOnly: binding.isTypeOnly,
-        hasNamespaceImport: binding.hasNamespaceImport,
-      });
-      continue;
-    }
-    if (!localDeclarations.has(localName)) {
-      throw new Error(
-        `[auklet:css] Unable to resolve exported symbol "${localName}" for CSS auto import.\n` +
-          `File: ${file}`,
-      );
-    }
-  }
+        return;
+    }
+    for (const element of node.exportClause.elements) {
+        if (node.isTypeOnly || element.isTypeOnly)
+            continue;
+        const localName = (element.propertyName ?? element.name).text;
+        const binding = importBindings.get(localName);
+        if (binding) {
+            imports.push({
+                importPath: binding.importPath,
+                importedNames: [binding.importedName],
+                isTypeOnly: binding.isTypeOnly,
+                hasNamespaceImport: binding.hasNamespaceImport,
+            });
+            continue;
+        }
+        if (!localDeclarations.has(localName)) {
+            throw new Error(`[auklet:css] Unable to resolve exported symbol "${localName}" for CSS auto import.\n` +
+                `File: ${file}`);
+        }
+    }
 };
 const getExportedNames = (node) => {
-  if (!node.exportClause || !ts.isNamedExports(node.exportClause)) {
-    return [];
-  }
-  return node.exportClause.elements
-    .filter((element) => !element.isTypeOnly)
-    .map((element) => (element.propertyName ?? element.name).text);
+    if (!node.exportClause || !ts.isNamedExports(node.exportClause)) {
+        return [];
+    }
+    return node.exportClause.elements
+        .filter((element) => !element.isTypeOnly)
+        .map((element) => (element.propertyName ?? element.name).text);
 };
 const isTypeOnlyImportClause = (importClause) => {
-  return importClause?.phaseModifier === ts.SyntaxKind.TypeKeyword;
+    return importClause?.phaseModifier === ts.SyntaxKind.TypeKeyword;
 };
 const createNamespaceImportError = (file, importPath) => {
-  return new Error(
-    `Namespace import is not supported for CSS auto import: ${importPath}\n` +
-      `Use named imports instead, for example: import { Component } from '${importPath}'.\n` +
-      `File: ${file}`,
-  );
+    return new Error(`Namespace import is not supported for CSS auto import: ${importPath}\n` +
+        `Use named imports instead, for example: import { Component } from '${importPath}'.\n` +
+        `File: ${file}`);
 };

package/dist/css/core/styleModuleEntryPlanner.d.ts

@@ -1,29 +1,26 @@
 import type { StylePackageContext } from '#auklet/css/core/stylePackageContext';
 export type ModuleStyleEntryPlan = {
-  sourceDir: string;
-  moduleStyleImports: Array<string>;
-  ownStyleFiles: Array<string>;
+    sourceDir: string;
+    moduleStyleImports: Array<string>;
+    ownStyleFiles: Array<string>;
 };
 export declare class StyleModuleEntryPlanner {
-  private readonly packageContext;
-  private readonly styleFilesByDir;
-  private readonly importedStyleFiles;
-  constructor(packageContext: StylePackageContext);
-  createEntries(moduleStyleImports: Map<string, Array<string>>): {
-    sourceDir: string;
-    moduleStyleImports: string[];
-    ownStyleFiles: string[];
-  }[];
-  createEntry(
-    sourceDir: string,
-    moduleStyleImports: Map<string, Array<string>>,
-  ): {
-    sourceDir: string;
-    moduleStyleImports: string[];
-    ownStyleFiles: string[];
-  };
-  private getSourceDirs;
-  private getSourceModuleDirs;
-  private getOwnStyleDirs;
-  private getOwnStyleFiles;
+    private readonly packageContext;
+    private readonly styleFilesByDir;
+    private readonly importedStyleFiles;
+    constructor(packageContext: StylePackageContext);
+    createEntries(moduleStyleImports: Map<string, Array<string>>): {
+        sourceDir: string;
+        moduleStyleImports: string[];
+        ownStyleFiles: string[];
+    }[];
+    createEntry(sourceDir: string, moduleStyleImports: Map<string, Array<string>>): {
+        sourceDir: string;
+        moduleStyleImports: string[];
+        ownStyleFiles: string[];
+    };
+    private getSourceDirs;
+    private getSourceModuleDirs;
+    private getOwnStyleDirs;
+    private getOwnStyleFiles;
 }

package/dist/css/core/styleModuleEntryPlanner.js

@@ -3,65 +3,48 @@ import { SOURCE_COMPONENT_MODULE_RE } from '#auklet/css/constants';
 import { groupStyleFilesByDir } from '#auklet/css/core/style/files';
 import { getSourceModuleDir, toPosixPath } from '#auklet/utils';
 export class StyleModuleEntryPlanner {
-  packageContext;
-  styleFilesByDir;
-  importedStyleFiles;
-  constructor(packageContext) {
-    this.packageContext = packageContext;
-    this.styleFilesByDir = groupStyleFilesByDir(
-      this.packageContext.sourceRoot,
-      this.packageContext.styleFiles,
-    );
-    this.importedStyleFiles =
-      this.packageContext.styleProcessor.collectImportedStyleFiles(
-        this.packageContext.styleFiles,
-      );
-  }
-  createEntries(moduleStyleImports) {
-    return this.getSourceDirs(moduleStyleImports).map((sourceDir) =>
-      this.createEntry(sourceDir, moduleStyleImports),
-    );
-  }
-  createEntry(sourceDir, moduleStyleImports) {
-    return {
-      sourceDir,
-      moduleStyleImports: moduleStyleImports.get(sourceDir) ?? [],
-      ownStyleFiles: this.getOwnStyleFiles(sourceDir),
-    };
-  }
-  getSourceDirs(moduleStyleImports) {
-    return Array.from(
-      new Set([
-        ...this.getSourceModuleDirs(),
-        ...this.getOwnStyleDirs(),
-        ...moduleStyleImports.keys(),
-      ]),
-    ).filter((sourceDir) => sourceDir !== '.');
-  }
-  getSourceModuleDirs() {
-    return this.packageContext.sourceFiles
-      .filter((sourceFile) => SOURCE_COMPONENT_MODULE_RE.test(sourceFile))
-      .map((sourceFile) => {
-        return getSourceModuleDir(
-          path.relative(this.packageContext.sourceRoot, sourceFile),
-        );
-      })
-      .filter((sourceModuleDir) => {
-        return toPosixPath(sourceModuleDir).split('/').length === 2;
-      });
-  }
-  getOwnStyleDirs() {
-    return Array.from(this.styleFilesByDir.entries())
-      .filter(([, dirStyleFiles]) =>
-        dirStyleFiles.some(
-          (styleFile) => !this.importedStyleFiles.has(path.resolve(styleFile)),
-        ),
-      )
-      .map(([sourceDir]) => sourceDir);
-  }
-  getOwnStyleFiles(sourceDir) {
-    return (this.styleFilesByDir.get(sourceDir) ?? []).filter(
-      (styleFile) => !this.importedStyleFiles.has(path.resolve(styleFile)),
-    );
-  }
+    packageContext;
+    styleFilesByDir;
+    importedStyleFiles;
+    constructor(packageContext) {
+        this.packageContext = packageContext;
+        this.styleFilesByDir = groupStyleFilesByDir(this.packageContext.sourceRoot, this.packageContext.styleFiles);
+        this.importedStyleFiles =
+            this.packageContext.styleProcessor.collectImportedStyleFiles(this.packageContext.styleFiles);
+    }
+    createEntries(moduleStyleImports) {
+        return this.getSourceDirs(moduleStyleImports).map((sourceDir) => this.createEntry(sourceDir, moduleStyleImports));
+    }
+    createEntry(sourceDir, moduleStyleImports) {
+        return {
+            sourceDir,
+            moduleStyleImports: moduleStyleImports.get(sourceDir) ?? [],
+            ownStyleFiles: this.getOwnStyleFiles(sourceDir),
+        };
+    }
+    getSourceDirs(moduleStyleImports) {
+        return Array.from(new Set([
+            ...this.getSourceModuleDirs(),
+            ...this.getOwnStyleDirs(),
+            ...moduleStyleImports.keys(),
+        ])).filter((sourceDir) => sourceDir !== '.');
+    }
+    getSourceModuleDirs() {
+        return this.packageContext.sourceFiles
+            .filter((sourceFile) => SOURCE_COMPONENT_MODULE_RE.test(sourceFile))
+            .map((sourceFile) => {
+            return getSourceModuleDir(path.relative(this.packageContext.sourceRoot, sourceFile));
+        })
+            .filter((sourceModuleDir) => {
+            return toPosixPath(sourceModuleDir).split('/').length === 2;
+        });
+    }
+    getOwnStyleDirs() {
+        return Array.from(this.styleFilesByDir.entries())
+            .filter(([, dirStyleFiles]) => dirStyleFiles.some((styleFile) => !this.importedStyleFiles.has(path.resolve(styleFile))))
+            .map(([sourceDir]) => sourceDir);
+    }
+    getOwnStyleFiles(sourceDir) {
+        return (this.styleFilesByDir.get(sourceDir) ?? []).filter((styleFile) => !this.importedStyleFiles.has(path.resolve(styleFile)));
+    }
 }

package/dist/css/core/stylePackageContext.d.ts

@@ -1,27 +1,23 @@
 import { ModuleStyleImportCollector } from '#auklet/css/core/styleImports/collector';
 import { StyleProcessor } from '#auklet/css/core/styleProcessor';
 import { WorkspaceStyleResolver } from '#auklet/css/core/workspaceStyleResolver';
-import type {
-  ModuleStyleBuildConfig,
-  NormalizedAukletConfig,
-  ResolvedModuleStyleBuildContext,
-} from '#auklet/types';
+import type { ModuleStyleBuildConfig, NormalizedAukletConfig, ResolvedModuleStyleBuildContext } from '#auklet/types';
 export type StylePackageContextOptions = {
-  config: ModuleStyleBuildConfig;
-  context: ResolvedModuleStyleBuildContext;
-  normalizedConfig: NormalizedAukletConfig;
+    config: ModuleStyleBuildConfig;
+    context: ResolvedModuleStyleBuildContext;
+    normalizedConfig: NormalizedAukletConfig;
 };
 export declare class StylePackageContext {
-  private readonly options;
-  readonly normalizedConfig: NormalizedAukletConfig;
-  readonly sourceRoot: string;
-  readonly resolver: WorkspaceStyleResolver;
-  readonly styleProcessor: StyleProcessor;
-  readonly importCollector: ModuleStyleImportCollector;
-  readonly sourceFiles: Array<string>;
-  readonly themeFiles: Map<string, string>;
-  readonly themeNames: Array<string>;
-  readonly styleFiles: Array<string>;
-  constructor(options: StylePackageContextOptions);
-  getStyleFiles(files: Array<string>): string[];
+    private readonly options;
+    readonly normalizedConfig: NormalizedAukletConfig;
+    readonly sourceRoot: string;
+    readonly resolver: WorkspaceStyleResolver;
+    readonly styleProcessor: StyleProcessor;
+    readonly importCollector: ModuleStyleImportCollector;
+    readonly sourceFiles: Array<string>;
+    readonly themeFiles: Map<string, string>;
+    readonly themeNames: Array<string>;
+    readonly styleFiles: Array<string>;
+    constructor(options: StylePackageContextOptions);
+    getStyleFiles(files: Array<string>): string[];
 }

package/dist/css/core/stylePackageContext.js

@@ -3,55 +3,39 @@ import path from 'node:path';
 import { ModuleStyleImportCollector } from '#auklet/css/core/styleImports/collector';
 import { StyleProcessor } from '#auklet/css/core/styleProcessor';
 import { WorkspaceStyleResolver } from '#auklet/css/core/workspaceStyleResolver';
-import {
-  createStyleFileKey,
-  createStyleFileKeySet,
-} from '#auklet/css/core/style/files';
-import {
-  getThemeNames,
-  resolveThemeStyleFiles,
-} from '#auklet/css/core/style/dependencies';
+import { createStyleFileKey, createStyleFileKeySet, } from '#auklet/css/core/style/files';
+import { getThemeNames, resolveThemeStyleFiles, } from '#auklet/css/core/style/dependencies';
 import { fileWalker } from '#auklet/utils';
 export class StylePackageContext {
-  options;
-  normalizedConfig;
-  sourceRoot;
-  resolver;
-  styleProcessor;
-  importCollector;
-  sourceFiles;
-  themeFiles;
-  themeNames;
-  styleFiles;
-  constructor(options) {
-    this.options = options;
-    const { config, context, normalizedConfig } = this.options;
-    this.normalizedConfig = normalizedConfig;
-    this.sourceRoot = path.join(context.packageRoot, context.sourceDir);
-    this.resolver = new WorkspaceStyleResolver(config, context);
-    this.styleProcessor = new StyleProcessor(config, this.resolver);
-    this.importCollector = new ModuleStyleImportCollector(
-      this.sourceRoot,
-      context.packageRoot,
-      this.resolver,
-      config.styleExtensions,
-    );
-    this.sourceFiles = fs.existsSync(this.sourceRoot)
-      ? fileWalker(this.sourceRoot)
-      : [];
-    this.themeFiles = resolveThemeStyleFiles(
-      normalizedConfig,
-      context.packageRoot,
-    );
-    this.themeNames = getThemeNames(normalizedConfig);
-    this.styleFiles = this.getStyleFiles(this.sourceFiles);
-  }
-  getStyleFiles(files) {
-    const themeFileKeys = createStyleFileKeySet(this.themeFiles.values());
-    return files
-      .filter((file) =>
-        this.options.config.styleExtensions.includes(path.extname(file)),
-      )
-      .filter((styleFile) => !themeFileKeys.has(createStyleFileKey(styleFile)));
-  }
+    options;
+    normalizedConfig;
+    sourceRoot;
+    resolver;
+    styleProcessor;
+    importCollector;
+    sourceFiles;
+    themeFiles;
+    themeNames;
+    styleFiles;
+    constructor(options) {
+        this.options = options;
+        const { config, context, normalizedConfig } = this.options;
+        this.normalizedConfig = normalizedConfig;
+        this.sourceRoot = path.join(context.packageRoot, context.sourceDir);
+        this.resolver = new WorkspaceStyleResolver(config, context);
+        this.styleProcessor = new StyleProcessor(config, this.resolver);
+        this.importCollector = new ModuleStyleImportCollector(this.sourceRoot, context.packageRoot, this.resolver, config.styleExtensions);
+        this.sourceFiles = fs.existsSync(this.sourceRoot)
+            ? fileWalker(this.sourceRoot)
+            : [];
+        this.themeFiles = resolveThemeStyleFiles(normalizedConfig, context.packageRoot);
+        this.themeNames = getThemeNames(normalizedConfig);
+        this.styleFiles = this.getStyleFiles(this.sourceFiles);
+    }
+    getStyleFiles(files) {
+        const themeFileKeys = createStyleFileKeySet(this.themeFiles.values());
+        return files
+            .filter((file) => this.options.config.styleExtensions.includes(path.extname(file)))
+            .filter((styleFile) => !themeFileKeys.has(createStyleFileKey(styleFile)));
+    }
 }