@adobe/helix-html-pipeline 1.0.0

package/src/steps/fix-sections.js

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2021 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+import { wrapContent } from './utils.js';
+
+/**
+ * fixes the sections of a document.
+ * @type PipelineStep
+ * @param {PipelineContent} content
+ */
+export default async function fixSections({ content }) {
+  const { document } = content;
+  const $sections = document.querySelectorAll('body > div');
+
+  // if there are no sections wrap everything in a div with appropriate class names from meta
+  if ($sections.length === 0) {
+    const $outerDiv = document.createElement('div');
+    if (content.meta && content.meta.class) {
+      content.meta.class.split(/[ ,]/)
+        .map((c) => c.trim())
+        .filter((c) => !!c)
+        .forEach((c) => {
+          $outerDiv.classList.add(c);
+        });
+    }
+    wrapContent($outerDiv, document.body);
+  }
+}

package/src/steps/folder-mapping.js

@@ -0,0 +1,61 @@
+/*
+ * Copyright 2022 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+import { extname } from 'path';
+import { getPathInfo } from '../utils/path.js';
+
+/**
+ * Finds the mapping from path to folders in fstab
+ * @param {object} folders folder/path mapping
+ * @param {string} path given path
+ * @returns {null|string} returns the mapped path or null
+ */
+export function mapPath(folders, path) {
+  for (const [folder, mapping] of Object.entries(folders)) {
+    if (path === folder) {
+      return mapping;
+    }
+    if (folder.endsWith('/') && path.startsWith(folder)) {
+      return mapping;
+    }
+    if (path.startsWith(`${folder}/`)) {
+      return mapping;
+    }
+  }
+  return null;
+}
+
+/**
+ * Checks the fstab for folder mapping entries and then re-adjusts the path infos if needed.
+ * if the remapped resource is *not* extensionless, it will be declared as code-bus resource.
+ *
+ * @type PipelineStep
+ * @param {PipelineState} state
+ */
+export default function folderMapping(state) {
+  const folders = state.helixConfig?.fstab?.folders;
+  if (!folders) {
+    return;
+  }
+  const { path } = state.info;
+  const mapped = mapPath(folders, path);
+  if (mapped) {
+    state.info = getPathInfo(mapped);
+    if (extname(mapped)) {
+      // special case: use code-bus
+      state.content.sourceBus = 'code';
+      state.info.resourcePath = mapped;
+      state.log.info(`mapped ${path} to ${state.info.resourcePath} (${state.content.sourceBus}-bus)`);
+    } else {
+      state.log.info(`mapped ${path} to ${state.info.path} (${state.content.sourceBus}-bus)`);
+    }
+  }
+}

package/src/steps/get-metadata.js

