@redocly/cli 1.0.0 → 1.0.1

package/src/__tests__/utils.test.ts

@@ -0,0 +1,564 @@
+import {
+  getFallbackApisOrExit,
+  isSubdir,
+  pathToFilename,
+  printConfigLintTotals,
+  langToExt,
+  checkIfRulesetExist,
+  handleError,
+  CircularJSONNotSupportedError,
+  sortTopLevelKeysForOas,
+  cleanColors,
+  HandledError,
+  cleanArgs,
+  cleanRawInput,
+} from '../utils';
+import {
+  ResolvedApi,
+  Totals,
+  isAbsoluteUrl,
+  ResolveError,
+  YamlParseError,
+} from '@redocly/openapi-core';
+import { blue, red, yellow } from 'colorette';
+import { existsSync, statSync } from 'fs';
+import * as path from 'path';
+import * as process from 'process';
+
+jest.mock('os');
+jest.mock('colorette');
+
+jest.mock('fs');
+
+describe('isSubdir', () => {
+  it('can correctly determine if subdir', () => {
+    (
+      [
+        ['/foo', '/foo', false],
+        ['/foo', '/bar', false],
+        ['/foo', '/foobar', false],
+        ['/foo', '/foo/bar', true],
+        ['/foo', '/foo/../bar', false],
+        ['/foo', '/foo/./bar', true],
+        ['/bar/../foo', '/foo/bar', true],
+        ['/foo', './bar', false],
+        ['/foo', '/foo/..bar', true],
+      ] as [string, string, boolean][]
+    ).forEach(([parent, child, expectRes]) => {
+      expect(isSubdir(parent, child)).toBe(expectRes);
+    });
+  });
+
+  it('can correctly determine if subdir for windows-based paths', () => {
+    const os = require('os');
+    os.platform.mockImplementation(() => 'win32');
+
+    (
+      [
+        ['C:/Foo', 'C:/Foo/Bar', true],
+        ['C:\\Foo', 'C:\\Bar', false],
+        ['C:\\Foo', 'D:\\Foo\\Bar', false],
+      ] as [string, string, boolean][]
+    ).forEach(([parent, child, expectRes]) => {
+      expect(isSubdir(parent, child)).toBe(expectRes);
+    });
+  });
+
+  afterEach(() => {
+    jest.resetModules();
+  });
+});
+
+describe('pathToFilename', () => {
+  it('should use correct path separator', () => {
+    const processedPath = pathToFilename('/user/createWithList', '_');
+    expect(processedPath).toEqual('user_createWithList');
+  });
+});
+
+describe('getFallbackApisOrExit', () => {
+  it('should find alias by filename', async () => {
+    (existsSync as jest.Mock<any, any>).mockImplementationOnce(() => true);
+    const entry = await getFallbackApisOrExit(['./test.yaml'], {
+      apis: {
+        main: {
+          root: 'test.yaml',
+        },
+      },
+    } as any);
+    expect(entry).toEqual([{ path: './test.yaml', alias: 'main' }]);
+  });
+});
+
+describe('printConfigLintTotals', () => {
+  const totalProblemsMock: Totals = {
+    errors: 1,
+    warnings: 0,
+    ignored: 0,
+  };
+
+  const redColoretteMocks = red as jest.Mock<any, any>;
+  const yellowColoretteMocks = yellow as jest.Mock<any, any>;
+
+  beforeEach(() => {
+    yellowColoretteMocks.mockImplementation((text: string) => text);
+    redColoretteMocks.mockImplementation((text: string) => text);
+    jest.spyOn(process.stderr, 'write').mockImplementation(() => true);
+  });
+
+  it('should print errors if such exist', () => {
+    printConfigLintTotals(totalProblemsMock);
+    expect(process.stderr.write).toHaveBeenCalledWith('❌ Your config has 1 error.\n');
+    expect(redColoretteMocks).toHaveBeenCalledWith('❌ Your config has 1 error.\n');
+  });
+
+  it('should print warnign and error', () => {
+    printConfigLintTotals({ ...totalProblemsMock, warnings: 2 });
+    expect(process.stderr.write).toHaveBeenCalledWith(
+      '❌ Your config has 1 error and 2 warnings.\n'
+    );
+    expect(redColoretteMocks).toHaveBeenCalledWith('❌ Your config has 1 error and 2 warnings.\n');
+  });
+
+  it('should print warnign if no error', () => {
+    printConfigLintTotals({ ...totalProblemsMock, errors: 0, warnings: 2 });
+    expect(process.stderr.write).toHaveBeenCalledWith('You have 2 warnings.\n');
+    expect(yellowColoretteMocks).toHaveBeenCalledWith('You have 2 warnings.\n');
+  });
+
+  it('should print nothing if no error and no warnings', () => {
+    const result = printConfigLintTotals({ ...totalProblemsMock, errors: 0 });
+    expect(result).toBeUndefined();
+    expect(process.stderr.write).toHaveBeenCalledTimes(0);
+    expect(yellowColoretteMocks).toHaveBeenCalledTimes(0);
+    expect(redColoretteMocks).toHaveBeenCalledTimes(0);
+  });
+});
+
+describe('getFallbackApisOrExit', () => {
+  const redColoretteMocks = red as jest.Mock<any, any>;
+  const yellowColoretteMocks = yellow as jest.Mock<any, any>;
+
+  const apis: Record<string, ResolvedApi> = {
+    main: {
+      root: 'someFile.yaml',
+      styleguide: {},
+    },
+  };
+
+  const config = { apis };
+
+  beforeEach(() => {
+    yellowColoretteMocks.mockImplementation((text: string) => text);
+    redColoretteMocks.mockImplementation((text: string) => text);
+    jest.spyOn(process.stderr, 'write').mockImplementation(() => true);
+    jest.spyOn(process, 'exit').mockImplementation();
+  });
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should exit with error because no path provided', async () => {
+    const apisConfig = {
+      apis: {},
+    };
+    expect.assertions(1);
+    try {
+      await getFallbackApisOrExit([''], apisConfig);
+    } catch (e) {
+      expect(e.message).toEqual('Path cannot be empty.');
+    }
+  });
+
+  it('should error if file from config do not exist', async () => {
+    (existsSync as jest.Mock<any, any>).mockImplementationOnce(() => false);
+    expect.assertions(3);
+    try {
+      await getFallbackApisOrExit(undefined, config);
+    } catch (e) {
+      expect(process.stderr.write).toHaveBeenCalledWith(
+        '\nsomeFile.yaml does not exist or is invalid.\n\n'
+      );
+      expect(process.stderr.write).toHaveBeenCalledWith('Please provide a valid path.\n\n');
+      expect(e.message).toEqual('Please provide a valid path.');
+    }
+  });
+
+  it('should return valid array with results if such file exist', async () => {
+    (existsSync as jest.Mock<any, any>).mockImplementationOnce(() => true);
+    jest.spyOn(path, 'resolve').mockImplementationOnce((_, path) => path);
+
+    const result = await getFallbackApisOrExit(undefined, config);
+    expect(process.stderr.write).toHaveBeenCalledTimes(0);
+    expect(process.exit).toHaveBeenCalledTimes(0);
+    expect(result).toStrictEqual([
+      {
+        alias: 'main',
+        path: 'someFile.yaml',
+      },
+    ]);
+  });
+
+  it('should exit with error in case if invalid path provided as args', async () => {
+    const apisConfig = {
+      apis: {},
+    };
+    (existsSync as jest.Mock<any, any>).mockImplementationOnce(() => false);
+    expect.assertions(3);
+
+    try {
+      await getFallbackApisOrExit(['someFile.yaml'], apisConfig);
+    } catch (e) {
+      expect(process.stderr.write).toHaveBeenCalledWith(
+        '\nsomeFile.yaml does not exist or is invalid.\n\n'
+      );
+      expect(process.stderr.write).toHaveBeenCalledWith('Please provide a valid path.\n\n');
+      expect(e.message).toEqual('Please provide a valid path.');
+    }
+  });
+
+  it('should exit with error in case if invalid 2 path provided as args', async () => {
+    const apisConfig = {
+      apis: {},
+    };
+    (existsSync as jest.Mock<any, any>).mockImplementationOnce(() => false);
+    expect.assertions(3);
+    try {
+      await getFallbackApisOrExit(['someFile.yaml', 'someFile2.yaml'], apisConfig);
+    } catch (e) {
+      expect(process.stderr.write).toHaveBeenCalledWith(
+        '\nsomeFile.yaml does not exist or is invalid.\n\n'
+      );
+      expect(process.stderr.write).toHaveBeenCalledWith('Please provide a valid path.\n\n');
+      expect(e.message).toEqual('Please provide a valid path.');
+    }
+  });
+
+  it('should exit with error if only one file exist ', async () => {
+    const apisStub = {
+      ...apis,
+      notExist: {
+        root: 'notExist.yaml',
+        styleguide: {},
+      },
+    };
+    const configStub = { apis: apisStub };
+
+    const existSyncMock = (existsSync as jest.Mock<any, any>).mockImplementation((path) =>
+      path.endsWith('someFile.yaml')
+    );
+
+    expect.assertions(4);
+
+    try {
+      await getFallbackApisOrExit(undefined, configStub);
+    } catch (e) {
+      expect(process.stderr.write).toHaveBeenCalledWith(
+        '\nnotExist.yaml does not exist or is invalid.\n\n'
+      );
+      expect(process.stderr.write).toHaveBeenCalledWith('Please provide a valid path.\n\n');
+      expect(process.stderr.write).toHaveBeenCalledTimes(2);
+      expect(e.message).toEqual('Please provide a valid path.');
+    }
+    existSyncMock.mockClear();
+  });
+
+  it('should work ok if it is url passed', async () => {
+    (existsSync as jest.Mock<any, any>).mockImplementationOnce(() => false);
+    (isAbsoluteUrl as jest.Mock<any, any>).mockImplementation(() => true);
+    const apisConfig = {
+      apis: {
+        main: {
+          root: 'https://someLinkt/petstore.yaml?main',
+          styleguide: {},
+        },
+      },
+    };
+
+    const result = await getFallbackApisOrExit(undefined, apisConfig);
+
+    expect(process.stderr.write).toHaveBeenCalledTimes(0);
+    expect(result).toStrictEqual([
+      {
+        alias: 'main',
+        path: 'https://someLinkt/petstore.yaml?main',
+      },
+    ]);
+  });
+});
+
+describe('langToExt', () => {
+  it.each([
+    ['php', '.php'],
+    ['c#', '.cs'],
+    ['shell', '.sh'],
+    ['curl', '.sh'],
+    ['bash', '.sh'],
+    ['javascript', '.js'],
+    ['js', '.js'],
+    ['python', '.py'],
+  ])('should infer file extension from lang - %s', (lang, expected) => {
+    expect(langToExt(lang)).toBe(expected);
+  });
+
+  it('should ignore case when inferring file extension', () => {
+    expect(langToExt('JavaScript')).toBe('.js');
+  });
+});
+
+describe('sorTopLevelKeysForOas', () => {
+  it('should sort oas3 top level keys', () => {
+    const openApi = {
+      openapi: '3.0.0',
+      components: {},
+      security: [],
+      tags: [],
+      servers: [],
+      paths: {},
+      info: {},
+      externalDocs: {},
+      webhooks: [],
+      'x-webhooks': [],
+      jsonSchemaDialect: '',
+    } as any;
+    const orderedKeys = [
+      'openapi',
+      'info',
+      'jsonSchemaDialect',
+      'servers',
+      'security',
+      'tags',
+      'externalDocs',
+      'paths',
+      'webhooks',
+      'x-webhooks',
+      'components',
+    ];
+    const result = sortTopLevelKeysForOas(openApi);
+
+    Object.keys(result).forEach((key, index) => {
+      expect(key).toEqual(orderedKeys[index]);
+    });
+  });
+
+  it('should sort oas2 top level keys', () => {
+    const openApi = {
+      swagger: '2.0.0',
+      security: [],
+      tags: [],
+      paths: {},
+      info: {},
+      externalDocs: {},
+      host: '',
+      basePath: '',
+      securityDefinitions: [],
+      schemes: [],
+      consumes: [],
+      parameters: [],
+      produces: [],
+      definitions: [],
+      responses: [],
+    } as any;
+    const orderedKeys = [
+      'swagger',
+      'info',
+      'host',
+      'basePath',
+      'schemes',
+      'consumes',
+      'produces',
+      'security',
+      'tags',
+      'externalDocs',
+      'paths',
+      'definitions',
+      'parameters',
+      'responses',
+      'securityDefinitions',
+    ];
+    const result = sortTopLevelKeysForOas(openApi);
+
+    Object.keys(result).forEach((key, index) => {
+      expect(key).toEqual(orderedKeys[index]);
+    });
+  });
+});
+
+describe('handleErrors', () => {
+  const ref = 'openapi/test.yaml';
+
+  const redColoretteMocks = red as jest.Mock<any, any>;
+  const blueColoretteMocks = blue as jest.Mock<any, any>;
+
+  beforeEach(() => {
+    jest.spyOn(process.stderr, 'write').mockImplementation(() => true);
+    jest.spyOn(process, 'exit').mockImplementation((code) => code as never);
+    redColoretteMocks.mockImplementation((text) => text);
+    blueColoretteMocks.mockImplementation((text) => text);
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should handle ResolveError', () => {
+    const resolveError = new ResolveError(new Error('File not found'));
+    expect(() => handleError(resolveError, ref)).toThrowError(HandledError);
+    expect(redColoretteMocks).toHaveBeenCalledTimes(1);
+    expect(process.stderr.write).toHaveBeenCalledWith(
+      `Failed to resolve api definition at openapi/test.yaml:\n\n  - File not found.\n\n`
+    );
+  });
+
+  it('should handle YamlParseError', () => {
+    const yamlParseError = new YamlParseError(new Error('Invalid yaml'), {} as any);
+    expect(() => handleError(yamlParseError, ref)).toThrowError(HandledError);
+    expect(redColoretteMocks).toHaveBeenCalledTimes(1);
+    expect(process.stderr.write).toHaveBeenCalledWith(
+      `Failed to parse api definition at openapi/test.yaml:\n\n  - Invalid yaml.\n\n`
+    );
+  });
+
+  it('should handle CircularJSONNotSupportedError', () => {
+    const circularError = new CircularJSONNotSupportedError(new Error('Circular json'));
+    expect(() => handleError(circularError, ref)).toThrowError(HandledError);
+    expect(process.stderr.write).toHaveBeenCalledWith(
+      `Detected circular reference which can't be converted to JSON.\n` +
+        `Try to use ${blue('yaml')} output or remove ${blue('--dereferenced')}.\n\n`
+    );
+  });
+
+  it('should handle SyntaxError', () => {
+    const testError = new SyntaxError('Unexpected identifier');
+    testError.stack = 'test stack';
+    expect(() => handleError(testError, ref)).toThrowError(HandledError);
+    expect(process.stderr.write).toHaveBeenCalledWith(
+      'Syntax error: Unexpected identifier test stack\n\n'
+    );
+  });
+
+  it('should throw unknown error', () => {
+    const testError = new Error('Test error');
+    expect(() => handleError(testError, ref)).toThrowError(HandledError);
+    expect(process.stderr.write).toHaveBeenCalledWith(
+      `Something went wrong when processing openapi/test.yaml:\n\n  - Test error.\n\n`
+    );
+  });
+});
+
+describe('checkIfRulesetExist', () => {
+  beforeEach(() => {
+    jest.spyOn(process, 'exit').mockImplementation((code?: number) => code as never);
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should throw an error if rules are not provided', () => {
+    const rules = {
+      oas2: {},
+      oas3_0: {},
+      oas3_1: {},
+    };
+    expect(() => checkIfRulesetExist(rules)).toThrowError(
+      '⚠️ No rules were configured. Learn how to configure rules: https://redocly.com/docs/cli/rules/'
+    );
+  });
+
+  it('should not throw an error if rules are provided', () => {
+    const rules = {
+      oas2: { 'operation-4xx-response': 'error' },
+      oas3_0: {},
+      oas3_1: {},
+    } as any;
+    checkIfRulesetExist(rules);
+  });
+});
+
+describe('cleanColors', () => {
+  it('should remove colors from string', () => {
+    const stringWithColors = `String for ${red('test')}`;
+    const result = cleanColors(stringWithColors);
+
+    expect(result).not.toMatch(/\x1b\[\d+m/g);
+  });
+});
+
+describe('cleanArgs', () => {
+  beforeEach(() => {
+    // @ts-ignore
+    isAbsoluteUrl = jest.requireActual('@redocly/openapi-core').isAbsoluteUrl;
+    // @ts-ignore
+    existsSync = (value) => jest.requireActual('fs').existsSync(path.resolve(__dirname, value));
+    // @ts-ignore
+    statSync = (value) => jest.requireActual('fs').statSync(path.resolve(__dirname, value));
+  });
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+  it('should remove potentially sensitive data from args', () => {
+    const testArgs = {
+      config: './fixtures/redocly.yaml',
+      apis: ['main@v1', 'fixtures/openapi.yaml', 'http://some.url/openapi.yaml'],
+      format: 'codeframe',
+    };
+    expect(cleanArgs(testArgs)).toEqual({
+      config: 'file-yaml',
+      apis: ['api-name@api-version', 'file-yaml', 'http://url'],
+      format: 'codeframe',
+    });
+  });
+  it('should remove potentially sensitive data from a push destination', () => {
+    const testArgs = {
+      destination: '@org/name@version',
+    };
+    expect(cleanArgs(testArgs)).toEqual({
+      destination: '@organization/api-name@api-version',
+    });
+  });
+});
+
+describe('cleanRawInput', () => {
+  beforeEach(() => {
+    // @ts-ignore
+    isAbsoluteUrl = jest.requireActual('@redocly/openapi-core').isAbsoluteUrl;
+    // @ts-ignore
+    existsSync = (value) => jest.requireActual('fs').existsSync(path.resolve(__dirname, value));
+    // @ts-ignore
+    statSync = (value) => jest.requireActual('fs').statSync(path.resolve(__dirname, value));
+  });
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+  it('should remove  potentially sensitive data from raw CLI input', () => {
+    const rawInput = [
+      'redocly',
+      'bundle',
+      'api-name@api-version',
+      './fixtures/openapi.yaml',
+      'http://some.url/openapi.yaml',
+      '--config=fixtures/redocly.yaml',
+      '--output',
+      'fixtures',
+    ];
+    expect(cleanRawInput(rawInput)).toEqual(
+      'redocly bundle api-name@api-version file-yaml http://url --config=file-yaml --output folder'
+    );
+  });
+  it('should preserve safe data from raw CLI input', () => {
+    const rawInput = [
+      'redocly',
+      'lint',
+      './fixtures/openapi.json',
+      '--format',
+      'stylish',
+      '--extends=minimal',
+      '--skip-rule',
+      'operation-4xx-response',
+    ];
+    expect(cleanRawInput(rawInput)).toEqual(
+      'redocly lint file-json --format stylish --extends=minimal --skip-rule operation-4xx-response'
+    );
+  });
+});

package/src/__tests__/wrapper.test.ts

@@ -0,0 +1,57 @@
+import { loadConfigAndHandleErrors, sendTelemetry } from '../utils';
+import * as process from 'process';
+import { commandWrapper } from '../wrapper';
+import { handleLint } from '../commands/lint';
+import { Arguments } from 'yargs';
+import { handlePush, PushOptions } from '../commands/push';
+
+jest.mock('node-fetch');
+jest.mock('../utils', () => ({
+  sendTelemetry: jest.fn(),
+  loadConfigAndHandleErrors: jest.fn(),
+}));
+jest.mock('../commands/lint', () => ({
+  handleLint: jest.fn(),
+  lintConfigCallback: jest.fn(),
+}));
+
+describe('commandWrapper', () => {
+  it('should send telemetry if there is "telemetry: on" in the config', async () => {
+    (loadConfigAndHandleErrors as jest.Mock).mockImplementation(() => {
+      return { telemetry: 'on', styleguide: { recommendedFallback: true } };
+    });
+    process.env.REDOCLY_TELEMETRY = 'on';
+
+    const wrappedHandler = commandWrapper(handleLint);
+    await wrappedHandler({} as any);
+    expect(handleLint).toHaveBeenCalledTimes(1);
+    expect(sendTelemetry).toHaveBeenCalledTimes(1);
+    expect(sendTelemetry).toHaveBeenCalledWith({}, 0, false);
+  });
+
+  it('should NOT send telemetry if there is "telemetry: off" in the config', async () => {
+    (loadConfigAndHandleErrors as jest.Mock).mockImplementation(() => {
+      return { telemetry: 'off', styleguide: { recommendedFallback: true } };
+    });
+    process.env.REDOCLY_TELEMETRY = 'on';
+
+    const wrappedHandler = commandWrapper(handleLint);
+    await wrappedHandler({} as any);
+    expect(handleLint).toHaveBeenCalledTimes(1);
+
+    expect(sendTelemetry).toHaveBeenCalledTimes(0);
+  });
+
+  it('should pass files from arguments to config', async () => {
+    const filesToPush = ['test1.yaml', 'test2.yaml'];
+
+    const loadConfigMock = loadConfigAndHandleErrors as jest.Mock<any, any>;
+
+    const argv = {
+      files: filesToPush,
+    } as Arguments<PushOptions>;
+
+    await commandWrapper(handlePush)(argv);
+    expect(loadConfigMock).toHaveBeenCalledWith(expect.objectContaining({ files: filesToPush }));
+  });
+});

package/src/assert-node-version.ts

@@ -0,0 +1,8 @@
+import * as path from 'path';
+import { exitWithError } from './utils';
+
+try {
+  require('assert-node-version')(path.join(__dirname, '../'));
+} catch (err) {
+  exitWithError(err.message);
+}

package/src/commands/build-docs/index.ts

@@ -0,0 +1,50 @@
+import { loadAndBundleSpec } from 'redoc';
+import { dirname, resolve } from 'path';
+import { writeFileSync, mkdirSync } from 'fs';
+import { performance } from 'perf_hooks';
+
+import { getObjectOrJSON, getPageHTML } from './utils';
+import type { BuildDocsArgv } from './types';
+import { Config, getMergedConfig, isAbsoluteUrl } from '@redocly/openapi-core';
+import { exitWithError, getExecutionTime, getFallbackApisOrExit } from '../../utils';
+
+export const handlerBuildCommand = async (argv: BuildDocsArgv, configFromFile: Config) => {
+  const startedAt = performance.now();
+
+  const config = getMergedConfig(configFromFile, argv.api);
+
+  const apis = await getFallbackApisOrExit(argv.api ? [argv.api] : [], config);
+  const { path: pathToApi } = apis[0];
+
+  const options = {
+    output: argv.o,
+    title: argv.title,
+    disableGoogleFont: argv.disableGoogleFont,
+    templateFileName: argv.template,
+    templateOptions: argv.templateOptions || {},
+    redocOptions: getObjectOrJSON(argv.theme?.openapi, config),
+  };
+
+  const redocCurrentVersion = require('../../../package.json').dependencies.redoc.substring(1); // remove ~
+
+  try {
+    const elapsed = getExecutionTime(startedAt);
+
+    const api = await loadAndBundleSpec(isAbsoluteUrl(pathToApi) ? pathToApi : resolve(pathToApi));
+    const pageHTML = await getPageHTML(
+      api,
+      pathToApi,
+      { ...options, redocCurrentVersion },
+      argv.config
+    );
+
+    mkdirSync(dirname(options.output), { recursive: true });
+    writeFileSync(options.output, pageHTML);
+    const sizeInKiB = Math.ceil(Buffer.byteLength(pageHTML) / 1024);
+    process.stdout.write(
+      `\n🎉 bundled successfully in: ${options.output} (${sizeInKiB} KiB) [⏱ ${elapsed}].\n`
+    );
+  } catch (e) {
+    exitWithError(e);
+  }
+};

package/src/commands/build-docs/template.hbs

@@ -0,0 +1,23 @@
+<!DOCTYPE html>
+<html>
+
+<head>
+  <meta charset="utf8" />
+  <title>{{title}}</title>
+  <!-- needed for adaptive design -->
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <style>
+    body {
+      padding: 0;
+      margin: 0;
+    }
+  </style>
+  {{{redocHead}}}
+  {{#unless disableGoogleFont}}<link href="https://fonts.googleapis.com/css?family=Montserrat:300,400,700|Roboto:300,400,700" rel="stylesheet">{{/unless}}
+</head>
+
+<body>
+  {{{redocHTML}}}
+</body>
+
+</html>