@fgv/ts-res 5.0.0-2 → 5.0.0-21

package/src/packlets/zip-archive/convert.ts

@@ -0,0 +1,121 @@
+/*
+ * Copyright (c) 2025 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+/* eslint-disable @rushstack/typedef-var */
+
+import { Validator, Validators, Converter, Converters } from '@fgv/ts-utils';
+import * as Json from './json';
+import { Model as ConfigModel, Convert as ConfigConvert } from '../config';
+
+/**
+ * Validator for ZIP archive input type
+ * @public
+ */
+export const zipArchiveInputType: Validator<'file' | 'directory'> = Validators.enumeratedValue([
+  'file',
+  'directory'
+] as const);
+
+/**
+ * Validator for ZIP archive config type
+ * @public
+ */
+export const zipArchiveConfigType: Validator<'file'> = Validators.enumeratedValue(['file'] as const);
+
+/**
+ * Validator for ZIP archive input information
+ * @public
+ */
+export const zipArchiveInputInfo: Validator<Json.IZipArchiveInputInfo> =
+  Validators.object<Json.IZipArchiveInputInfo>({
+    type: zipArchiveInputType,
+    originalPath: Validators.string,
+    archivePath: Validators.string
+  });
+
+/**
+ * Validator for ZIP archive config information
+ * @public
+ */
+export const zipArchiveConfigInfo: Validator<Json.IZipArchiveConfigInfo> =
+  Validators.object<Json.IZipArchiveConfigInfo>({
+    type: zipArchiveConfigType,
+    originalPath: Validators.string,
+    archivePath: Validators.string
+  });
+
+/**
+ * Validator for ZIP archive manifest
+ * Compatible with existing tools from ts-res-browser-cli
+ * @public
+ */
+export const zipArchiveManifest: Validator<Json.IZipArchiveManifest> =
+  Validators.object<Json.IZipArchiveManifest>({
+    timestamp: Validators.string,
+    input: zipArchiveInputInfo.optional(),
+    config: zipArchiveConfigInfo.optional()
+  });
+
+/**
+ * Validator for MIME type strings
+ * @public
+ */
+export const mimeType: Validator<string> = Validators.string;
+
+/**
+ * Converter for imported file
+ * @public
+ */
+export const importedFile: Converter<Json.IImportedFile> = Converters.strictObject<Json.IImportedFile>({
+  name: Converters.string,
+  path: Converters.string,
+  content: Converters.string,
+  type: Converters.string // MIME type as string
+});
+
+/**
+ * Converter for imported directory structure (recursive)
+ * Note: Uses Converter pattern because Validators don't support recursion with self parameter
+ * @public
+ */
+export const importedDirectory: Converter<Json.IImportedDirectory> = Converters.generic<
+  Json.IImportedDirectory,
+  unknown
+>((from: unknown, self: Converter<Json.IImportedDirectory, unknown>, context?: unknown) => {
+  return Converters.strictObject<Json.IImportedDirectory>({
+    name: Converters.string,
+    files: Converters.arrayOf(importedFile),
+    subdirectories: Converters.arrayOf(self)
+  }).convert(from, context);
+});
+
+/**
+ * Validator for system configuration (delegates to config packlet)
+ * This validates that the parsed JSON conforms to the system configuration schema
+ * @public
+ */
+export const systemConfiguration: Validator<ConfigModel.ISystemConfiguration> = Validators.isA(
+  'system configuration',
+  (value: unknown): value is ConfigModel.ISystemConfiguration => {
+    return ConfigConvert.systemConfiguration.convert(value).isSuccess();
+  }
+);

package/src/packlets/zip-archive/index.ts

@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) 2025 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+/**
+ * ZIP archive functionality for ts-res source file archives
+ *
+ * This packlet provides consolidated ZIP archive creation and loading functionality
+ * for source files, compatible with existing tools while using fflate for
+ * universal browser compatibility.
+ *
+ * @remarks
+ * ZIP archives contain source files for resource ingestion with directory
+ * structure preserved and optional validation but no processing or transformation.
+ * This is distinct from ZIP bundles which contain processed resource output.
+ *
+ * @packageDocumentation
+ */
+
+import * as Json from './json';
+import * as Convert from './convert';
+
+// Namespaces
+export { Json, Convert };
+
+// Core classes
+export { ZipArchiveCreator } from './zipArchiveCreator';
+export { ZipArchiveLoader } from './zipArchiveLoader';
+
+// Types and interfaces
+export type {
+  IZipArchivePathOptions,
+  IZipArchiveFileTreeOptions,
+  ZipArchiveOptions,
+  IZipArchiveResult,
+  IZipArchiveManifest,
+  IZipArchiveLoadOptions,
+  IZipArchiveLoadResult,
+  IImportedFile,
+  IImportedDirectory,
+  ZipArchiveProgressCallback
+} from './types';
+
+// Format utilities
+export {
+  createZipArchiveManifest,
+  parseZipArchiveManifest,
+  validateZipArchiveManifest,
+  parseZipArchiveConfiguration,
+  generateZipArchiveFilename,
+  normalizePath,
+  getDirectoryName,
+  sanitizeFilename,
+  isZipFile
+} from './zipArchiveFormat';
+
+// Constants
+export { ZipArchiveConstants } from './types';