@@ -0,0 +1,170 @@
+/*
+ * Copyright 2018 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+import { select, selectAll } from 'unist-util-select';
+import { toString as plain } from 'mdast-util-to-string';
+
+function yaml(section) {
+  section.meta = selectAll('yaml', section)
+    .reduce((prev, { payload }) => Object.assign(prev, payload), {});
+  return section;
+}
+
+function title(section) {
+  const header = select('heading', section);
+  section.title = header ? plain(header) : '';
+}
+
+function intro(section) {
+  const para = selectAll('paragraph', section).filter((p) => {
+    if ((!p.children || p.children.length === 0)
+      || (p.children.length === 1 && p.children[0].type === 'image')) {
+      return false;
+    }
+    return true;
+  })[0];
+  section.intro = para ? plain(para) : '';
+}
+
+function image(section) {
+  // selects the most prominent image of the section
+  // TODO: get a better measure of prominence than "first"
+  const img = select('image', section);
+  if (img) {
+    section.image = img.url;
+  }
+}
+
+/**
+ * Construct the strings corresponding to the number of occurences per type.
+ * @param {Object} typecounter Type as a key, number of occurences as value
+ */
+function constructTypes(typecounter) {
+  const types = Object.keys(typecounter).map((type) => `has-${type}`); // has-{type}
+  types.push(...Object.keys(typecounter).map((type) => `nb-${type}-${typecounter[type]}`)); // nb-{type}-{nb-occurences}
+  if (Object.keys(typecounter).length === 1) {
+    types.push(`has-only-${Object.keys(typecounter)[0]}`);
+  } else {
+    types.push(...Object.entries(typecounter) // get pairs of type, count
+      // sort first descending by count, then alphabetical by key if count is the same
+      .sort((left, right) => right[1] - left[1] || left[0].localeCompare(right[0]))
+      // take the top three
+      .slice(0, 3)
+      // keep only the type
+      .map(([name]) => name)
+      // generate names
+      .reduce((names, name) => [`${names[0] || 'is'}-${name}`, ...names], []));
+  }
+  return types;
+}
+
+/**
+ * Sets the `types` attribute of the section, using following patterns:
+ * 1. has-<type> for every type of content found in the section
+ * 2. is-<type>-only for sections that have only content of type
+ * 3. is-<type1>-<type2>-<type3> ranks the top three most common types of content
+ * 4. nb-<type>-<nb_occurences> is the number of occurences per type
+ * @param {*} section
+ */
+function sectiontype(section) {
+  const children = section.children || [];
+
+  function reducer(counter, node) {
+    const { type, children: pChildren } = node;
+
+    node.meta = { types: [], ...node.meta };
+
+    if (type === 'yaml') {
+      return counter;
+    }
+
+    const mycounter = {};
+
+    if (type === 'paragraph' && pChildren && pChildren.length > 0) {
+      // if child is a paragraph, check its children, it might contain an image or a list
+      // which are always wrapped by default.
+      pChildren.forEach((p) => {
+        let prefix = 'has';
+        if (p.type === 'text') {
+          // do not count "empty" paragraphs
+          if (p.value === '\n' || p.value === '') return;
+
+          // paragraph with type text "is" a text
+          prefix = 'is';
+        }
+        if (!node.meta.types.includes(`${prefix}-${p.type}`)) {
+          node.meta.types.push(`${prefix}-${p.type}`);
+        }
+        const mycount = mycounter[p.type] || 0;
+        mycounter[p.type] = mycount + 1;
+      });
+    }
+
+    if (type === 'list' && pChildren && pChildren.length > 0) {
+      // if list, analyze the children of its children (listitems)
+      let listtypecounter = {};
+      pChildren.forEach((listitem) => {
+        listtypecounter = listitem.children.reduce(reducer, listtypecounter);
+      });
+      constructTypes(listtypecounter).forEach((item) => node.meta.types.push(item));
+    }
+
+    if (Object.keys(mycounter).length === 0) {
+      // was really a paragraph, only text inside
+      const mycount = mycounter[type] || 0;
+      mycounter[type] = mycount + 1;
+      node.meta.types.push(`is-${type}`);
+    }
+
+    Object.keys(counter).forEach((key) => {
+      mycounter[key] = counter[key] + (mycounter[key] || 0);
+    });
+    return mycounter;
+  }
+
+  const typecounter = children.reduce(reducer, {});
+  section.meta.types = constructTypes(typecounter);
+}
+
+function fallback(section) {
+  if (section.intro && !section.title) {
+    section.title = section.intro;
+  } else if (section.title && !section.intro) {
+    section.intro = section.title;
+  }
+}
+
+/**
+ * Extract the metadata from the mdast
+ * @type PipelineStep
+ * @param {PipelineState} state
+ */
+export default function getMetadata(state) {
+  const { content } = state;
+  const { mdast: { children = [] } } = content;
+  let sections = children.filter((node) => node.type === 'section');
+  if (!sections.length) {
+    sections = [content.mdast];
+  }
+
+  [yaml, title, intro, image, sectiontype, fallback].forEach((fn) => {
+    sections.forEach(fn);
+  });
+
+  const img = sections.filter((section) => section.image)[0];
+  const titl = sections.filter((section) => section.title)[0];
+
+  // todo: cleanup meta data confusion
+  content.meta = sections[0].meta;
+  content.title = titl?.title ?? '';
+  content.intro = sections[0].intro;
+  content.image = img?.image ?? undefined;
+}

package/src/steps/make-html.js

