openapi-explorer 0.9.310 → 0.9.314

package/dist/lib/utils/spec-parser.js

@@ -0,0 +1,361 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = ProcessSpec;
+
+var _openapiResolver = _interopRequireDefault(require("openapi-resolver/dist/openapi-resolver.browser"));
+
+var _marked = require("marked");
+
+var _commonUtils = require("./common-utils");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+async function ProcessSpec(specUrlOrObject, serverUrl = '') {
+  const inputSpecIsAUrl = typeof specUrlOrObject === 'string' && specUrlOrObject.match(/^http/) || typeof specUrlOrObject === 'object' && typeof specUrlOrObject.href === 'string';
+  let jsonParsedSpec;
+
+  try {
+    jsonParsedSpec = await (0, _openapiResolver.default)(specUrlOrObject);
+  } catch (error) {
+    // eslint-disable-next-line no-console
+    console.error('Error parsing specification', error);
+    throw Error('SpecificationNotFound');
+  }
+
+  if (!jsonParsedSpec) {
+    throw Error('SpecificationNotFound');
+  } // Tags with Paths and WebHooks
+
+
+  const tags = groupByTags(jsonParsedSpec); // Components
+
+  const components = getComponents(jsonParsedSpec); // Info Description Headers
+
+  const infoDescriptionHeaders = jsonParsedSpec.info && jsonParsedSpec.info.description ? getHeadersFromMarkdown(jsonParsedSpec.info.description) : []; // Security Scheme
+
+  const securitySchemes = [];
+
+  if (jsonParsedSpec.components && jsonParsedSpec.components.securitySchemes) {
+    Object.entries(jsonParsedSpec.components.securitySchemes).forEach(kv => {
+      const securityObj = {
+        apiKeyId: kv[0],
+        ...kv[1]
+      };
+      securityObj.value = '';
+      securityObj.finalKeyValue = '';
+
+      if (kv[1].type === 'apiKey' || kv[1].type === 'http') {
+        securityObj.name = kv[1].name || 'Authorization';
+        securityObj.user = '';
+        securityObj.password = '';
+      } else if (kv[1].type === 'oauth2') {
+        securityObj.name = 'Authorization';
+        securityObj.clientId = '';
+        securityObj.clientSecret = '';
+      }
+
+      securitySchemes.push(securityObj);
+    });
+  } // Updated Security Type Display Text based on Type
+
+
+  securitySchemes.forEach(v => {
+    if (v.type === 'http') {
+      v.typeDisplay = v.scheme === 'basic' ? 'HTTP Basic' : 'HTTP Bearer';
+    } else if (v.type === 'apiKey') {
+      v.typeDisplay = `API Key (${v.name})`;
+    } else if (v.type === 'oauth2') {
+      v.typeDisplay = 'OAuth2.0';
+    } else {
+      v.typeDisplay = v.type;
+    }
+  }); // Servers
+
+  let servers = [];
+
+  if (Array.isArray(jsonParsedSpec.servers) && jsonParsedSpec.servers.length) {
+    jsonParsedSpec.servers.forEach(v => {
+      let computedUrl = v.url.trim();
+
+      if (!(computedUrl.startsWith('http') || computedUrl.startsWith('//') || computedUrl.startsWith('{'))) {
+        if (window.location.origin.startsWith('http')) {
+          v.url = window.location.origin + v.url;
+          computedUrl = v.url;
+        }
+      } // Apply server-variables to generate final computed-url
+
+
+      if (v.variables) {
+        Object.entries(v.variables).forEach(kv => {
+          const regex = new RegExp(`{${kv[0]}}`, 'g');
+          computedUrl = computedUrl.replace(regex, kv[1].default || '');
+          kv[1].value = kv[1].default || '';
+        });
+      }
+
+      v.computedUrl = computedUrl;
+    });
+
+    if (serverUrl && !jsonParsedSpec.servers.some(s => s.url === serverUrl || s.computedUrl === serverUrl)) {
+      jsonParsedSpec.servers.push({
+        url: serverUrl,
+        computedUrl: serverUrl
+      });
+    }
+  } else if (serverUrl) {
+    jsonParsedSpec.servers = [{
+      url: serverUrl,
+      computedUrl: serverUrl
+    }];
+  } else if (inputSpecIsAUrl) {
+    jsonParsedSpec.servers = [{
+      url: new URL(specUrlOrObject).origin,
+      computedUrl: new URL(specUrlOrObject).origin
+    }];
+  } else if (window.location.origin.startsWith('http')) {
+    jsonParsedSpec.servers = [{
+      url: window.location.origin,
+      computedUrl: window.location.origin
+    }];
+  } else {
+    jsonParsedSpec.servers = [{
+      url: 'http://localhost',
+      computedUrl: 'http://localhost'
+    }];
+  }
+
+  servers = jsonParsedSpec.servers;
+  const parsedSpec = {
+    info: jsonParsedSpec.info,
+    infoDescriptionHeaders,
+    tags,
+    components,
+    // pathGroups,
+    externalDocs: jsonParsedSpec.externalDocs,
+    securitySchemes,
+    servers
+  };
+  return parsedSpec;
+}
+
+function getHeadersFromMarkdown(markdownContent) {
+  const tokens = _marked.marked.lexer(markdownContent);
+
+  const headers = tokens.filter(v => v.type === 'heading' && v.depth <= 2);
+  return headers || [];
+}
+
+function getComponents(openApiSpec) {
+  if (!openApiSpec.components) {
+    return [];
+  }
+
+  const components = [];
+
+  for (const component in openApiSpec.components) {
+    const subComponents = Object.keys(openApiSpec.components[component]).map(sComponent => ({
+      expanded: true,
+      id: `${component.toLowerCase()}-${sComponent.toLowerCase()}`.replace(_commonUtils.invalidCharsRegEx, '-'),
+      name: sComponent,
+      component: openApiSpec.components[component][sComponent]
+    })).sort((a, b) => a.name.toLowerCase().localeCompare(b.name.toLowerCase()));
+    let cmpDescription;
+    let cmpName;
+
+    switch (component) {
+      case 'schemas':
+        cmpName = 'Schemas';
+        cmpDescription = '';
+        break;
+
+      case 'responses':
+        cmpName = 'Responses';
+        cmpDescription = 'Describes responses from an API Operation, including design-time, static links to operations based on the response.';
+        break;
+
+      case 'parameters':
+        cmpName = 'Parameters';
+        cmpDescription = 'Describes operation parameters. A unique parameter is defined by a combination of a name and location.';
+        break;
+
+      case 'examples':
+        cmpName = 'Examples';
+        cmpDescription = 'List of Examples for operations, can be requests, responses and objects examples.';
+        break;
+
+      case 'requestBodies':
+        break;
+
+      case 'headers':
+        cmpName = 'Headers';
+        cmpDescription = 'Headers follows the structure of the Parameters but they are explicitly in "header"';
+        break;
+
+      case 'securitySchemes':
+        break;
+
+      case 'links':
+        cmpName = 'Links';
+        cmpDescription = 'Links represent a possible design-time link for a response. The presence of a link does not guarantee the caller\'s ability to successfully invoke it, rather it provides a known relationship and traversal mechanism between responses and other operations.';
+        break;
+
+      case 'callbacks':
+        cmpName = 'Callbacks'; // eslint-disable-next-line max-len
+
+        cmpDescription = 'A map of possible out-of band callbacks related to the parent operation. Each value in the map is a Path Item Object that describes a set of requests that may be initiated by the API provider and the expected responses. The key value used to identify the path item object is an expression, evaluated at runtime, that identifies a URL to use for the callback operation.';
+        break;
+
+      default:
+        cmpName = component;
+        cmpDescription = component;
+        break;
+    }
+
+    if (cmpName) {
+      components.push({
+        show: true,
+        name: cmpName,
+        description: cmpDescription,
+        subComponents
+      });
+    }
+  }
+
+  return components;
+}
+
+function groupByTags(openApiSpec) {
+  const supportedMethods = ['get', 'put', 'post', 'delete', 'patch', 'head', 'options']; // this is also used for ordering endpoints by methods
+
+  const tags = openApiSpec.tags && Array.isArray(openApiSpec.tags) ? openApiSpec.tags.map(t => ({
+    show: true,
+    elementId: `tag--${t.name.replace(_commonUtils.invalidCharsRegEx, '-')}`,
+    name: t.name,
+    description: t.description || '',
+    headers: t.description ? getHeadersFromMarkdown(t.description) : [],
+    paths: [],
+    expanded: t['x-tag-expanded'] !== false
+  })) : [];
+  const pathsAndWebhooks = openApiSpec.paths || {};
+
+  if (openApiSpec.webhooks) {
+    for (const [key, value] of Object.entries(openApiSpec.webhooks)) {
+      value._type = 'webhook'; // eslint-disable-line no-underscore-dangle
+
+      pathsAndWebhooks[key] = value;
+    }
+  } // For each path find the tag and push it into the corresponding tag
+
+
+  for (const pathOrHookName in pathsAndWebhooks) {
+    const commonParams = pathsAndWebhooks[pathOrHookName].parameters;
+    const commonPathProp = {
+      servers: pathsAndWebhooks[pathOrHookName].servers || [],
+      parameters: pathsAndWebhooks[pathOrHookName].parameters || []
+    };
+    const isWebhook = pathsAndWebhooks[pathOrHookName]._type === 'webhook'; // eslint-disable-line no-underscore-dangle
+
+    supportedMethods.forEach(methodName => {
+      if (pathsAndWebhooks[pathOrHookName][methodName]) {
+        const pathOrHookObj = openApiSpec.paths[pathOrHookName][methodName]; // If path.methods are tagged, else generate it from path
+
+        const pathTags = Array.isArray(pathOrHookObj.tags) ? pathOrHookObj.tags : pathOrHookObj.tags && [pathOrHookObj.tags] || [];
+
+        if (pathTags.length === 0) {
+          pathTags.push('General ⦂');
+        }
+
+        pathTags.forEach(tag => {
+          let tagObj;
+          let specTagsItem;
+
+          if (openApiSpec.tags) {
+            specTagsItem = openApiSpec.tags.find(v => v.name.toLowerCase() === tag.toLowerCase());
+          }
+
+          tagObj = tags.find(v => v.name === tag);
+
+          if (!tagObj) {
+            tagObj = {
+              show: true,
+              elementId: `tag--${tag.replace(_commonUtils.invalidCharsRegEx, '-')}`,
+              name: tag,
+              description: specTagsItem && specTagsItem.description || '',
+              headers: specTagsItem && specTagsItem.description ? getHeadersFromMarkdown(specTagsItem.description) : [],
+              paths: [],
+              expanded: specTagsItem ? specTagsItem['x-tag-expanded'] !== false : true
+            };
+            tags.push(tagObj);
+          } // Generate a short summary which is broken
+
+
+          let shortSummary = (pathOrHookObj.summary || pathOrHookObj.description || `${methodName.toUpperCase()} ${pathOrHookName}`).trim();
+
+          if (shortSummary.length > 100) {
+            shortSummary = shortSummary.split(/[.|!|?]\s|[\r?\n]/)[0]; // take the first line (period or carriage return)
+          } // Merge Common Parameters with This methods parameters
+
+
+          let finalParameters = [];
+
+          if (commonParams) {
+            if (pathOrHookObj.parameters) {
+              finalParameters = commonParams.filter(commonParam => {
+                if (!pathOrHookObj.parameters.some(param => commonParam.name === param.name && commonParam.in === param.in)) {
+                  return commonParam;
+                }
+
+                return undefined;
+              }).concat(pathOrHookObj.parameters);
+            } else {
+              finalParameters = commonParams.slice(0);
+            }
+          } else {
+            finalParameters = pathOrHookObj.parameters ? pathOrHookObj.parameters.slice(0) : [];
+          } // Remove bad callbacks
+
+
+          if (pathOrHookObj.callbacks) {
+            for (const [callbackName, callbackConfig] of Object.entries(pathOrHookObj.callbacks)) {
+              const originalCallbackEntries = Object.entries(callbackConfig);
+              const filteredCallbacks = originalCallbackEntries.filter(entry => typeof entry[1] === 'object') || [];
+              pathOrHookObj.callbacks[callbackName] = Object.fromEntries(filteredCallbacks);
+
+              if (filteredCallbacks.length !== originalCallbackEntries.length) {
+                console.warn(`OpenAPI Explorer: Invalid Callback found in ${callbackName}`); // eslint-disable-line no-console
+              }
+            }
+          } // Update Responses
+
+
+          tagObj.paths.push({
+            show: true,
+            expanded: false,
+            isWebhook,
+            expandedAtLeastOnce: false,
+            summary: pathOrHookObj.summary || '',
+            description: pathOrHookObj.description || '',
+            shortSummary,
+            method: methodName,
+            path: pathOrHookName,
+            operationId: pathOrHookObj.operationId,
+            elementId: `${methodName}-${pathOrHookName.replace(_commonUtils.invalidCharsRegEx, '-')}`,
+            servers: pathOrHookObj.servers ? commonPathProp.servers.concat(pathOrHookObj.servers) : commonPathProp.servers,
+            parameters: finalParameters,
+            requestBody: pathOrHookObj.requestBody,
+            responses: pathOrHookObj.responses,
+            callbacks: pathOrHookObj.callbacks,
+            deprecated: pathOrHookObj.deprecated,
+            security: pathOrHookObj.security,
+            // commonSummary: commonPathProp.summary,
+            // commonDescription: commonPathProp.description,
+            xCodeSamples: pathOrHookObj['x-codeSamples'] || pathOrHookObj['x-code-samples'] || ''
+          });
+        }); // End of tag path create
+      }
+    }); // End of Methods
+  }
+
+  return tags.filter(tag => tag.paths && tag.paths.length > 0);
+}