package/src/packlets/zip-archive/json.ts

@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) 2025 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+/**
+ * JSON representation of ZIP archive input information
+ * @public
+ */
+export interface IZipArchiveInputInfo {
+  /** Type of input (file or directory) */
+  type: 'file' | 'directory';
+  /** Original file/directory path */
+  originalPath: string;
+  /** Path within the archive (e.g., "input/mydir") */
+  archivePath: string;
+}
+
+/**
+ * JSON representation of ZIP archive config information
+ * @public
+ */
+export interface IZipArchiveConfigInfo {
+  /** Type of config (always 'file') */
+  type: 'file';
+  /** Original config file path */
+  originalPath: string;
+  /** Path within the archive (e.g., "config.json") */
+  archivePath: string;
+}
+
+/**
+ * JSON representation of a ZIP archive manifest
+ * Compatible with existing tools from ts-res-browser-cli
+ * @public
+ */
+export interface IZipArchiveManifest {
+  /** Archive creation timestamp */
+  timestamp: string;
+
+  /** Optional input source information */
+  input?: IZipArchiveInputInfo;
+
+  /** Optional configuration file information */
+  config?: IZipArchiveConfigInfo;
+}
+
+/**
+ * JSON representation of an imported file
+ * @public
+ */
+export interface IImportedFile {
+  /** File name */
+  name: string;
+  /** Full path within archive */
+  path: string;
+  /** File content as string */
+  content: string;
+  /** MIME type */
+  type: string;
+}
+
+/**
+ * JSON representation of an imported directory structure
+ * @public
+ */
+export interface IImportedDirectory {
+  /** Directory name */
+  name: string;
+  /** Files in this directory */
+  files: IImportedFile[];
+  /** Subdirectories */
+  subdirectories: IImportedDirectory[];
+}

package/src/packlets/zip-archive/types.ts

@@ -0,0 +1,140 @@
+/*
+ * Copyright (c) 2025 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+import { Model as ConfigModel } from '../config';
+import * as Json from './json';
+import { FileTree } from '@fgv/ts-utils';
+
+/**
+ * Options for creating a ZIP archive buffer
+ * @public
+ */
+export interface IZipArchivePathOptions {
+  /** File or directory path to include in the archive */
+  inputPath?: string;
+  /** Optional configuration file path */
+  configPath?: string;
+}
+
+/**
+ * Options for creating a ZIP archive buffer from a file tree
+ * @public
+ */
+export interface IZipArchiveFileTreeOptions {
+  /** Input file or directory */
+  inputItem?: FileTree.FileTreeItem;
+  /** Optional configuration file */
+  configItem?: FileTree.IFileTreeFileItem;
+}
+
+/**
+ * Options for creating a ZIP archive buffer
+ * @public
+ */
+export type ZipArchiveOptions = IZipArchivePathOptions | IZipArchiveFileTreeOptions;
+
+/**
+ * Standardized ZIP archive manifest format (compatible with existing tools)
+ * @public
+ */
+export type IZipArchiveManifest = Json.IZipArchiveManifest;
+
+/**
+ * Result of ZIP archive buffer creation
+ * @public
+ */
+export interface IZipArchiveResult {
+  /** Raw ZIP data buffer */
+  zipBuffer: Uint8Array;
+  /** Archive manifest with metadata */
+  manifest: IZipArchiveManifest;
+  /** Total ZIP size in bytes */
+  size: number;
+}
+
+/**
+ * Options for loading a ZIP archive
+ * @public
+ */
+export interface IZipArchiveLoadOptions {
+  /** Validate manifest strictly */
+  strictManifestValidation?: boolean;
+}
+
+/**
+ * Result of ZIP archive loading
+ * @public
+ */
+export interface IZipArchiveLoadResult {
+  /** Parsed archive manifest */
+  manifest: IZipArchiveManifest | undefined;
+  /** Loaded configuration */
+  config: ConfigModel.ISystemConfiguration | undefined;
+  /** All files extracted from the archive */
+  files: IImportedFile[];
+  /** Directory structure if available */
+  directory: IImportedDirectory | undefined;
+}
+
+/**
+ * Imported file representation
+ * @public
+ */
+export type IImportedFile = Json.IImportedFile;
+
+/**
+ * Imported directory structure
+ * @public
+ */
+export type IImportedDirectory = Json.IImportedDirectory;
+
+/**
+ * Progress callback for ZIP operations
+ * @public
+ */
+export type ZipArchiveProgressCallback = (
+  stage:
+    | 'reading-file'
+    | 'parsing-zip'
+    | 'loading-manifest'
+    | 'loading-config'
+    | 'extracting-files'
+    | 'processing-resources'
+    | 'creating-zip',
+  progress: number, // 0-100
+  details: string
+) => void;
+
+/**
+ * Constants for ZIP archive structure
+ * @public
+ */
+export const ZipArchiveConstants = {
+  /** Manifest file name */
+  MANIFEST_FILE: 'manifest.json',
+  /** Configuration file name */
+  CONFIG_FILE: 'config.json',
+  /** Input files directory */
+  INPUT_DIR: 'input',
+  /** Configuration files directory */
+  CONFIG_DIR: 'config'
+} as const;