@@ -0,0 +1,34 @@
+/*
+ * Copyright 2018 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+import GithubSlugger from 'github-slugger';
+import VDOMTransformer from '../utils/mdast-to-vdom.js';
+
+/**
+ * Converts the markdown to a jsdom dom and stores it in `content.document`
+ * @type PipelineStep
+ * @param {PipelineState} state
+ */
+export default function html(state) {
+  const { log, content } = state;
+  const { mdast } = content;
+  log.debug(`Turning Markdown into HTML from ${typeof mdast}`);
+  // initialize transformer
+  content.slugger = new GithubSlugger();
+  const transformer = new VDOMTransformer()
+    .withOptions({
+      slugger: content.slugger,
+    });
+  content.document = transformer
+    .withMdast(mdast)
+    .getDocument();
+}

package/src/steps/parse-markdown.js

@@ -0,0 +1,42 @@
+/*
+ * Copyright 2018 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+import { unified } from 'unified';
+import remarkParse from 'remark-parse';
+import { removePosition } from 'unist-util-remove-position';
+import { remarkMatter } from '@adobe/helix-markdown-support';
+import remarkGfm from '../utils/remark-gfm-nolink.js';
+
+export class FrontmatterParsingError extends Error {
+}
+
+/**
+ * Parses the markdown body
+ * @type PipelineStep
+ * @param {PipelineState} state
+ */
+export default function parseMarkdown(state) {
+  const { log, content } = state;
+
+  // convert linebreaks
+  const converted = content.data.replace(/(\r\n|\n|\r)/gm, '\n');
+  content.mdast = unified()
+    .use(remarkParse)
+    .use(remarkGfm)
+    .use(remarkMatter, {
+      errorHandler: (e) => {
+        log.warn(new FrontmatterParsingError(e));
+      },
+    })
+    .parse(converted);
+
+  removePosition(content.mdast, true);
+}

package/src/steps/removeHlxProps.js

@@ -0,0 +1,34 @@
+/*
+ * Copyright 2019 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+/**
+ * Cleans the response document by removing `hlx-` stuff
+ * @param {PipelineState} state
+ * @param {PipelineRequest} req
+ * @param {PipelineResponse} res
+ */
+export default function clean(state, req, res) {
+  const { document } = res;
+  document.querySelectorAll('[class]').forEach((el) => {
+    // Remove all `hlx-*` classes on the elements
+    el.classList.value.split(' ')
+      .filter((cls) => cls.indexOf('hlx-') === 0)
+      .forEach((cls) => el.classList.remove(cls));
+    if (!el.classList.length) {
+      el.removeAttribute('class');
+    }
+
+    // Remove all `data-hlx-*` attributes on these elements
+    Object.keys(el.dataset)
+      .filter((key) => key.match(/^hlx[A-Z]/))
+      .forEach((key) => delete el.dataset[key]);
+  });
+}

package/src/steps/render-code.js

@@ -0,0 +1,25 @@
+/*
+ * Copyright 2022 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+import mime from 'mime';
+
+/**
+ * "Renders" the content from the code-bus as-is
+ * @type PipelineStep
+ * @param {PipelineState} state
+ * @param {PipelineRequest} req
+ * @param {PipelineResponse} res
+ * @returns {Promise<void>}
+ */
+export default async function renderCode(state, req, res) {
+  res.body = state.content.data;
+  res.headers.set('content-type', mime.getType(state.info.resourcePath));
+}

package/src/steps/render.js

