@omega.js/web 0.1.0

package/dist/vendor/template-kit/tags/content.js

@@ -0,0 +1,175 @@
+/**
+ * content.js — the content/metadata omega_ tags.
+ *
+ * Ported from jekyll-uj-powertools lib/tags/{readtime,fake_comments,external,
+ * social,language,translation_url}.rb. Engine-neutral renderers (see
+ * conditionals.js for the ctx contract).
+ */
+
+// Libraries
+const { resolveInput, parseArguments } = require('../variable-resolver.js');
+const { LANGUAGES } = require('../data/languages.js');
+const { SOCIAL_URLS } = require('../data/social-urls.js');
+
+/**
+ * Strip HTML (script/style blocks first, then tags) and collapse whitespace.
+ * @param {string} content
+ * @returns {string}
+ */
+function stripHtml(content) {
+  return String(content)
+    .replace(/<script[\s\S]*?<\/script>/gm, '')
+    .replace(/<style[\s\S]*?<\/style>/gm, '')
+    .replace(/<[^>]+>/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+/**
+ * Resolve tag content: no argument = current page content, else resolve input.
+ */
+function resolveContent(ctx, markup) {
+  if (!markup) {
+    return ctx.page ? ctx.page.content : null;
+  }
+  return resolveInput(ctx.lookup, markup);
+}
+
+// {% omega_readtime %} / {% omega_readtime page.description %} — minutes at 269 wpm, min 1
+const omegaReadtime = {
+  block: false,
+  render(ctx, markup) {
+    const content = resolveContent(ctx, markup.trim());
+    if (!content) return '1';
+
+    const words = stripHtml(content).split(/\s+/).length;
+    return String(Math.max(1, Math.ceil(words / 269)));
+  },
+};
+
+// {% omega_fake_comments %} — deterministic pseudo comment count (words % 13)
+const omegaFakeComments = {
+  block: false,
+  render(ctx, markup) {
+    const content = resolveContent(ctx, markup.trim());
+    if (!content) return '0';
+
+    const words = stripHtml(content).split(/\s+/).length;
+    return String(words % 13);
+  },
+};
+
+// {% omega_external path %} — absolutize a path against site.url (pass through full URLs)
+const omegaExternal = {
+  block: false,
+  render(ctx, markup) {
+    let path = resolveInput(ctx.lookup, markup.trim());
+    if (!path) return '';
+
+    path = String(path);
+    if (/^https?:\/\//.test(path) || /^\/\//.test(path)) return path;
+
+    const siteUrl = String(ctx.site.config.url || '').replace(/\/$/, '');
+    if (!path.startsWith('/')) path = `/${path}`;
+    return `${siteUrl}${path}`;
+  },
+};
+
+// {% omega_social platform %} — profile URL from resolved.config.socials.{platform}
+const omegaSocial = {
+  block: false,
+  render(ctx, markup) {
+    const platform = resolveInput(ctx.lookup, markup.trim()) || markup.trim();
+    if (!ctx.page) return '';
+
+    // Two shapes of the same scope: legacy UJM injected `resolved` INTO the
+    // page; @omega.js/web's data cascade puts it beside `page` (its migrate
+    // rule 1: `page.resolved.` → `resolved.`). Config keys live under
+    // `resolved.config` since #607 — `socials` is one of them.
+    const resolved = ctx.page.resolved || ctx.lookup('resolved');
+    const socials = resolved && resolved.config && resolved.config.socials;
+    const entry = socials && socials[platform];
+    // An entry is a handle, or { handle, redirect } when the shortlink goes
+    // somewhere other than the profile (#429) — sameAs reads the PROFILE.
+    const handle = entry && typeof entry === 'object' ? entry.handle : entry;
+    if (!handle) return '';
+
+    const pattern = SOCIAL_URLS[platform];
+    if (!pattern) return '';
+
+    return pattern.replace('%s', handle);
+  },
+};
+
+// {% omega_language "es" %} / {% omega_language code, "native" %} — language name lookup
+const omegaLanguage = {
+  block: false,
+  render(ctx, markup) {
+    const parts = parseArguments(markup);
+
+    let isoCode = parts[0] || '';
+    const resolved = resolveInput(ctx.lookup, isoCode, true);
+    isoCode = typeof resolved === 'string'
+      ? resolved.replace(/^['"]|['"]$/g, '')
+      : isoCode.replace(/^['"]|['"]$/g, '');
+
+    const outputType = String(resolveInput(ctx.lookup, parts[1], true) || 'english').toLowerCase();
+    isoCode = isoCode.toLowerCase();
+
+    const language = LANGUAGES[isoCode];
+    if (!language) return isoCode;
+
+    return outputType === 'native' ? language[1] : language[0];
+  },
+};
+
+// {% omega_translation_url lang, page.url %} — language-prefixed URL honoring
+// site.translation { default, languages, exclude }
+const omegaTranslationUrl = {
+  block: false,
+  render(ctx, markup) {
+    const parts = parseArguments(markup);
+    if (parts.length === 0 || !parts[0]) return '/';
+
+    let languageCode = resolveInput(ctx.lookup, parts[0]);
+    const urlPath = resolveInput(ctx.lookup, parts[1]) || '/';
+
+    const translation = ctx.site.config.translation || {};
+    const defaultLanguage = translation.default || 'en';
+    const availableLanguages = translation.languages || [defaultLanguage];
+
+    if (!availableLanguages.includes(languageCode)) {
+      languageCode = defaultLanguage;
+    }
+
+    const normalizedPath = normalizePath(urlPath);
+
+    const excludes = translation.exclude || [];
+    if (pageExcluded(normalizedPath, excludes)) {
+      return normalizedPath === '' ? '/' : `/${normalizedPath}`;
+    }
+
+    if (languageCode === defaultLanguage) {
+      return normalizedPath === '' ? '/' : `/${normalizedPath}`;
+    }
+    return normalizedPath === '' ? `/${languageCode}` : `/${languageCode}/${normalizedPath}`;
+  },
+};
+
+function normalizePath(path) {
+  if (!path) return '';
+
+  let clean = String(path).startsWith('/') ? String(path).slice(1) : String(path);
+  if (!clean) return '';
+
+  clean = clean.replace(/^blog\/index\.html$/, 'blog');
+  clean = clean.replace(/^blog\/page\/(\d+)\.html$/, 'blog/page/$1');
+  return clean;
+}
+
+function pageExcluded(normalizedPath, excludes) {
+  if (!excludes.length || !normalizedPath) return false;
+  return excludes.some((exclude) => normalizedPath === exclude || normalizedPath.startsWith(`${exclude}/`));
+}
+
+module.exports = { omegaReadtime, omegaFakeComments, omegaExternal, omegaSocial, omegaLanguage, omegaTranslationUrl, stripHtml };

package/dist/vendor/template-kit/tags/index.js

@@ -0,0 +1,33 @@
+/**
+ * tags/index.js — the registered-name => tag-definition map.
+ *
+ * Names match jekyll-uj-powertools' Liquid registrations exactly (including
+ * the four unprefixed ones: iftruthy, iffalsy, iffile, urlmatches) so
+ * templates port verbatim. Each definition is `{ block, render(ctx, markup
+ * [, renderInner]) }`; the engine adapter (register-liquid.js) builds `ctx`.
+ */
+
+const { iftruthy, iffalsy, iffile, urlmatches } = require('./conditionals.js');
+const { omegaReadtime, omegaFakeComments, omegaExternal, omegaSocial, omegaLanguage, omegaTranslationUrl } = require('./content.js');
+const { omegaLogo, omegaImage, omegaVideo } = require('./media.js');
+const { omegaMember, omegaPost } = require('./collections.js');
+
+const TAGS = {
+  iftruthy,
+  iffalsy,
+  iffile,
+  urlmatches,
+  omega_readtime: omegaReadtime,
+  omega_fake_comments: omegaFakeComments,
+  omega_external: omegaExternal,
+  omega_social: omegaSocial,
+  omega_language: omegaLanguage,
+  omega_translation_url: omegaTranslationUrl,
+  omega_logo: omegaLogo,
+  omega_image: omegaImage,
+  omega_video: omegaVideo,
+  omega_member: omegaMember,
+  omega_post: omegaPost,
+};
+
+module.exports = { TAGS };

package/dist/vendor/template-kit/tags/media.js

@@ -0,0 +1,376 @@
+/**
+ * media.js — the media omega_ tags (logo, image, video).
+ *
+ * Ported from jekyll-uj-powertools lib/tags/{logo,image,video}.rb. Logo SVG
+ * loading is directory-injectable via the adapter options (`options.logos.dir`)
+ * — no hardcoded node_modules path like the Ruby had.
+ *
+ * ICONS are not a tag ([#619](https://github.com/Omega-JS-Stack/omega/issues/619)):
+ * authoring is native Font Awesome markup (`<i class="fa-solid fa-rocket">`),
+ * which @omega.js/web inlines at build and upgrades at runtime — one system,
+ * nothing to learn, and it works for markup JS creates.
+ */
+
+// Libraries
+const fs = require('fs');
+const path = require('path');
+const { resolveInput, parseArguments, parseOptions, stripQuotes } = require('../variable-resolver.js');
+
+// Constants (verbatim from the Ruby port)
+const DEFAULT_ICON = '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 640 640"><!--!Font Awesome Free v7.0.0 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license/free Copyright 2025 Fonticons, Inc.--><path d="M320 64C334.7 64 348.2 72.1 355.2 85L571.2 485C577.9 497.4 577.6 512.4 570.4 524.5C563.2 536.6 550.1 544 536 544L104 544C89.9 544 76.9 536.6 69.6 524.5C62.3 512.4 62.1 497.4 68.8 485L284.8 85C291.8 72.1 305.3 64 320 64zM320 232C306.7 232 296 242.7 296 256L296 368C296 381.3 306.7 392 320 392C333.3 392 344 381.3 344 368L344 256C344 242.7 333.3 232 320 232zM346.7 448C347.3 438.1 342.4 428.7 333.9 423.5C325.4 418.4 314.7 418.4 306.2 423.5C297.7 428.7 292.8 438.1 293.4 448C292.8 457.9 297.7 467.3 306.2 472.5C314.7 477.6 325.4 477.6 333.9 472.5C342.4 467.3 347.3 457.9 346.7 448z"/></svg>';
+const IMAGE_PLACEHOLDER = 'data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==';
+
+// Caches (module-level like the Ruby class variables)
+const logoCache = new Map();
+const warnedLogos = new Set(); // names already warned about (warn-once)
+let logoInstanceCounter = 0;
+
+/**
+ * Resolve a tag argument that may be a variable but should fall back to the
+ * literal when it resolves to a non-string (Ruby's icon/logo/language pattern).
+ */
+function resolveNameArg(ctx, arg) {
+  if (!arg) return null;
+  const resolved = resolveInput(ctx.lookup, arg, true);
+  return typeof resolved === 'string' ? stripQuotes(resolved) : stripQuotes(arg);
+}
+
+// Attribute-position escaping for caller-supplied strings — frontmatter can
+// legitimately carry quotes (e.g. a post title used as the default alt), and
+// an unescaped quote breaks out of the attribute.
+function escapeAttr(value) {
+  return String(value)
+    .replace(/&/g, '&amp;')
+    .replace(/"/g, '&quot;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;');
+}
+
+function readFileIfExists(filePath) {
+  if (!filePath) return null;
+  try {
+    return fs.readFileSync(filePath, 'utf8');
+  } catch {
+    return null;
+  }
+}
+
+// {% omega_logo name %} / {% omega_logo name, type, color %} — inline SVG with
+// instance-unique ID prefixing so repeated logos don't collide
+const omegaLogo = {
+  block: false,
+  render(ctx, markup) {
+    const parts = parseArguments(markup);
+    const logoName = resolveNameArg(ctx, parts[0]);
+    if (!logoName) return '';
+
+    const type = resolveNameArg(ctx, parts[1]) || 'brandmarks';
+    const color = resolveNameArg(ctx, parts[2]) || 'original';
+
+    const rawSvg = loadLogo(ctx, logoName, type, color);
+    if (!rawSvg) return '';
+
+    logoInstanceCounter++;
+    return prefixSvgIds(rawSvg, `${logoName}-${logoInstanceCounter}`);
+  },
+};
+
+function loadLogo(ctx, logoName, type, color) {
+  const logos = (ctx.options && ctx.options.logos) || {};
+  const cacheKey = `${logos.dir || ''}|${type}/${color}/${logoName}`;
+
+  if (logoCache.has(cacheKey)) return logoCache.get(cacheKey);
+
+  let svg = logos.dir && readFileIfExists(path.join(logos.dir, type, color, `${logoName}.svg`));
+  if (!svg) {
+    if (!warnedLogos.has(logoName)) {
+      warnedLogos.add(logoName);
+      console.warn(`[@omega.js/template-kit:media] omega_logo: no SVG found for "${type}/${color}/${logoName}" — rendering the default icon`);
+    }
+    svg = tagMissing(DEFAULT_ICON, `logo:${logoName}`);
+  }
+
+  logoCache.set(cacheKey, svg);
+  return svg;
+}
+
+/**
+ * Stamp the failed slug onto the fallback SVG so the browser can see it: the
+ * dev-only icon audit (web core/js/core/dev-icon-audit.js) scans
+ * [data-omega-icon-missing] and console.errors every miss.
+ * @param {string} svg
+ * @param {string} name
+ * @returns {string}
+ */
+function tagMissing(svg, name) {
+  const safe = String(name || 'unknown').replace(/["<>&]/g, '');
+  return svg.replace('<svg ', `<svg data-omega-icon-missing="${safe}" `);
+}
+
+/**
+ * Prefix all IDs in an SVG (and their url()/href references) to prevent
+ * conflicts when multiple SVGs are inlined on the same page.
+ */
+function prefixSvgIds(svgContent, prefix) {
+  const ids = [...new Set([...svgContent.matchAll(/\bid=["']([^"']+)["']/g)].map((m) => m[1]))];
+  if (!ids.length) return svgContent;
+
+  let result = svgContent;
+  for (const id of ids) {
+    const newId = `${prefix}-${id}`;
+    const escaped = id.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+
+    result = result
+      .replace(new RegExp(`\\bid=(["'])${escaped}\\1`, 'g'), `id="${newId}"`)
+      .replace(new RegExp(`url\\(\\s*#${escaped}\\s*\\)`, 'g'), `url(#${newId})`)
+      .replace(new RegExp(`url\\(\\s*["']#${escaped}["']\\s*\\)`, 'g'), `url(#${newId})`)
+      .replace(new RegExp(`xlink:href=["']#${escaped}["']`, 'g'), `xlink:href="#${newId}"`)
+      .replace(new RegExp(`x:href=["']#${escaped}["']`, 'g'), `href="#${newId}"`)
+      .replace(new RegExp(`\\bhref=["']#${escaped}["']`, 'g'), `href="#${newId}"`);
+  }
+  return result;
+}
+
+/**
+ * Build the responsive image HTML for a source + options (shared by omega_image,
+ * the member/post image-tag properties, and @omega.js/web's markdown image
+ * renderer — one image-markup SSOT).
+ * @param {string} src
+ * @param {object} options - alt/title/class/style/width/height/max_width/webp/loading
+ * @returns {string}
+ */
+function buildImageHtml(src, options = {}) {
+  const isExternal = /^https?:\/\//.test(src);
+  if (isExternal) return buildExternalImage(src, options);
+
+  const rawExtension = path.extname(src);
+  // src is caller-supplied like the options — escape once at derivation;
+  // every interpolation below is attribute-position
+  const srcPath = escapeAttr(rawExtension ? src.slice(0, -rawExtension.length) : src);
+  const extension = escapeAttr(rawExtension);
+  src = escapeAttr(src);
+  const maxWidthRaw = options.max_width || options['max-width'] || false;
+  const maxWidth = maxWidthRaw ? String(maxWidthRaw) : false;
+
+  let html = '<picture>\n';
+  if (options.webp !== 'false' && options.webp !== false) {
+    html += buildWebpSources(srcPath, maxWidth);
+  }
+  html += buildOriginalSources(srcPath, extension, maxWidth, src);
+
+  const alt = escapeAttr(options.alt || '');
+  const title = escapeAttr(options.title || '');
+  const cssClass = escapeAttr(options.class || '');
+  const style = escapeAttr(options.style || '');
+  const width = escapeAttr(options.width || '');
+  const height = escapeAttr(options.height || '');
+
+  html += '<img\n';
+  html += `src="${IMAGE_PLACEHOLDER}"\n`;
+  html += `data-lazy="@src ${src}"\n`;
+  if (cssClass) html += `class="${cssClass}"\n`;
+  html += `alt="${alt}"\n`;
+  if (title) html += `title="${title}"\n`;
+  if (style) html += `style="${style}"\n`;
+  if (width) html += `width="${width}"\n`;
+  if (height) html += `height="${height}"\n`;
+  html += '>\n';
+  html += '</picture>';
+
+  return html;
+}
+
+function buildWebpSources(srcPath, maxWidth) {
+  switch (maxWidth) {
+    case '320':
+      return `<source data-lazy="@srcset ${srcPath}-320px.webp" type="image/webp">\n`;
+    case '640':
+      return `<source data-lazy="@srcset ${srcPath}-320px.webp" media="(max-width: 320px)" type="image/webp">\n`
+        + `<source data-lazy="@srcset ${srcPath}-640px.webp" type="image/webp">\n`;
+    case '1024':
+      return `<source data-lazy="@srcset ${srcPath}-320px.webp" media="(max-width: 320px)" type="image/webp">\n`
+        + `<source data-lazy="@srcset ${srcPath}-640px.webp" media="(max-width: 640px)" type="image/webp">\n`
+        + `<source data-lazy="@srcset ${srcPath}-1024px.webp" type="image/webp">\n`;
+    default:
+      return `<source data-lazy="@srcset ${srcPath}-320px.webp" media="(max-width: 320px)" type="image/webp">\n`
+        + `<source data-lazy="@srcset ${srcPath}-640px.webp" media="(max-width: 640px)" type="image/webp">\n`
+        + `<source data-lazy="@srcset ${srcPath}-1024px.webp" media="(max-width: 1024px)" type="image/webp">\n`
+        + `<source data-lazy="@srcset ${srcPath}.webp" type="image/webp">\n`;
+  }
+}
+
+function buildOriginalSources(srcPath, extension, maxWidth, src) {
+  switch (maxWidth) {
+    case '320':
+      return `<source data-lazy="@srcset ${srcPath}-320px${extension}">\n`;
+    case '640':
+      return `<source data-lazy="@srcset ${srcPath}-320px${extension}" media="(max-width: 320px)">\n`
+        + `<source data-lazy="@srcset ${srcPath}-640px${extension}">\n`;
+    case '1024':
+      return `<source data-lazy="@srcset ${srcPath}-320px${extension}" media="(max-width: 320px)">\n`
+        + `<source data-lazy="@srcset ${srcPath}-640px${extension}" media="(max-width: 640px)">\n`
+        + `<source data-lazy="@srcset ${srcPath}-1024px${extension}">\n`;
+    default:
+      return `<source data-lazy="@srcset ${srcPath}-320px${extension}" media="(max-width: 320px)">\n`
+        + `<source data-lazy="@srcset ${srcPath}-640px${extension}" media="(max-width: 640px)">\n`
+        + `<source data-lazy="@srcset ${srcPath}-1024px${extension}" media="(max-width: 1024px)">\n`
+        + `<source data-lazy="@srcset ${src}" media="(min-width: 1025px)">\n`;
+  }
+}
+
+function buildExternalImage(src, options) {
+  src = escapeAttr(src);
+  const alt = escapeAttr(options.alt || '');
+  const title = escapeAttr(options.title || '');
+  const cssClass = escapeAttr(options.class || '');
+  const style = escapeAttr(options.style || '');
+  const width = escapeAttr(options.width || '');
+  const height = escapeAttr(options.height || '');
+  const loading = escapeAttr(options.loading || 'lazy');
+
+  let html = '<img';
+  html += ` src="${IMAGE_PLACEHOLDER}"`;
+  html += ` data-lazy="@src ${src}"`;
+  if (cssClass) html += ` class="${cssClass}"`;
+  html += ` alt="${alt}"`;
+  if (title) html += ` title="${title}"`;
+  html += ` loading="${loading}"`;
+  if (style) html += ` style="${style}"`;
+  if (width) html += ` width="${width}"`;
+  if (height) html += ` height="${height}"`;
+  html += '>';
+
+  return html;
+}
+
+// {% omega_image "/path.png", alt="...", max_width="640" %}
+const omegaImage = {
+  block: false,
+  render(ctx, markup) {
+    const args = parseArguments(markup);
+    const src = resolveInput(ctx.lookup, args[0], true);
+    if (!src) return '';
+
+    const options = parseOptions(args.slice(1), ctx.lookup);
+    return buildImageHtml(String(src), options);
+  },
+};
+
+// {% omega_video "/path.mp4", autoplay="true", ... %}
+const omegaVideo = {
+  block: false,
+  render(ctx, markup) {
+    const args = parseArguments(markup);
+    const src = resolveInput(ctx.lookup, args[0], true);
+    if (!src) return '';
+
+    const options = parseOptions(args.slice(1), ctx.lookup);
+    return buildVideoHtml(String(src), options);
+  },
+};
+
+function buildVideoHtml(src, options) {
+  const isExternal = /^https?:\/\//.test(src);
+  if (isExternal) return buildExternalVideo(src, options);
+
+  const rawExtension = path.extname(src);
+  // Same attribute-position escaping at derivation as buildImageHtml
+  const srcPath = escapeAttr(rawExtension ? src.slice(0, -rawExtension.length) : src);
+  const extension = escapeAttr(rawExtension);
+  src = escapeAttr(src);
+  const maxWidthRaw = options.max_width || options['max-width'] || false;
+  const maxWidth = maxWidthRaw ? String(maxWidthRaw) : false;
+
+  let html = '<div class="lazy-loading" data-lazy-load-container>\n';
+  html += '<video\n';
+  html += videoAttributes(options, '\n');
+  html += '>\n';
+  html += buildVideoSources(srcPath, extension, maxWidth, src);
+  html += 'Your browser does not support the video tag.\n';
+  html += '</video>\n';
+  html += '</div>';
+
+  return html;
+}
+
+/**
+ * Shared <video> attribute rendering. `sep` is '\n' for local (multi-line)
+ * and '' (leading-space single-line) for external — matching the Ruby output.
+ */
+function videoAttributes(options, sep) {
+  const attr = (text) => (sep === '\n' ? `${text}\n` : ` ${text}`);
+  const flagOn = (value) => value && value !== '' && value !== 'false';
+
+  let html = '';
+  if (options.class) html += attr(`class="${escapeAttr(options.class)}"`);
+  if (options.style) html += attr(`style="${escapeAttr(options.style)}"`);
+  if (options.width) html += attr(`width="${escapeAttr(options.width)}"`);
+  if (options.height) html += attr(`height="${escapeAttr(options.height)}"`);
+  if (flagOn(options.autoplay)) html += attr('autoplay');
+  if (flagOn(options.loop)) html += attr('loop');
+  if (flagOn(options.muted)) html += attr('muted');
+  // controls defaults ON; bare `controls=false` now resolves to boolean false
+  if (options.controls !== 'false' && options.controls !== false) html += attr('controls');
+  if (flagOn(options.playsinline)) html += attr('playsinline');
+  html += attr(`preload="${escapeAttr(options.preload || 'metadata')}"`);
+  if (options.poster) html += attr(`poster="${escapeAttr(options.poster)}"`);
+
+  return html;
+}
+
+function buildVideoSources(srcPath, extension, maxWidth, src) {
+  const mime = getVideoMimeType(extension);
+  switch (maxWidth) {
+    case '320':
+      return `<source data-lazy="@src ${srcPath}-320px${extension}" type="video/${mime}">\n`;
+    case '640':
+      return `<source data-lazy="@src ${srcPath}-320px${extension}" media="(max-width: 320px)" type="video/${mime}">\n`
+        + `<source data-lazy="@src ${srcPath}-640px${extension}" type="video/${mime}">\n`;
+    case '1024':
+      return `<source data-lazy="@src ${srcPath}-320px${extension}" media="(max-width: 320px)" type="video/${mime}">\n`
+        + `<source data-lazy="@src ${srcPath}-640px${extension}" media="(max-width: 640px)" type="video/${mime}">\n`
+        + `<source data-lazy="@src ${srcPath}-1024px${extension}" type="video/${mime}">\n`;
+    default:
+      return `<source data-lazy="@src ${srcPath}-320px${extension}" media="(max-width: 320px)" type="video/${mime}">\n`
+        + `<source data-lazy="@src ${srcPath}-640px${extension}" media="(max-width: 640px)" type="video/${mime}">\n`
+        + `<source data-lazy="@src ${srcPath}-1024px${extension}" media="(max-width: 1024px)" type="video/${mime}">\n`
+        + `<source data-lazy="@src ${src}" media="(min-width: 1025px)" type="video/${mime}">\n`;
+  }
+}
+
+function buildExternalVideo(src, options) {
+  let html = '<div class="lazy-loading" data-lazy-load-container>';
+  html += '<video';
+  html += videoAttributes(options, '');
+  html += '>';
+
+  const mime = getVideoMimeType(path.extname(src));
+  html += `<source data-lazy="@src ${escapeAttr(src)}" type="video/${mime}">`;
+  html += 'Your browser does not support the video tag.';
+  html += '</video>';
+  html += '</div>';
+
+  return html;
+}
+
+function getVideoMimeType(extension) {
+  switch (String(extension).toLowerCase()) {
+    case '.mp4': return 'mp4';
+    case '.webm': return 'webm';
+    case '.ogg':
+    case '.ogv': return 'ogg';
+    case '.mov': return 'quicktime';
+    case '.avi': return 'x-msvideo';
+    default: return 'mp4';
+  }
+}
+
+module.exports = {
+  omegaLogo,
+  omegaImage,
+  omegaVideo,
+  buildImageHtml,
+  buildExternalImage,
+  DEFAULT_ICON,
+  IMAGE_PLACEHOLDER,
+};