@heartlandone/vega 2.75.0-RTE-table-preview → 2.75.1

package/dist/collection/components/vega-rich-text-editor/test/extensions/table/annotation-handler/table-head-cell-annotation-handler.test.js

@@ -1,411 +0,0 @@
-import { TableHeadCellAnnotationHandler } from '../../../../extensions/table/annotation-handler/table-head-cell-annotation-handler';
-import { RTETableHeadCellBlock } from '../../../../extensions/table/dto/table-head-cell-block';
-import { setBorder } from './table-cell-annotation-handler.test';
-describe('TableHeadCellAnnotationHandler', () => {
-  let handler;
-  beforeEach(() => {
-    handler = new TableHeadCellAnnotationHandler();
-  });
-  describe('canHandle', () => {
-    it('should return true for RTETableHeadCellBlock', () => {
-      expect(handler.canHandle(RTETableHeadCellBlock)).toBe(true);
-    });
-    it('should return false for other DTOs', () => {
-      const mockDto = { name: 'RTETextBlock' };
-      expect(handler.canHandle(mockDto)).toBe(false);
-    });
-  });
-  describe('handle', () => {
-    it('should return empty object when no cell annotations are present', () => {
-      const element = document.createElement('th');
-      const result = handler.handle(element);
-      expect(result).toEqual({});
-    });
-    it('should extract background color from inline style', () => {
-      const element = document.createElement('th');
-      element.style.backgroundColor = 'rgb(252, 252, 252)';
-      const result = handler.handle(element);
-      expect(result).toEqual({
-        tableCell: {
-          backgroundColor: 'white',
-        },
-      });
-    });
-    it('should extract padding from inline style', () => {
-      const element = document.createElement('th');
-      element.style.padding = '12px 16px';
-      const result = handler.handle(element);
-      expect(result).toEqual({
-        tableCell: {
-          padding: '12px 16px',
-        },
-      });
-    });
-    it('should extract border from individual properties', () => {
-      const element = document.createElement('th');
-      element.style.borderStyle = 'double';
-      element.style.borderWidth = '4px';
-      element.style.borderColor = 'rgb(4, 4, 28)';
-      const result = handler.handle(element);
-      expect(result).toEqual({
-        tableCell: {
-          border: {
-            style: 'double',
-            width: '4px',
-            color: 'black',
-          },
-        },
-      });
-    });
-    it('should extract width from inline style', () => {
-      const element = document.createElement('th');
-      element.style.width = '180px';
-      const result = handler.handle(element);
-      expect(result).toEqual({
-        tableCell: {
-          width: '180px',
-        },
-      });
-    });
-    it('should extract width from attribute and convert numeric to pixels', () => {
-      const element = document.createElement('th');
-      element.setAttribute('width', '120');
-      const result = handler.handle(element);
-      expect(result).toEqual({
-        tableCell: {
-          width: '120px',
-        },
-      });
-      expect(element.getAttribute('width')).toBe('120');
-    });
-    it('should extract width from attribute with percentage', () => {
-      const element = document.createElement('th');
-      element.setAttribute('width', '25%');
-      const result = handler.handle(element);
-      expect(result).toEqual({
-        tableCell: {
-          width: '25%',
-        },
-      });
-    });
-    it('should extract height from inline style', () => {
-      const element = document.createElement('th');
-      element.style.height = '50px';
-      const result = handler.handle(element);
-      expect(result).toEqual({
-        tableCell: {
-          height: '50px',
-        },
-      });
-    });
-    it('should extract height from attribute and convert numeric to pixels', () => {
-      const element = document.createElement('th');
-      element.setAttribute('height', '60');
-      const result = handler.handle(element);
-      expect(result).toEqual({
-        tableCell: {
-          height: '60px',
-        },
-      });
-      expect(element.getAttribute('height')).toBe('60');
-    });
-    it('should extract height from attribute with units as-is', () => {
-      const element = document.createElement('th');
-      element.setAttribute('height', '75px');
-      const result = handler.handle(element);
-      expect(result).toEqual({
-        tableCell: {
-          height: '75px',
-        },
-      });
-    });
-    it('should extract text alignment from inline style', () => {
-      const element = document.createElement('th');
-      element.style.textAlign = 'center';
-      const result = handler.handle(element);
-      expect(result).toEqual({
-        tableCell: {
-          textAlign: 'center',
-        },
-      });
-    });
-    it('should extract text alignment from align attribute', () => {
-      const element = document.createElement('th');
-      element.setAttribute('align', 'left');
-      const result = handler.handle(element);
-      expect(result).toEqual({
-        tableCell: {
-          textAlign: 'left',
-        },
-      });
-      expect(element.getAttribute('align')).toBe('left');
-    });
-    it('should extract vertical alignment from inline style', () => {
-      const element = document.createElement('th');
-      element.style.verticalAlign = 'bottom';
-      const result = handler.handle(element);
-      expect(result).toEqual({
-        tableCell: {
-          verticalAlign: 'bottom',
-        },
-      });
-    });
-    it('should extract multiple annotations', () => {
-      const element = document.createElement('th');
-      element.style.backgroundColor = 'rgb(252, 252, 252)';
-      element.style.padding = '10px';
-      setBorder(element, 'solid 2px rgb(4, 4, 28)');
-      element.style.width = '200px';
-      element.style.height = '40px';
-      element.style.textAlign = 'center';
-      element.style.verticalAlign = 'middle';
-      const result = handler.handle(element);
-      expect(result).toEqual({
-        tableCell: {
-          backgroundColor: 'white',
-          padding: '10px',
-          border: {
-            style: 'solid',
-            width: '2px',
-            color: 'black',
-          },
-          width: '200px',
-          height: '40px',
-          textAlign: 'center',
-          verticalAlign: 'middle',
-        },
-      });
-    });
-    it('should handle border with rgba color', () => {
-      const element = document.createElement('th');
-      setBorder(element, 'solid 1px rgb(4, 4, 28)');
-      const result = handler.handle(element);
-      expect(result).toEqual({
-        tableCell: {
-          border: {
-            style: 'solid',
-            width: '1px',
-            color: 'black',
-          },
-        },
-      });
-    });
-    it('should prioritize inline style over attributes', () => {
-      const element = document.createElement('th');
-      element.style.width = '400px';
-      element.setAttribute('width', '300');
-      element.style.textAlign = 'right';
-      element.setAttribute('align', 'left');
-      const result = handler.handle(element);
-      expect(result).toEqual({
-        tableCell: {
-          width: '400px',
-          textAlign: 'right',
-        },
-      });
-    });
-    it('should handle all text alignment values', () => {
-      const alignments = [
-        'left',
-        'center',
-        'right',
-        'justify',
-      ];
-      alignments.forEach((align) => {
-        const element = document.createElement('th');
-        element.style.textAlign = align;
-        const result = handler.handle(element);
-        expect(result).toEqual({
-          tableCell: {
-            textAlign: align,
-          },
-        });
-      });
-    });
-    it('should handle all vertical alignment values', () => {
-      const alignments = ['top', 'middle', 'bottom'];
-      alignments.forEach((align) => {
-        const element = document.createElement('th');
-        element.style.verticalAlign = align;
-        const result = handler.handle(element);
-        expect(result).toEqual({
-          tableCell: {
-            verticalAlign: align,
-          },
-        });
-      });
-    });
-    it('should ignore invalid text alignment values', () => {
-      const element = document.createElement('th');
-      element.style.textAlign = 'invalid';
-      const result = handler.handle(element);
-      expect(result).toEqual({});
-    });
-    it('should ignore invalid vertical alignment values', () => {
-      const element = document.createElement('th');
-      element.style.verticalAlign = 'baseline';
-      const result = handler.handle(element);
-      expect(result).toEqual({});
-    });
-    it('should handle mixed attributes and styles', () => {
-      const element = document.createElement('th');
-      element.style.backgroundColor = 'white';
-      element.setAttribute('width', '100');
-      element.style.textAlign = 'center';
-      const result = handler.handle(element);
-      expect(result).toEqual({
-        tableCell: {
-          backgroundColor: 'white',
-          width: '100px',
-          textAlign: 'center',
-        },
-      });
-    });
-  });
-  describe('inheritance from TableCellAnnotationHandler', () => {
-    it('should inherit all extraction methods from TableCellAnnotationHandler', () => {
-      const element = document.createElement('th');
-      element.style.padding = '10px';
-      setBorder(element, 'solid 1px #ddd');
-      element.style.width = '150px';
-      element.style.height = '50px';
-      element.style.textAlign = 'left';
-      element.style.verticalAlign = 'top';
-      element.style.backgroundColor = 'rgb(252, 252, 252)';
-      const result = handler.handle(element);
-      // Should extract all cell properties using inherited methods
-      expect(result).toEqual({
-        tableCell: {
-          padding: '10px',
-          border: {
-            style: 'solid',
-            width: '1px',
-            color: '',
-          },
-          width: '150px',
-          height: '50px',
-          textAlign: 'left',
-          verticalAlign: 'top',
-          backgroundColor: 'white',
-        },
-      });
-    });
-    it('should only differ from TableCellAnnotationHandler in canHandle check', () => {
-      const thElement = document.createElement('th');
-      const tdElement = document.createElement('td');
-      thElement.style.padding = '10px';
-      tdElement.style.padding = '10px';
-      // Both should extract the same way
-      const thResult = handler.handle(thElement);
-      const tdResult = handler.handle(tdElement);
-      expect(thResult).toEqual(tdResult);
-      expect(thResult).toEqual({
-        tableCell: {
-          padding: '10px',
-        },
-      });
-    });
-    it('should use inherited protected methods for extraction', () => {
-      var _a;
-      // Test that protected methods are accessible and working
-      const element = document.createElement('th');
-      // Test border extraction (inherited protected method)
-      setBorder(element, 'dashed 2px rgb(4, 4, 28)');
-      const borderResult = handler.handle(element);
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      expect((_a = borderResult.tableCell) === null || _a === void 0 ? void 0 : _a.border).toEqual({
-        style: 'dashed',
-        width: '2px',
-        color: 'black',
-      });
-    });
-    it('should handle all text alignment values like parent class', () => {
-      const alignments = [
-        'left',
-        'center',
-        'right',
-        'justify',
-      ];
-      alignments.forEach((align) => {
-        const element = document.createElement('th');
-        element.style.textAlign = align;
-        const result = handler.handle(element);
-        expect(result).toEqual({
-          tableCell: {
-            textAlign: align,
-          },
-        });
-      });
-    });
-    it('should handle all vertical alignment values like parent class', () => {
-      const alignments = ['top', 'middle', 'bottom'];
-      alignments.forEach((align) => {
-        const element = document.createElement('th');
-        element.style.verticalAlign = align;
-        const result = handler.handle(element);
-        expect(result).toEqual({
-          tableCell: {
-            verticalAlign: align,
-          },
-        });
-      });
-    });
-    describe('border edge cases inherited from parent', () => {
-      it('should handle invalid border string gracefully', () => {
-        const element = document.createElement('th');
-        setBorder(element, 'invalid');
-        const result = handler.handle(element);
-        expect(result).toEqual({
-          tableCell: {
-            border: {
-              style: 'invalid',
-              width: '',
-              color: '',
-            },
-          },
-        });
-      });
-      it('should handle border with only 2 parts', () => {
-        const element = document.createElement('th');
-        setBorder(element, 'double 3px');
-        const result = handler.handle(element);
-        expect(result).toEqual({
-          tableCell: {
-            border: {
-              style: 'double',
-              width: '3px',
-              color: '',
-            },
-          },
-        });
-      });
-      it('should handle border with only spaces', () => {
-        const element = document.createElement('th');
-        setBorder(element, '   ');
-        const result = handler.handle(element);
-        expect(result).toEqual({});
-      });
-      it('should handle border with single word', () => {
-        const element = document.createElement('th');
-        setBorder(element, 'ridge');
-        const result = handler.handle(element);
-        expect(result).toEqual({
-          tableCell: {
-            border: {
-              style: 'ridge',
-              width: '',
-              color: '',
-            },
-          },
-        });
-        // Should not fail even if border string is incomplete
-      });
-      it('should handle empty border string', () => {
-        const element = document.createElement('th');
-        setBorder(element, '');
-        const result = handler.handle(element);
-        expect(result).toEqual({});
-      });
-    });
-  });
-});