@@ -0,0 +1,158 @@
+/*
+ * Copyright 2021 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+/* eslint-disable max-len */
+
+import { JSDOM } from 'jsdom';
+
+/*
+<!DOCTYPE html>
+<html data-sly-attribute="${content.document.documentElement.attributesMap}">
+<head>
+  <title>${content.meta.title}</title>
+  <link data-sly-test="${content.meta.url}" rel="canonical" href="${content.meta.url}"/>
+  <meta data-sly-test="${content.meta.description}" name="description" content="${content.meta.description}"/>
+  <meta data-sly-test="${content.meta.keywords}" name="keywords" content="${content.meta.keywords}"/>
+  <meta data-sly-test="${content.meta.title}" property="og:title" content="${content.meta.title}"/>
+  <meta data-sly-test="${content.meta.description}" property="og:description" content="${content.meta.description}"/>
+  <meta data-sly-test="${content.meta.url}" property="og:url" content="${content.meta.url}"/>
+  <meta data-sly-test="${content.meta.image}" property="og:image" content="${content.meta.image}"/>
+  <meta data-sly-test="${content.meta.image}" property="og:image:secure_url" content="${content.meta.image}"/>
+<sly data-sly-test="${content.meta.imageAlt}">
+  <meta data-sly-test="${content.meta.imageAlt}" property="og:image:alt" content="${content.meta.imageAlt}"/>
+</sly>
+  <meta data-sly-test="${content.meta.modifiedTime}" property="og:updated_time" content="${content.meta.modified_time}"/>
+<sly data-sly-test="${content.meta.tags}" data-sly-list.tag="${content.meta.tags}">
+  <meta property="article:tag" content="${tag}"/>
+</sly>
+  <meta data-sly-test="${content.meta.section}" property="article:section" content="${section}"/>
+  <meta data-sly-test="${content.meta.published_time}" property="article:published_time" content="${content.meta.published_time}"/>
+  <meta data-sly-test="${content.meta.modified_time}" property="article:modified_time" content="${content.meta.modified_time}"/>
+  <meta data-sly-test="${content.meta.title}" name="twitter:title" content="${content.meta.title}"/>
+  <meta data-sly-test="${content.meta.description}" name="twitter:description" content="${content.meta.description}"/>
+  <meta data-sly-test="${content.meta.image}" name="twitter:image" content="${content.meta.image}"/>
+<sly data-sly-test="${content.meta.custom}" data-sly-list="${content.meta.custom}">
+  <meta data-sly-test="${item.property}" property="${item.name}" content="${item.value}">
+  <meta data-sly-test="${!item.property}" name="${item.name}" content="${item.value}">
+</sly>
+  <esi:include src="/head.html" onerror="continue"/>
+</head>
+<body data-sly-attribute="${content.document.body.attributesMap}">
+  <!--  header -->
+  <header><esi:include src="/header.plain.html" onerror="continue"/></header>
+  <!--  main content -->
+  <main>${content.document.body}</main>
+  <!--  footer -->
+  <footer><esi:include src="/footer.plain.html"  onerror="continue"/></footer>
+</body>
+</html>
+*/
+
+function appendElement($parent, $el) {
+  if ($el) {
+    $parent.append($el);
+  }
+}
+
+function createElement(doc, name, ...attrs) {
+  // check for empty values
+  for (let i = 0; i < attrs.length; i += 2) {
+    if (!attrs[i + 1]) {
+      return null;
+    }
+  }
+  const $el = doc.createElement(name);
+  for (let i = 0; i < attrs.length; i += 2) {
+    $el.setAttribute(attrs[i], attrs[i + 1]);
+  }
+  return $el;
+}
+
+/**
+ * @type PipelineStep
+ * @param {PipelineState} state
+ * @param {PipelineRequest} req
+ * @param {PipelineResponse} res
+ * @returns {Promise<void>}
+ */
+export default async function render(state, req, res) {
+  const { content } = state;
+  const srcDoc = content.document;
+  if (state.info.selector === 'plain') {
+    // just return body
+    res.document = srcDoc.body;
+  } else {
+    // create document like HTL used to do
+    const dom = new JSDOM('<!DOCTYPE html>'
+      + '<html>'
+      + '<head></head>'
+      + '<body>'
+      + '<header></header>' // todo: are those still required ?
+      + '<main></main>'
+      + '<footer></footer>' // todo: are those still required ?
+      + '</body>'
+      + '</html>');
+    const doc = dom.window.document;
+
+    // add title
+    const $head = doc.head;
+    const { meta } = content;
+    const $title = doc.createElement('title');
+    $title.innerHTML = meta.title;
+    $head.append($title);
+
+    // add meta
+    appendElement($head, createElement(doc, 'link', 'rel', 'canonical', 'href', content.meta.canonical));
+
+    appendElement($head, createElement(doc, 'meta', 'name', 'description', 'content', content.meta.description));
+    appendElement($head, createElement(doc, 'meta', 'name', 'keywords', 'content', content.meta.keywords));
+    appendElement($head, createElement(doc, 'meta', 'property', 'og:title', 'content', content.meta.title));
+    appendElement($head, createElement(doc, 'meta', 'property', 'og:description', 'content', content.meta.description));
+    appendElement($head, createElement(doc, 'meta', 'property', 'og:url', 'content', content.meta.url));
+    appendElement($head, createElement(doc, 'meta', 'property', 'og:image', 'content', content.meta.image));
+    appendElement($head, createElement(doc, 'meta', 'property', 'og:image:secure_url', 'content', content.meta.image));
+    if (content.meta.imageAlt) {
+      appendElement($head, createElement(doc, 'meta', 'property', 'og:image:alt', 'content', content.meta.imageAlt));
+    }
+    appendElement($head, createElement(doc, 'meta', 'property', 'og:updated_time', 'content', content.meta.modified_time));
+    for (const tag of (meta.tags || [])) {
+      appendElement($head, createElement(doc, 'meta', 'property', 'article:tag', 'content', tag));
+    }
+    appendElement($head, createElement(doc, 'meta', 'property', 'article:section', 'content', content.meta.section));
+    appendElement($head, createElement(doc, 'meta', 'property', 'article:published_time', 'content', content.meta.published_time));
+    appendElement($head, createElement(doc, 'meta', 'property', 'article:modified_time', 'content', content.meta.modified_time));
+
+    appendElement($head, createElement(doc, 'meta', 'name', 'twitter:title', 'content', content.meta.title));
+    appendElement($head, createElement(doc, 'meta', 'name', 'twitter:description', 'content', content.meta.description));
+    appendElement($head, createElement(doc, 'meta', 'name', 'twitter:image', 'content', content.meta.image));
+
+    for (const custom of (meta.custom || [])) {
+      appendElement($head, createElement(doc, 'meta', custom.property ? 'property' : 'name', custom.name, 'content', custom.value));
+    }
+    if (meta.feed) {
+      appendElement($head, createElement(doc, 'link', 'rel', 'alternate', 'type', 'application/xml+atom', 'href', meta.feed, 'title', `${meta.title} feed`));
+    }
+    // inject head.html
+    const $headHtml = doc.createElement('template');
+    $headHtml.innerHTML = state.helixConfig?.head?.html ?? `
+        <meta name="viewport" content="width=device-width, initial-scale=1"/>
+        <script src="/scripts.js" type="module" crossorigin="use-credentials"></script>
+        <link rel="stylesheet" href="/styles.css"/>`;
+    $head.appendChild($headHtml.content);
+
+    // add body to main
+    const $main = doc.querySelector('main');
+
+    $main.append(...srcDoc.body.childNodes);
+    res.document = doc;
+  }
+}

package/src/steps/rewrite-blob-images.js

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+const AZURE_BLOB_REGEXP = /^https:\/\/hlx\.blob\.core\.windows\.net\/external\//;
+
+const MEDIA_BLOB_REGEXP = /^https:\/\/.*\.hlx3?\.(live|page)\/media_.*/;
+
+/**
+ * Rewrite blob store image URLs to /hlx_* URLs
+ *
+ * @param {Document} document The (vdom) document
+ */
+function images(document) {
+  document.querySelectorAll('img').forEach((img) => {
+    if (AZURE_BLOB_REGEXP.test(img.src)) {
+      const { pathname, hash } = new URL(img.src);
+      const filename = pathname.split('/').pop();
+      const extension = hash.split('?').shift().split('.').pop() || 'jpg';
+      img.src = `./media_${filename}.${extension}`;
+    } else if (MEDIA_BLOB_REGEXP.test(img.src)) {
+      const { pathname } = new URL(img.src);
+      img.src = `.${pathname}`; // don't append fragment until picture tag supports width/height
+    }
+  });
+}
+
+/**
+ * @type PipelineStep
+ * @param content
+ */
+export default function rewrite({ content }) {
+  if (content.document) {
+    images(content.document);
+  }
+}