package/dist/lib/utils/theme.js

@@ -0,0 +1,84 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = setTheme;
+
+var _litElement = require("lit-element");
+
+var _color = _interopRequireDefault(require("color"));
+
+var _colorUtils = _interopRequireDefault(require("./color-utils"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/* Generates an schema object containing type and constraint info */
+// TODO: possible drive theme from:
+
+/*
+  if (!this.theme || !'light, dark,'.includes(`${this.theme},`)) {
+    this.theme = (window.matchMedia && window.matchMedia('(prefers-color-scheme: light)').matches) ? 'light' : 'dark';
+  }
+*/
+function setTheme(theme = {}) {
+  const bg1 = theme.bg1 ? theme.bg1 : '#ffffff';
+  const fg1 = theme.fg1 ? theme.fg1 : '#444444';
+  const bg2 = theme.bg2 ? theme.bg2 : _colorUtils.default.color.brightness(bg1, -5); // or '#fafafa'
+
+  const bg3 = theme.bg3 ? theme.bg3 : _colorUtils.default.color.brightness(bg1, -15); // or '#f6f6f6'
+
+  const lightBg = theme.bg3 ? theme.bg3 : _colorUtils.default.color.brightness(bg1, -45);
+  const fg2 = theme.fg2 ? theme.fg2 : _colorUtils.default.color.brightness(fg1, 17); // or '#555'
+
+  const fg3 = theme.fg3 ? theme.fg3 : _colorUtils.default.color.brightness(fg1, 30); // or #666
+
+  const lightFg = theme.fg3 ? theme.fg3 : _colorUtils.default.color.brightness(fg1, 70); // or #999
+
+  const inlineCodeFg = theme.inlineCodeFg ? theme.inlineCodeFg : 'brown';
+  const selectionBg = '#444';
+  const selectionFg = '#eee';
+  const headerColor = theme.headerColor ? theme.headerColor : _colorUtils.default.color.brightness(bg1, -180);
+  const navBgColor = theme.navBgColor ? theme.navBgColor : _colorUtils.default.color.brightness(bg1, -180);
+  const navTextColor = theme.navTextColor ? theme.navTextColor : _colorUtils.default.color.opacity(_colorUtils.default.color.invert(navBgColor), '0.65');
+  const navHoverBgColor = theme.navHoverBgColor ? theme.navHoverBgColor : _colorUtils.default.color.brightness(navBgColor, -15);
+  const navHoverTextColor = theme.navHoverTextColor ? theme.navHoverTextColor : _colorUtils.default.color.invert(navBgColor);
+  const overlayBg = 'rgba(0, 0, 0, 0.4)';
+  const defaultColors = [`--purple: ${getComputedStyle(this).getPropertyValue('--purple').trim() || '#6f42c1'}`, `--red: ${getComputedStyle(this).getPropertyValue('--red').trim() || '#dc3545'}`, `--orange: ${getComputedStyle(this).getPropertyValue('--orange').trim() || '#fd7e14'}`, `--yellow: ${getComputedStyle(this).getPropertyValue('--yellow').trim() || '#ffc107'}`, `--green: ${getComputedStyle(this).getPropertyValue('--green').trim() || '#28a745'}`, `--blue: ${getComputedStyle(this).getPropertyValue('--blue').trim() || '#38b3f9'}`, '--pink: #e83e8c', '--white: #fff', ''];
+  const lightColors = [`--light-purple: ${(0, _color.default)(getComputedStyle(this).getPropertyValue('--purple').trim() || '#6f42c1').lightness(96).hex()}`, `--light-red: ${(0, _color.default)(getComputedStyle(this).getPropertyValue('--red').trim() || '#dc3545').lightness(96).hex()}`, `--light-orange: ${(0, _color.default)(getComputedStyle(this).getPropertyValue('--orange').trim() || '#fd7e14').lightness(96).hex()}`, `--light-yellow: ${(0, _color.default)(getComputedStyle(this).getPropertyValue('--yellow').trim() || '#ffc107').lightness(96).hex()}`, `--light-green: ${(0, _color.default)(getComputedStyle(this).getPropertyValue('--green').trim() || '#28a745').lightness(96).hex()}`, `--light-blue: ${(0, _color.default)(getComputedStyle(this).getPropertyValue('--blue').trim() || '#38b3f9').lightness(96).hex()}`, ''];
+  const newTheme = {
+    bg1,
+    bg2,
+    bg3,
+    lightBg,
+    fg1,
+    fg2,
+    fg3,
+    lightFg,
+    inlineCodeFg,
+    selectionBg,
+    selectionFg,
+    overlayBg,
+    navBgColor,
+    navTextColor,
+    navHoverBgColor,
+    navHoverTextColor,
+    headerColor,
+    headerColorInvert: _colorUtils.default.color.invert(headerColor),
+    headerColorDarker: _colorUtils.default.color.brightness(headerColor, -20),
+    headerColorBorder: _colorUtils.default.color.brightness(headerColor, 10),
+    borderColor: theme.borderColor || _colorUtils.default.color.brightness(bg1, -38),
+    lightBorderColor: theme.lightBorderColor || _colorUtils.default.color.brightness(bg1, -23),
+    codeBorderColor: theme.codeBorderColor || 'transparent',
+    inputBg: theme.inputBg || _colorUtils.default.color.brightness(bg1, 10),
+    // #fff
+    placeHolder: theme.placeHolder || _colorUtils.default.color.brightness(lightFg, 20),
+    // #dedede
+    hoverColor: theme.hoverColor || _colorUtils.default.color.brightness(bg1, -5),
+    // # f1f1f1
+    codeBg: theme.codeBg || _colorUtils.default.color.opacity(_colorUtils.default.color.brightness(bg1, -15), 0.7),
+    codeFg: theme.codeFg || '#666',
+    codePropertyColor: theme.codePropertyColor || '#905',
+    codeKeywordColor: theme.codeKeywordColor || '#07a',
+    codeOperatorColor: theme.codeOperatorColor || '#9a6e3a'
+  };
+  return (0, _litElement.html)` <style>*,:after,:before{box-sizing:border-box}:host{--border-radius:2px;--layout:${this.layout || 'column'};--nav-item-padding:${this.navItemSpacing === 'relaxed' ? '10px' : this.navItemSpacing === 'compact' ? '5px 10px' : '7px 10px'};--resp-area-height:${this.responseAreaHeight};--font-size-small:${this.fontSize === 'default' ? '12px' : this.fontSize === 'large' ? '13px' : '14px'};--font-size-mono:${this.fontSize === 'default' ? '13px' : this.fontSize === 'large' ? '14px' : '15px'};--font-size-regular:${this.fontSize === 'default' ? '14px' : this.fontSize === 'large' ? '15px' : '16px'};--dialog-z-index:1000;--bg:${newTheme.bg1};--bg2:${newTheme.bg2};--bg3:${newTheme.bg3};--light-bg:${newTheme.lightBg};--fg:${newTheme.fg1};--fg2:${newTheme.fg2};--fg3:${newTheme.fg3};--light-fg:${newTheme.lightFg};--selection-bg:${newTheme.selectionBg};--selection-fg:${newTheme.selectionFg};--overlay-bg:${newTheme.overlayBg};--border-color:${newTheme.borderColor};--light-border-color:${newTheme.lightBorderColor};--code-border-color:${newTheme.codeBorderColor};--input-bg:${newTheme.inputBg};--placeholder-color:${newTheme.placeHolder};--hover-color:${newTheme.hoverColor};${defaultColors.join(';\n')} ${lightColors.join(';\n')} --header-bg:${newTheme.headerColor};--header-fg:${newTheme.headerColorInvert};--header-color-darker:${newTheme.headerColorDarker};--header-color-border:${newTheme.headerColorBorder};--nav-bg-color:${newTheme.navBgColor};--nav-text-color:${newTheme.navTextColor};--nav-hover-bg-color:${newTheme.navHoverBgColor};--nav-hover-text-color:${newTheme.navHoverTextColor};--code-bg:${newTheme.codeBg};--code-fg:${newTheme.codeFg};--inline-code-fg:${newTheme.inlineCodeFg};--code-property-color:${newTheme.codePropertyColor};--code-keyword-color:${newTheme.codeKeywordColor};--code-operator-color:${newTheme.codeOperatorColor};--primary-color:${theme.primaryColor};--secondary-color:${theme.secondaryColor};--primary-btn-text-color:${_colorUtils.default.color.selectTextColorFromBackground(theme.primaryColor)}}</style>`;
+}

package/dist/lib/utils/xml/xml.js

@@ -0,0 +1,239 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = xml;
+
+/* eslint-disable no-underscore-dangle */
+const XML_CHARACTER_MAP = {
+  '&': '&',
+  '"': '"',
+  "'": ''',
+  '<': '&lt;',
+  '>': '&gt;'
+};
+
+function escapeForXML(string) {
+  return string && string.replace ? string.replace(/([&"<>'])/g, function (str, item) {
+    return XML_CHARACTER_MAP[item];
+  }) : string;
+}
+
+const DEFAULT_INDENT = '    ';
+
+function xml(input, rawOptions) {
+  let options = rawOptions;
+
+  if (typeof options !== 'object') {
+    options = {
+      indent: options
+    };
+  }
+
+  let output = '';
+  const indent = !options.indent ? '' : options.indent === true ? DEFAULT_INDENT : options.indent;
+  let instant = true;
+
+  function delay(func) {
+    if (!instant) {
+      func();
+    } else {
+      process.nextTick(func);
+    }
+  }
+
+  function append(_, out) {
+    if (out !== undefined) {
+      output += out;
+    }
+  }
+
+  function add(value, last) {
+    format(append, resolve(value, indent, indent ? 1 : 0), last);
+  }
+
+  function addXmlDeclaration(declaration) {
+    const encoding = declaration.encoding || 'UTF-8';
+    const attr = {
+      version: '1.0',
+      encoding: encoding
+    };
+
+    if (declaration.standalone) {
+      attr.standalone = declaration.standalone;
+    }
+
+    add({
+      '?xml': {
+        _attr: attr
+      }
+    });
+    output = output.replace('/>', '?>');
+  } // disable delay delayed
+
+
+  delay(function () {
+    instant = false;
+  });
+
+  if (options.declaration) {
+    addXmlDeclaration(options.declaration);
+  }
+
+  if (input && input.forEach) {
+    input.forEach(function (value, i) {
+      add(value, i + 1 === input.length);
+    });
+  } else {
+    add(input, true);
+  }
+
+  return output;
+}
+
+function create_indent(character, count) {
+  return new Array(count || 0).join(character || '');
+}
+
+function resolve(data, indent, indent_count_raw) {
+  const indent_count = indent_count_raw || 0;
+  const indent_spaces = create_indent(indent, indent_count);
+  let name;
+  let values = data;
+  const interrupt = false;
+
+  if (typeof data === 'object') {
+    const keys = Object.keys(data);
+    name = keys[0];
+    values = data[name];
+
+    if (values && values._elem) {
+      values._elem.name = name;
+      values._elem.icount = indent_count;
+      values._elem.indent = indent;
+      values._elem.indents = indent_spaces;
+      values._elem.interrupt = values;
+      return values._elem;
+    }
+  }
+
+  const attributes = [];
+  const content = [];
+  let isStringContent;
+
+  function get_attributes(obj) {
+    const keys = Object.keys(obj);
+    keys.forEach(function (key) {
+      attributes.push(attribute(key, obj[key]));
+    });
+  }
+
+  switch (typeof values) {
+    case 'object':
+      if (values === null) {
+        break;
+      }
+
+      if (values._attr) {
+        get_attributes(values._attr);
+      }
+
+      if (values._cdata) {
+        content.push(`${`<![CDATA[${values._cdata}`.replace(/\]\]>/g, ']]]]><![CDATA[>')}]]>`);
+      }
+
+      if (values.forEach) {
+        isStringContent = false;
+        content.push('');
+        values.forEach(function (value) {
+          if (typeof value === 'object') {
+            const _name = Object.keys(value)[0];
+
+            if (_name === '_attr') {
+              get_attributes(value._attr);
+            } else {
+              content.push(resolve(value, indent, indent_count + 1));
+            }
+          } else {
+            // string
+            content.pop();
+            isStringContent = true;
+            content.push(escapeForXML(value));
+          }
+        });
+
+        if (!isStringContent) {
+          content.push('');
+        }
+      }
+
+      break;
+
+    default:
+      // string
+      content.push(escapeForXML(values));
+  }
+
+  return {
+    name: name,
+    interrupt: interrupt,
+    attributes: attributes,
+    content: content,
+    icount: indent_count,
+    indents: indent_spaces,
+    indent: indent
+  };
+}
+
+function format(append, elem, end) {
+  if (typeof elem !== 'object') {
+    append(false, elem);
+    return;
+  }
+
+  const len = elem.interrupt ? 1 : elem.content.length;
+
+  function proceed() {
+    while (elem.content.length) {
+      const value = elem.content.shift();
+
+      if (value === undefined) {
+        continue;
+      }
+
+      if (interrupt(value)) {
+        return;
+      }
+
+      format(append, value);
+    }
+
+    append(false, (len > 1 ? elem.indents : '') + (elem.name ? `</${elem.name}>` : '') + (elem.indent && !end ? '\n' : ''));
+  }
+
+  function interrupt(value) {
+    if (value.interrupt) {
+      value.interrupt.append = append;
+      value.interrupt.end = proceed;
+      value.interrupt = false;
+      append(true);
+      return true;
+    }
+
+    return false;
+  }
+
+  append(false, elem.indents + (elem.name ? `<${elem.name}` : '') + (elem.attributes.length ? ` ${elem.attributes.join(' ')}` : '') + (len ? elem.name ? '>' : '' : elem.name ? '/>' : '') + (elem.indent && len > 1 ? '\n' : ''));
+
+  if (!len) {
+    append(false, elem.indent ? '\n' : '');
+    return;
+  }
+
+  if (!interrupt(elem)) {
+    proceed();
+  }
+}
+
+function attribute(key, value) {
+  return `${key}=` + `"${escapeForXML(value)}"`;
+}