package/src/packlets/zip-archive/zipArchiveCreator.ts

@@ -0,0 +1,229 @@
+/*
+ * Copyright (c) 2025 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+import { zipSync } from 'fflate';
+import { Result, succeed, fail, FileTree } from '@fgv/ts-utils';
+import type { IZipArchiveResult, ZipArchiveOptions, ZipArchiveProgressCallback } from './types';
+import { normalizePath } from './zipArchiveFormat';
+import * as Json from './json';
+
+/**
+ * ZIP archive creator using fflate for universal compatibility
+ * @public
+ */
+export class ZipArchiveCreator {
+  /**
+   * Create a ZIP archive buffer from a supplied buffer
+   * @param options - Input paths and configuration
+   * @param onProgress - Optional progress callback
+   * @returns Result containing ZIP buffer and manifest
+   */
+  public async createFromBuffer(
+    options: ZipArchiveOptions,
+    onProgress?: ZipArchiveProgressCallback
+  ): Promise<Result<IZipArchiveResult>> {
+    try {
+      onProgress?.('creating-zip', 0, 'Starting ZIP archive creation');
+
+      const files: Record<string, Uint8Array> = {};
+      const manifest: Json.IZipArchiveManifest = {
+        timestamp: new Date().toISOString()
+      };
+
+      const { value: inputItem, message: inputItemError } = this._getInputFileTreeItem(options);
+      if (inputItemError !== undefined) {
+        return fail(inputItemError);
+      }
+
+      if (inputItem !== undefined) {
+        onProgress?.('reading-file', 10, `Processing input: ${inputItem.absolutePath}`);
+
+        if (inputItem.type === 'directory') {
+          // Add entire directory recursively, preserving structure
+          const archivePath = `input/${inputItem.name}`;
+
+          const addDirResult = await this._addDirectoryTreeToZip(files, inputItem, archivePath, onProgress);
+          /* c8 ignore next 3 - defense in depth against internal error */
+          if (addDirResult.isFailure()) {
+            return fail(addDirResult.message);
+          }
+
+          manifest.input = {
+            type: 'directory',
+            originalPath: inputItem.absolutePath,
+            archivePath
+          };
+        } else if (inputItem.type === 'file') {
+          // Add single file
+          const archivePath = `input/${inputItem.name}`;
+
+          const addFileResult = await this._addFileTreeItemToZip(files, inputItem, archivePath);
+          /* c8 ignore next 3 - defense in depth against internal error */
+          if (addFileResult.isFailure()) {
+            return fail(addFileResult.message);
+          }
+
+          manifest.input = {
+            type: 'file',
+            originalPath: inputItem.absolutePath,
+            archivePath
+          };
+        }
+      }
+
+      const { value: configItem, message: configItemError } = this._getConfigFileTreeItem(options);
+      if (configItemError !== undefined) {
+        return fail(configItemError);
+      }
+
+      if (configItem !== undefined) {
+        onProgress?.('reading-file', 40, `Processing config: ${configItem.absolutePath}`);
+
+        const archivePath = `config/${configItem.name}`;
+
+        const addConfigResult = await this._addFileTreeItemToZip(files, configItem, archivePath);
+        /* c8 ignore next 3 - defense in depth against internal error */
+        if (addConfigResult.isFailure()) {
+          return fail(addConfigResult.message);
+        }
+
+        // Update manifest with config info
+        manifest.config = {
+          type: 'file',
+          originalPath: configItem.absolutePath,
+          archivePath
+        };
+      }
+
+      // Add manifest to ZIP
+      onProgress?.('creating-zip', 70, 'Adding manifest');
+      const manifestJson = JSON.stringify(manifest, null, 2);
+      files['manifest.json'] = new TextEncoder().encode(manifestJson);
+
+      // Create ZIP buffer using fflate
+      onProgress?.('creating-zip', 80, 'Compressing files');
+      const zipBuffer = zipSync(files, { level: 6 });
+
+      const result: IZipArchiveResult = {
+        zipBuffer,
+        manifest,
+        size: zipBuffer.length
+      };
+
+      onProgress?.('creating-zip', 100, 'ZIP archive buffer created');
+
+      return succeed(result);
+      /* c8 ignore next 3 - defense in depth against internal error */
+    } catch (error) {
+      return fail(`Failed to create ZIP archive: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+
+  /**
+   * Add a single FileTree item to the ZIP archive
+   * @param files - ZIP files collection
+   * @param fileItem - FileTree file item to add
+   * @param archivePath - Path within the archive
+   * @returns Result indicating success or failure
+   */
+  private async _addFileTreeItemToZip(
+    files: Record<string, Uint8Array>,
+    fileItem: FileTree.IFileTreeFileItem,
+    archivePath: string
+  ): Promise<Result<void>> {
+    return fileItem.getRawContents().onSuccess((content) => {
+      const contentBuffer = new TextEncoder().encode(content);
+      files[normalizePath(archivePath)] = contentBuffer;
+      return succeed(undefined);
+    });
+  }
+
+  /**
+   * Add a directory recursively to the ZIP archive using FileTree
+   * @param files - ZIP files collection
+   * @param directoryItem - FileTree directory item to add
+   * @param archivePrefix - Prefix path within the archive
+   * @param onProgress - Optional progress callback
+   * @returns Result indicating success or failure
+   */
+  private async _addDirectoryTreeToZip(
+    files: Record<string, Uint8Array>,
+    directoryItem: FileTree.IFileTreeDirectoryItem,
+    archivePrefix: string,
+    onProgress?: ZipArchiveProgressCallback
+  ): Promise<Result<void>> {
+    const childrenResult = directoryItem.getChildren();
+    /* c8 ignore next 3 - defense in depth against internal error */
+    if (childrenResult.isFailure()) {
+      return fail(`Failed to read directory ${directoryItem.absolutePath}: ${childrenResult.message}`);
+    }
+
+    for (const child of childrenResult.value) {
+      const itemArchivePath = normalizePath(`${archivePrefix}/${child.name}`);
+
+      if (child.type === 'directory') {
+        // Recursively add subdirectory
+        const addDirResult = await this._addDirectoryTreeToZip(files, child, itemArchivePath, onProgress);
+        /* c8 ignore next 3 - defense in depth against internal error */
+        if (addDirResult.isFailure()) {
+          return fail(addDirResult.message);
+        }
+      } else if (child.type === 'file') {
+        // Add file
+        const addFileResult = await this._addFileTreeItemToZip(files, child, itemArchivePath);
+        /* c8 ignore next 3 - defense in depth against internal error */
+        if (addFileResult.isFailure()) {
+          return fail(addFileResult.message);
+        }
+        onProgress?.('reading-file', 0, `Added file: ${itemArchivePath}`);
+      }
+    }
+
+    return succeed(undefined);
+  }
+
+  private _getInputFileTreeItem(options: ZipArchiveOptions): Result<FileTree.FileTreeItem | undefined> {
+    if ('inputPath' in options && options.inputPath !== undefined) {
+      return FileTree.forFilesystem()
+        .withErrorFormat((msg) => `Failed to create file tree: ${msg}`)
+        .onSuccess((fileTree) =>
+          fileTree.getItem(options.inputPath!).withErrorFormat((msg) => `Failed to get item: ${msg}`)
+        );
+    } else if ('inputItem' in options) {
+      return succeed(options.inputItem);
+    }
+    return succeed(undefined);
+  }
+
+  private _getConfigFileTreeItem(options: ZipArchiveOptions): Result<FileTree.IFileTreeFileItem | undefined> {
+    if ('configPath' in options && options.configPath !== undefined) {
+      return FileTree.forFilesystem()
+        .withErrorFormat((msg) => `Failed to create file tree: ${msg}`)
+        .onSuccess((fileTree) =>
+          fileTree.getFile(options.configPath!).withErrorFormat((msg) => `Failed to get config file: ${msg}`)
+        );
+    } else if ('configItem' in options && options.configItem !== undefined) {
+      return succeed(options.configItem);
+    }
+    return succeed(undefined);
+  }
+}