package/dist/collection/components/vega-rich-text-editor/test/extensions/table/caption-operation.test.js

@@ -1,99 +0,0 @@
-import { CaptionOperationEventHandler } from '../../../extensions/table/setting-event-handlers/caption-operation';
-import { TableSettingType } from '../../../extensions/table/setting-event-handlers/setting-event-handler.abstract';
-import { RTETableBlock } from '../../../extensions/table/dto/table-block';
-import { RTETableCaptionBlock, } from '../../../extensions/table/dto/table-caption-block';
-/**
- * Lightweight helper to create a fresh table block with optional caption attached.
- *
- * @param {RTETableCaptionBlock | null | undefined} caption - Optional caption DTO used to seed the table.
- * @returns {RTETableBlock} Table block instance wired with the provided caption.
- */
-const createTableBlock = (caption) => {
-  const tableBlock = new RTETableBlock('table-id');
-  if (caption) {
-    tableBlock.setCaption(caption);
-  }
-  return tableBlock;
-};
-/**
- * Creates a caption handler stub with cursor-sync side effects mocked out.
- *
- * @returns {CaptionOperationEventHandler} Configured handler ready for unit tests.
- */
-const createHandler = () => {
-  const handler = new CaptionOperationEventHandler();
-  handler.syncCursorPosition = jest.fn();
-  return handler;
-};
-describe('CaptionOperationEventHandler', () => {
-  const extensionContext = {};
-  /**
-   * Guards that the provided block is a text block.
-   *
-   * @param {VegaRTEContentBlock | undefined} block - Candidate caption child.
-   * @returns {block is VegaRTETextBlock} True when the block exposes `nodes`.
-   */
-  const isTextBlock = (block) => Boolean(block && 'nodes' in block);
-  /**
-   * Extracts the first caption text node, if present.
-   *
-   * @param {VegaRTETableCaptionBlock | null | undefined} caption - Caption DTO emitted by `toJSON`.
-   * @returns {string | undefined} Placeholder or undefined when caption lacks text.
-   */
-  const getFirstCaptionText = (caption) => {
-    var _a, _b, _c;
-    const firstChild = (_a = caption === null || caption === void 0 ? void 0 : caption.children) === null || _a === void 0 ? void 0 : _a[0];
-    if (isTextBlock(firstChild)) {
-      return (_c = (_b = firstChild.nodes) === null || _b === void 0 ? void 0 : _b[0]) === null || _c === void 0 ? void 0 : _c.text;
-    }
-    return undefined;
-  };
-  it('creates captions pre-filled with placeholder guidance', () => {
-    var _a;
-    const handler = createHandler();
-    const tableBlock = createTableBlock();
-    handler.execute([TableSettingType.CAPTION, 'rte-table-caption'], extensionContext, tableBlock);
-    const captionJson = (_a = tableBlock.getCaption()) === null || _a === void 0 ? void 0 : _a.toJSON();
-    expect(getFirstCaptionText(captionJson)).toBe('');
-  });
-  it('restores the placeholder when caption content has been cleared', () => {
-    var _a;
-    const handler = createHandler();
-    const emptyCaption = RTETableCaptionBlock.from({
-      id: 'caption-id',
-      type: 'table-caption',
-      children: [],
-    });
-    emptyCaption.children = [];
-    const tableBlock = createTableBlock(emptyCaption);
-    handler.execute([TableSettingType.CAPTION, 'rte-table-caption'], extensionContext, tableBlock);
-    const captionJson = (_a = tableBlock.getCaption()) === null || _a === void 0 ? void 0 : _a.toJSON();
-    expect(getFirstCaptionText(captionJson)).toBe('');
-  });
-  it('preserves existing caption content when it is already populated', () => {
-    var _a;
-    const handler = createHandler();
-    const hydratedCaption = RTETableCaptionBlock.from({
-      id: 'caption-id',
-      type: 'table-caption',
-      children: [
-        {
-          id: 'paragraph-id',
-          type: 'paragraph',
-          nodes: [
-            {
-              id: 'text-id',
-              type: 'text',
-              text: 'Custom caption content',
-            },
-          ],
-        },
-      ],
-    });
-    const tableBlock = createTableBlock(hydratedCaption);
-    handler.execute([TableSettingType.CAPTION, 'rte-table-caption'], extensionContext, tableBlock);
-    expect(tableBlock.getCaption()).toBe(hydratedCaption);
-    const captionJson = (_a = tableBlock.getCaption()) === null || _a === void 0 ? void 0 : _a.toJSON();
-    expect(getFirstCaptionText(captionJson)).toBe('Custom caption content');
-  });
-});

package/dist/collection/components/vega-rich-text-editor/test/extensions/table/table-annotation.test.js

@@ -1,181 +0,0 @@
-import { RTETableExtensionAnnotationTypeEnum, RTETableAnnotation, } from '../../../extensions/table/annotations/table-annotation';
-import { RTETableBlock } from '../../../extensions/table/dto/table-block';
-import { RTETableAnnotationsAction } from '../../../extensions/table/actions/table-annotations-action';
-import { VegaInternalThemeManager } from '../../../../../helpers/theme/internal-theme-manager';
-describe('RTETableAnnotation', () => {
-  test('defaults width to 100% and includes border collapse in style', () => {
-    const annotation = new RTETableAnnotation();
-    const style = annotation.renderStyle();
-    expect(style).toEqual({ borderCollapse: 'collapse', margin: '0 auto' });
-  });
-  test('renderStyle handles alignment correctly', () => {
-    const leftAligned = new RTETableAnnotation({ alignment: 'left' });
-    expect(leftAligned.renderStyle().margin).toBe('0');
-    const rightAligned = new RTETableAnnotation({ alignment: 'right' });
-    expect(rightAligned.renderStyle().margin).toBe('0 0 0 auto');
-    const centerAligned = new RTETableAnnotation({ alignment: 'center' });
-    expect(centerAligned.renderStyle().margin).toBe('0 auto');
-  });
-  test('renderStyle merges provided values', () => {
-    const annotation = new RTETableAnnotation({
-      backgroundColor: 'orange',
-      border: { style: 'solid', width: '2px', color: 'orange' },
-      height: '200px',
-      alignment: 'center',
-    });
-    expect(annotation.renderStyle()).toEqual({
-      borderCollapse: 'collapse',
-      backgroundColor: '#FDAB68',
-      border: 'solid 2px #FDAB68',
-      height: '200px',
-      margin: '0 auto',
-    });
-  });
-  test('borderStr handles missing and provided borders', () => {
-    expect(new RTETableAnnotation({ border: undefined }).borderStr).toBeNull();
-    expect(new RTETableAnnotation({
-      border: { style: 'dotted', width: '3px', color: 'orange' },
-    }).borderStr).toBe('dotted 3px #FDAB68');
-  });
-  test('clone duplicates all values', () => {
-    const original = new RTETableAnnotation({
-      backgroundColor: 'orange',
-      border: { style: 'dashed', width: '1px', color: 'orange' },
-      height: '50px',
-      alignment: 'right',
-    });
-    const clone = original.clone();
-    expect(clone).not.toBe(original);
-    expect(clone).toEqual(original);
-  });
-  test('from returns tuple with type constant', () => {
-    const [type, annotation] = RTETableAnnotation.from({
-      backgroundColor: 'orange',
-    });
-    expect(type).toBe(RTETableExtensionAnnotationTypeEnum.TABLE);
-    expect(annotation).toBeInstanceOf(RTETableAnnotation);
-    expect(annotation.backgroundColor).toBe('orange');
-  });
-  test('toJSON filters undefined values', () => {
-    const annotation = new RTETableAnnotation({
-      backgroundColor: 'orange',
-      height: '20px',
-      border: undefined,
-    });
-    expect(annotation.toJSON()).toEqual({
-      table: {
-        backgroundColor: 'orange',
-        height: '20px',
-        alignment: 'center',
-        borderCollapse: 'collapse',
-      },
-    });
-  });
-  test('renderClass returns the extension helper class', () => {
-    expect(new RTETableAnnotation().renderClass()).toBe('v-rte--extension-table');
-  });
-  test('should apply annotation correctly', () => {
-    const tableBlock = new RTETableBlock('table-id');
-    tableBlock.apply(new RTETableAnnotationsAction({
-      backgroundColor: 'orange',
-    }));
-    expect(tableBlock.toJSON()).toEqual({
-      id: 'table-id',
-      type: 'table-block',
-      annotations: {
-        table: { backgroundColor: 'orange', alignment: 'center', borderCollapse: 'collapse' },
-      },
-      children: [],
-    });
-  });
-  test('should initial table color annotation correct', () => {
-    VegaInternalThemeManager.toggleDarkMode(false);
-    const annotation = new RTETableAnnotation({
-      backgroundColor: 'orange',
-      border: { color: 'orange', style: 'none', width: '1px' },
-    });
-    expect(annotation.toJSON()).toEqual({
-      table: {
-        backgroundColor: 'orange',
-        alignment: 'center',
-        borderCollapse: 'collapse',
-        border: { color: 'orange', style: 'none', width: '1px' },
-      },
-    });
-    expect(annotation.renderStyle().backgroundColor).toEqual('#FDAB68');
-    expect(annotation.borderStr).toEqual('none 1px #FDAB68');
-    VegaInternalThemeManager.toggleDarkMode(true);
-    expect(annotation.renderStyle().backgroundColor).toEqual('#974502');
-    expect(annotation.borderStr).toEqual('none 1px #974502');
-    VegaInternalThemeManager.toggleDarkMode(false);
-  });
-  describe('useInternalStyle parameter', () => {
-    test('applies default values when useInternalStyle is true and values are undefined', () => {
-      const annotation = new RTETableAnnotation({}, true);
-      expect(annotation.alignment).toBe(RTETableAnnotation.DEFAULT_ALIGNMENT);
-      expect(annotation.borderCollapse).toBe(RTETableAnnotation.DEFAULT_BORDER_COLLAPSE);
-      expect(annotation.useInternalStyle).toBe(true);
-    });
-    test('does not apply default values when useInternalStyle is false', () => {
-      const annotation = new RTETableAnnotation({}, false);
-      expect(annotation.alignment).toBeUndefined();
-      expect(annotation.borderCollapse).toBeUndefined();
-      expect(annotation.useInternalStyle).toBe(false);
-    });
-    test('preserves explicit null values when useInternalStyle is true', () => {
-      const annotation = new RTETableAnnotation({
-        alignment: null,
-        borderCollapse: null,
-      }, true);
-      expect(annotation.alignment).toBeNull();
-      expect(annotation.borderCollapse).toBeNull();
-    });
-    test('preserves explicit null values when useInternalStyle is false', () => {
-      const annotation = new RTETableAnnotation({
-        alignment: null,
-        borderCollapse: null,
-      }, false);
-      expect(annotation.alignment).toBeNull();
-      expect(annotation.borderCollapse).toBeNull();
-    });
-    test('uses provided custom values regardless of useInternalStyle', () => {
-      const customValues = {
-        alignment: 'left',
-        borderCollapse: 'separate',
-      };
-      const annotationWithInternal = new RTETableAnnotation(customValues, true);
-      const annotationWithoutInternal = new RTETableAnnotation(customValues, false);
-      expect(annotationWithInternal.alignment).toBe('left');
-      expect(annotationWithInternal.borderCollapse).toBe('separate');
-      expect(annotationWithoutInternal.alignment).toBe('left');
-      expect(annotationWithoutInternal.borderCollapse).toBe('separate');
-    });
-    test('defaults to useInternalStyle true when not specified', () => {
-      const annotation = new RTETableAnnotation({});
-      expect(annotation.alignment).toBe(RTETableAnnotation.DEFAULT_ALIGNMENT);
-      expect(annotation.borderCollapse).toBe(RTETableAnnotation.DEFAULT_BORDER_COLLAPSE);
-      expect(annotation.useInternalStyle).toBe(true);
-    });
-    test('applies defaults only for undefined values when useInternalStyle is true', () => {
-      const annotation = new RTETableAnnotation({
-        alignment: 'right',
-        borderCollapse: undefined,
-      }, true);
-      expect(annotation.alignment).toBe('right');
-      expect(annotation.borderCollapse).toBe(RTETableAnnotation.DEFAULT_BORDER_COLLAPSE);
-    });
-    test('clone preserves useInternalStyle flag', () => {
-      const original = new RTETableAnnotation({
-        alignment: 'left',
-      }, false);
-      const cloned = original.clone();
-      expect(cloned.useInternalStyle).toBe(false);
-      expect(cloned.alignment).toBe('left');
-    });
-    test('from method passes useInternalStyle to constructor', () => {
-      const [, annotation] = RTETableAnnotation.from({ alignment: undefined }, false);
-      expect(annotation.useInternalStyle).toBe(false);
-      expect(annotation.alignment).toBeUndefined();
-    });
-  });
-});