@videinfra/static-website-builder 2.0.9 → 2.1.0

package/CHANGELOG.md

@@ -4,6 +4,11 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/)
 and this project adheres to [Semantic Versioning](http://semver.org/).
 
+## [2.1.0] - 2026-03-04
+### Changed
+- Updated gulp-sass to use sass-embedded instead of sass
+- Updated gulp-sass to remove legacy code and use only sync mode
+
 ## [2.0.9] - 2026-02-19
 ### Fixed
 - Removed file extension from the sitemap URLs

package/init/test/src/stylesheets/env-test.scss

@@ -1,13 +1,15 @@
+@use 'sass:map';
+
 .env-test:before {
-    content: map-get($env, host);
+    content: map.get($env, host);
 }
 
 :root {
-    #{ --env-test-type-number }: map-get($env, typeNumber);
-    #{ --env-test-type-empty }: map-get($env, typeEmpty);
+    #{ --env-test-type-number }: map.get($env, typeNumber);
+    #{ --env-test-type-empty }: map.get($env, typeEmpty);
 }
 
-@if map-get($env, typeBoolTrue) {
+@if map.get($env, typeBoolTrue) {
     :root {
         --env-test-bool-true: true;
     }
@@ -17,7 +19,7 @@
     }
 }
 
-@if map-get($env, typeBoolFalse) {
+@if map.get($env, typeBoolFalse) {
     :root {
         --env-test-bool-false: true;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@videinfra/static-website-builder",
-  "version": "2.0.9",
+  "version": "2.1.0",
   "description": "Customizable static site project builder",
   "license": "MIT",
   "engines": {
@@ -58,7 +58,7 @@
     "minimist": "^1.2.8",
     "nano-memoize": "3.0.16",
     "rolldown": "^1.0.0-rc.1",
-    "sass": "^1.97.3",
+    "sass-embedded": "^1.97.3",
     "through": "^2.3.8",
     "twig": "^1.17.1"
   },

package/plugins/sass-engine/preprocess-config.js

@@ -4,7 +4,7 @@ import merge from './../../lib/merge.js';
 import getEnvData from './../../tasks/env/get-env.js';
 import gulpSass from '../../vendor/gulp-sass/index.js';
 import assign from 'lodash/assign.js';
-import * as sass from 'sass';
+import * as sass from 'sass-embedded';
 
 /**
  * Modify configuration
@@ -32,7 +32,15 @@ export default function processSASSConfig(config, fullConfig) {
         });
 
         // Engine is a function which returns a gulp pipe function
-        config.engine = function getSASSEngine() {
+        config._engineCache = null;
+        config.engine = function getSASSEngine(disposeOnly = false) {
+            if (config._engineCache) {
+                config._engineCache.dispose();
+            }
+            if (disposeOnly) {
+                return;
+            }
+
             const sassEngine = gulpSass(sass);
             const sassConfig = getTaskConfig('stylesheets', 'sass');
 
@@ -41,7 +49,10 @@ export default function processSASSConfig(config, fullConfig) {
             }
 
             sassConfig.data = merge(getEnvData().sass, sassConfig.data || {});
-            return sassEngine(sassConfig, /* sync */ true).on('error', sassEngine.logError);
+            config._engineCache = sassEngine(sassConfig).on('error', sassEngine.logError);
+            config._engineCache.dispose = sassEngine.dispose;
+
+            return config._engineCache;
         };
 
         // Main 'dependents' config is shared between all tasks

package/tasks/sitemap/task.js

@@ -2,7 +2,7 @@ import gulp from 'gulp';
 import gulpif from 'gulp-if';
 import nanomemoize from 'nano-memoize';
 import ignore from 'gulp-ignore';
-import gulpSitemap from 'gulp-sitemap';
+import gulpSitemap from '../../vendor/gulp-sitemap/index.js';
 
 import { getDestPath } from './../../lib/get-path.js';
 import { getTaskConfig } from './../../lib/get-config.js';

package/tasks/stylesheets/task.js

@@ -33,13 +33,13 @@ const getGlobPaths = nanomemoize.nanomemoize(function () {
 });
 
 
-const getEngine = function () {
+const getEngine = function (disposeOnly = false) {
     const engine = getTaskConfig('stylesheets', 'engine');
-    return engine ? engine() : (() => {});
+    return engine ? engine(disposeOnly) : (() => {});
 };
 
 
-function stylesheets () {
+function stylesheetsBuild () {
     return gulp.src(getGlobPaths())
         .pipe(taskStart())
 
@@ -65,9 +65,14 @@ function stylesheets () {
 }
 
 function stylesheetsWatch () {
-    return taskWatch(getWatchGlobPaths(true), stylesheets);
+    return taskWatch(getWatchGlobPaths(true), stylesheetsBuild);
+}
+
+function stylesheetsBuildEnd () {
+    getEngine(true);
+    return Promise.resolve();
 }
 
 
-export const build = stylesheets;
+export const build = gulp.series(stylesheetsBuild, stylesheetsBuildEnd);
 export const watch = stylesheetsWatch;

package/vendor/gulp-sass/index.js

@@ -1,4 +1,6 @@
 // 2025-01-20, Kaspars Zuks: added "options.data" support for variables
+// 2026-03-04, Kaspars Zuks: updated to use "compileString" instead of "renderSync"
+// 2026-03-04, Kaspars Zuks: removed async version
 'use strict';
 
 import path from 'path';
@@ -8,54 +10,17 @@ import PluginError from 'plugin-error';
 import replaceExtension from 'replace-ext';
 import stripAnsi from 'strip-ansi';
 import clonedeep from 'lodash.clonedeep';
-import applySourceMap from 'vinyl-sourcemaps-apply';
 import sassStingify from './sass-stringify.js';
 
 const PLUGIN_NAME = 'gulp-sass';
 
-const MISSING_COMPILER_MESSAGE = `
-gulp-sass no longer has a default Sass compiler; please set one yourself.
-Both the "sass" and "node-sass" packages are permitted.
-For example, in your gulpfile:
-
-  import * as sass from 'sass';
-  import gulpSass from 'gulp-sass';
-  const instance = gulpSass(sass);
-`;
-
 const transfob = (transform) => new Transform({ transform, objectMode: true });
 
 /**
  * Handles returning the file to the stream
  */
-const filePush = (file, sassObject, callback) => {
-    // Build Source Maps!
-    if (sassObject.map) {
-        // Transform map into JSON
-        const sassMap = JSON.parse(sassObject.map.toString());
-        // Grab the stdout and transform it into stdin
-        const sassMapFile = sassMap.file.replace(/^stdout$/, 'stdin');
-        // Grab the base filename that's being worked on
-        const sassFileSrc = file.relative;
-        // Grab the path portion of the file that's being worked on
-        const sassFileSrcPath = path.dirname(sassFileSrc);
-
-        if (sassFileSrcPath) {
-            const sourceFileIndex = sassMap.sources.indexOf(sassMapFile);
-            // Prepend the path to all files in the sources array except the file that's being worked on
-            sassMap.sources = sassMap.sources.map((source, index) => (index === sourceFileIndex ? source : path.join(sassFileSrcPath, source)));
-        }
-
-        // Remove 'stdin' from souces and replace with filenames!
-        sassMap.sources = sassMap.sources.filter((src) => src !== 'stdin' && src);
-
-        // Replace the map file with the original filename (but new extension)
-        sassMap.file = replaceExtension(sassFileSrc, '.css');
-        // Apply the map
-        applySourceMap(file, sassMap);
-    }
-
-    file.contents = sassObject.css;
+const filePush = (file, css, callback) => {
+    file.contents = css;
     file.path = replaceExtension(file.path, '.css');
 
     if (file.stat) {
@@ -81,32 +46,13 @@ const handleError = (error, file, callback) => {
     return callback(new PluginError(PLUGIN_NAME, error));
 };
 
-/**
- * Escape SCSS variable value for output in SCSS
- * @param {any} value Value
- * @returns {string} Escaped value
- */
-const escapeSCSSVariable = (value) => {
-    if (value !== '' && (value === true || value === false || !isNaN(value))) {
-        return String(value);
-    } else {
-        // Convert to string
-        return "'" + value.toString().replace(/\\/g, '\\\\').replace(/'/g, "\\'").replace(/\n/g, '\\n') + "'";
-    }
-};
-
 /**
  * Main Gulp Sass function
  */
 
 // eslint-disable-next-line arrow-body-style
-const gulpSass = (options, sync) => {
+const gulpSass = (options) => {
     return transfob((file, encoding, callback) => {
-        if (file.isNull()) {
-            callback(null, file);
-            return;
-        }
-
         if (file.isStream()) {
             callback(new PluginError(PLUGIN_NAME, 'Streaming not supported'));
             return;
@@ -117,23 +63,21 @@ const gulpSass = (options, sync) => {
             return;
         }
 
-        if (!file.contents.length) {
+        if (file.contents && !file.contents.length) {
             file.path = replaceExtension(file.path, '.css');
             callback(null, file);
             return;
         }
 
         const opts = clonedeep(options || {});
-        opts.data = file.contents.toString();
+        let source = file.contents.toString();
 
         // Stringiyfy variables
-        if (options.data) {
-            opts.data = sassStingify(options.data) + opts.data;
+        if (opts.data) {
+            source = sassStingify(opts.data) + source;
+            delete(opts.data);
         }
 
-        // We set the file path here so that libsass can correctly resolve import paths
-        opts.file = file.path;
-
         // Ensure `indentedSyntax` is true if a `.sass` file
         if (path.extname(file.path) === '.sass') {
             opts.indentedSyntax = true;
@@ -150,59 +94,35 @@ const gulpSass = (options, sync) => {
 
         opts.includePaths.unshift(path.dirname(file.path));
 
-        // Generate Source Maps if the source-map plugin is present
-        if (file.sourceMap) {
-            opts.sourceMap = file.path;
-            opts.omitSourceMapUrl = true;
-            opts.sourceMapContents = true;
-        }
+        // Rename `includePaths` to `loadPaths`
+        opts.loadPaths = opts.includePaths;
+        delete(opts.includePaths);
 
-        if (sync !== true) {
-            /**
-             * Async Sass render
-             */
-            gulpSass.compiler.render(opts, (error, obj) => {
-                if (error) {
-                    handleError(error, file, callback);
-                    return;
-                }
-
-                filePush(file, obj, callback);
-            });
-        } else {
-            /**
-             * Sync Sass render
-             */
-            try {
-                filePush(file, gulpSass.compiler.renderSync(opts), callback);
-            } catch (error) {
-                handleError(error, file, callback);
-            }
+        try {
+            const result = gulpSass.compiler.compileString(source, opts);
+            filePush(file, Buffer.from(result.css, 'utf8'), callback);
+        } catch (error) {
+            handleError(error, file, callback);
         }
     });
 };
 
-/**
- * Sync Sass render
- */
-gulpSass.sync = (options) => gulpSass(options, true);
-
 /**
  * Log errors nicely
  */
 gulpSass.logError = function logError(error) {
-    const message = new PluginError('sass', error.messageFormatted).toString();
+    const message = new PluginError('sass', error.messageFormatted || error.message).toString();
     process.stderr.write(`${message}\n`);
     this.emit('end');
 };
 
-export default (compiler) => {
-    if (!compiler || !compiler.render) {
-        const message = new PluginError(PLUGIN_NAME, MISSING_COMPILER_MESSAGE, { showProperties: false }).toString();
-        process.stderr.write(`${message}\n`);
-        process.exit(1);
+gulpSass.dispose = function () {
+    if (gulpSass.compiler.dispose) {
+        gulpSass.compiler.dispose();
     }
+}
 
-    gulpSass.compiler = compiler;
+export default (compiler) => {
+    gulpSass.compiler = compiler.initCompiler();
     return gulpSass;
 };

package/vendor/gulp-sass/package.json

@@ -55,7 +55,7 @@
     "node-sass": "^7.0.1",
     "postcss": "^8.4.5",
     "rimraf": "^3.0.2",
-    "sass": "^1.45.1",
+    "sass-embedded": "^1.97.3",
     "vinyl": "^2.2.1"
   }
 }

package/vendor/gulp-sitemap/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) Gilad Peleg <gilad@giladpeleg.com> (https://www.giladpeleg.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/vendor/gulp-sitemap/README.md

@@ -0,0 +1,293 @@
+# [gulp](https://github.com/wearefractal/gulp)-sitemap
+> Generate a search engine friendly sitemap.xml using a Gulp stream
+
+[![NPM version](http://img.shields.io/npm/v/gulp-sitemap.svg?style=flat)](https://www.npmjs.org/package/gulp-sitemap)
+[![NPM Downloads](http://img.shields.io/npm/dm/gulp-sitemap.svg?style=flat)](https://www.npmjs.org/package/gulp-sitemap)
+[![Build Status](http://img.shields.io/travis/pgilad/gulp-sitemap/master.svg?style=flat)](https://travis-ci.org/pgilad/gulp-sitemap)
+
+Easily generate a search engine friendly sitemap.xml from your project.
+
+:bowtie: Search engines love the sitemap.xml and it helps SEO as well.
+
+For information about sitemap properties and structure, see the [wiki for sitemaps](http://www.wikiwand.com/en/Sitemaps)
+
+## Install
+
+Install with [npm](https://npmjs.org/package/gulp-sitemap)
+
+```bash
+$ npm install --save-dev gulp-sitemap
+```
+
+## Example
+
+```js
+var gulp = require('gulp');
+var sitemap = require('gulp-sitemap');
+
+gulp.task('sitemap', function () {
+    gulp.src('build/**/*.html', {
+            read: false
+        })
+        .pipe(sitemap({
+            siteUrl: 'http://www.amazon.com'
+        }))
+        .pipe(gulp.dest('./build'));
+});
+```
+
+* `siteUrl` is required.
+* `index.html` will be turned into directory path `/`.
+* `404.html` will be skipped automatically. No need to unglob it.
+
+Let's see an example of how we can create and output a sitemap, and then return to the original stream files:
+```js
+var gulp = require('gulp');
+var sitemap = require('gulp-sitemap');
+var save = require('gulp-save');
+
+gulp.task('html', function() {
+    gulp.src('*.html', {
+          read: false
+        })
+        .pipe(save('before-sitemap'))
+        .pipe(sitemap({
+                siteUrl: 'http://www.amazon.com'
+        })) // Returns sitemap.xml
+        .pipe(gulp.dest('./dist'))
+        .pipe(save.restore('before-sitemap')) //restore all files to the state when we cached them
+        // -> continue stream with original html files
+        // ...
+});
+```
+
+## Options
+
+### siteUrl
+
+Your website's base url. This gets prepended to all documents locations.
+
+Type: `string`
+
+Required: `true`
+
+### fileName
+
+Determine the output filename for the sitemap.
+
+Type: `string`
+
+Default: `sitemap.xml`
+
+Required: `false`
+
+### changefreq
+
+Gets filled inside the sitemap in the tag `<changefreq>`. Not added by default.
+
+Type: `string`
+
+Default: `undefined`
+
+Valid Values: `['always', 'hourly', 'daily', 'weekly', 'monthly', 'yearly', 'never']`
+
+Required: `false`
+
+**Note: any falsey value is also valid and will skip this xml tag**
+
+### priority
+
+Gets filled inside the sitemap in the tag `<priority>`. Not added by default.
+
+Type: `string|function`
+
+Default: `undefined`
+
+Valid Values: `0.0` to `1.0`
+
+Required: `false`
+
+**Note: any falsey (non-zero) value is also valid and will skip this xml tag**
+
+Example using a function as `priority`:
+
+
+```js
+priority: function(siteUrl, loc, entry) {
+    // Give pages inside root path (i.e. no slashes) a higher priority
+    return loc.split('/').length === 0 ? 1 : 0.5;
+}
+```
+
+### lastmod
+
+The file last modified time.
+
+- If `null` then this plugin will try to get the last modified time from the stream vinyl file, or use `Date.now()` as lastmod.
+- If the value is not `null` - It will be used as lastmod.
+- When `lastmod` is a function, it is executed with the current file given as parameter. (Note: the function is expected to be sync).
+- A string can be used to manually set a fixed `lastmod`.
+
+Type: `string|datetime|function`
+
+Default: `null`
+
+Required: `false`
+
+Example that uses git to get lastmod from the latest commit of a file:
+
+```js
+lastmod: function(file) {
+  var cmd = 'git log -1 --format=%cI "' + file.relative + '"';
+  return execSync(cmd, {
+    cwd: file.base
+  }).toString().trim();
+}
+```
+
+**Note: any falsey (other than null) value is also valid and will skip this xml tag**
+
+### newLine
+
+How to join line in the target sitemap file.
+
+Type: `string`
+
+Default: Your OS's new line, mostly: `\n`
+
+Required: `false`
+
+### spacing
+
+How should the sitemap xml file be spaced. You can use `\t` for tabs, or `  ` with 2
+spaces if you'd like.
+
+Type: `string`
+
+Default: `    ` (4 spaces)
+
+Required: `false`
+
+### noindex
+
+Exclude pages from the sitemap when the `robots` meta tag is set to `noindex`. The plugin needs to be able to read the contents of the files for this to have an effect.
+
+Type: `boolean`
+
+Default: `false`
+
+Required: `false`
+
+### images
+
+For generate sitemap for images per page, just enable images flag to `true`
+
+Type: `boolean`
+
+Default: `undefined`
+
+Required: `false`
+
+
+### mappings
+
+An object to custom map pages to their own configuration.
+
+This should be an array with the following structure:
+
+Type: `array`
+
+Default: `[]`
+
+Required: `false`
+
+Example:
+
+```js
+mappings: [{
+    pages: [ 'minimatch pattern' ],
+    changefreq: 'hourly',
+    priority: 0.5,
+    lastmod: Date.now(),
+    getLoc(siteUrl, loc, entry) {
+        // Removes the file extension if it exists
+        return loc.replace(/\.\w+$/, '');
+    },
+    hreflang: [{
+        lang: 'ru',
+        getHref(siteUrl, file, lang, loc) {
+            return 'http://www.amazon.ru/' + file;
+        }
+    }]
+},
+//....
+]
+```
+
+- Every file will be matched against the supplied patterns
+- Only defined attributes for a matched file are applied.
+- Only the first match will apply, so consequent matches for the filename will not apply.
+- Possible attributes to set: `hreflang`, `changefreq`, `priority`, `loc` and `lastmod`.
+- All rules applying to [options](#options) apply to the attributes that can overridden.
+
+##### pages
+
+Type: `array`
+
+Required: `true`
+
+This is an array with [minimatch](https://github.com/isaacs/minimatch) patterns to match the
+relevant pages to override.
+Every file will be matched against the supplied patterns.
+
+Uses [multimatch](https://github.com/sindresorhus/multimatch) to match patterns against filenames.
+
+Example: `pages: ['home/index.html', 'home/see-*.html', '!home/see-admin.html']`
+
+##### hreflang
+
+Matching pages can get their `hreflang` tags set using this option.
+
+The input is an array like so:
+
+```js
+hreflang: [{
+    lang: 'ru',
+    getHref: function(siteUrl, file, lang, loc) {
+        // return href src for the hreflang. For example:
+        return 'http://www.amazon.ru/' + file;
+    }
+}]
+```
+
+##### getLoc
+
+Matching pages can get their `loc` tag modified by using a function.
+
+```js
+getLoc: function(siteUrl, loc, entry) {
+    return loc.replace(/\.\w+$/, '');
+}
+```
+
+#### verbose
+
+Type: `boolean`
+
+Required: `false`
+
+Default: `false`
+
+If true, will log the number of files that where handled.
+
+## Complementary plugins
+
+- [gulp-sitemap-files](https://github.com/adam-lynch/gulp-sitemap-files) - Get all files listed in a sitemap (Perhaps one generated from this plugin)
+
+## Thanks
+
+To [grunt-sitemap](https://github.com/RayViljoen/grunt-sitemap) for the inspiration on writing this.
+
+## License
+
+MIT © [Gilad Peleg](https://www.giladpeleg.com)

package/vendor/gulp-sitemap/index.js

@@ -0,0 +1,91 @@
+'use strict';
+const chalk = require('chalk');
+const defaults = require('lodash/defaults');
+const log = require('fancy-log');
+const path = require('path');
+const PluginError = require('plugin-error');
+const through = require('through2');
+const Vinyl = require('vinyl');
+
+const pluginName = 'gulp-sitemap';
+const sitemap = require('./lib/sitemap');
+
+module.exports = function (options = {}) {
+    const config = defaults({}, options, {
+        changefreq: undefined,
+        fileName: 'sitemap.xml',
+        lastmod: null,
+        mappings: [],
+        newLine: '\n',
+        priority: undefined,
+        spacing: '    ',
+        verbose: false,
+        noindex: false
+    });
+    const entries = [];
+    let firstFile;
+    let msg;
+
+    if (!config.siteUrl) {
+        msg = 'siteUrl is a required param';
+        throw new PluginError(pluginName, msg);
+    }
+    if (options.changeFreq) {
+        msg = chalk.magenta('changeFreq') + ' has been deprecated. Please use ' + chalk.cyan('changefreq');
+        throw new PluginError(pluginName, msg);
+    }
+    // site url should have a trailing slash
+    if (config.siteUrl.slice(-1) !== '/') {
+        config.siteUrl = config.siteUrl + '/';
+    }
+
+    return through.obj(function (file, enc, callback) {
+            //we handle null files (that have no contents), but not dirs
+            if (file.isDirectory()) {
+                return callback(null, file);
+            }
+
+            if (file.isStream()) {
+                msg = 'Streaming not supported';
+                return callback(new PluginError(pluginName), msg);
+            }
+
+            //skip 404 file
+            if (/404\.html?$/i.test(file.relative)) {
+                return callback();
+            }
+
+            if(options.noindex){
+                const contents = file.contents.toString();
+                if (/<meta [^>]*?noindex/i.test(contents)) {
+                    return callback();
+                }
+            }
+
+            if (!firstFile) {
+                firstFile = file;
+            }
+
+            const entry = sitemap.getEntryConfig(file, config);
+            entries.push(entry);
+            callback();
+        },
+        function (callback) {
+            if (!firstFile) {
+                return callback();
+            }
+            const contents = sitemap.prepareSitemap(entries, config);
+            if (options.verbose) {
+                msg = 'Files in sitemap: ' + entries.length;
+                log(pluginName, msg);
+            }
+            //create and push new vinyl file for sitemap
+            this.push(new Vinyl({
+                cwd: firstFile.cwd,
+                base: firstFile.cwd,
+                path: path.join(firstFile.cwd, config.fileName),
+                contents: Buffer.from(contents)
+            }));
+            callback();
+        });
+};

package/vendor/gulp-sitemap/lib/sitemap.js

@@ -0,0 +1,207 @@
+/**
+ * Changes by Kaspars Zuks:
+ * - Removed xmlns:image attribute from `urlset` if images is false
+ */
+'use strict';
+const fs = require('fs');
+const defaults = require('lodash/defaults');
+const find = require('lodash/find');
+const includes = require('lodash/includes');
+const multimatch = require('multimatch');
+const slash = require('slash');
+const pick = require('lodash/pick');
+
+const header = [
+    '<?xml version="1.0" encoding="UTF-8"?>',
+    '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">'
+];
+
+const headerHref = [
+    '<?xml version="1.0" encoding="UTF-8"?>',
+    '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9" xmlns:xhtml="http://www.w3.org/1999/xhtml">'
+];
+
+const footer = ['</urlset>'];
+const allowedProperties = ['getLoc', 'lastmod', 'priority', 'changefreq', 'hreflang'];
+
+function getEntryConfig(file, siteConfig) {
+    const relativePath = file.relative;
+    const mappingsForFile = find(siteConfig.mappings, function(item) {
+        return multimatch(relativePath, item.pages).length > 0;
+    }) || {};
+
+    const entry = defaults(
+        {},
+        pick(mappingsForFile, allowedProperties),
+        pick(siteConfig, allowedProperties)
+    );
+
+    // if images enabled add headerHref
+    if (siteConfig.images) {
+        header[1] = '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9" xmlns:image="http://www.google.com/schemas/sitemap-image/1.1">';
+        headerHref[1] = '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9" xmlns:xhtml="http://www.w3.org/1999/xhtml" xmlns:image="http://www.google.com/schemas/sitemap-image/1.1">'
+    }
+
+    if (entry.lastmod === null) {
+        // calculate mtime manually
+        entry.lastmod = file.stat && file.stat.mtime || Date.now();
+    } else if (typeof entry.lastmod === 'function') {
+        entry.lastmod = entry.lastmod(file);
+    }
+
+    //turn index.html into -> /
+    let relativeFile = relativePath.replace(/(\/|\\|^)index\.html?$/, '/');
+    if (relativeFile === '/') {
+        relativeFile = '';
+    }
+    //url location. Use slash to convert windows \\ or \ to /
+    const adjustedFile = slash(relativeFile);
+    entry.loc = siteConfig.siteUrl + adjustedFile;
+    entry.file = adjustedFile;
+    entry.source = file.history[0];
+
+    return entry;
+}
+
+function wrapTag(tag, value) {
+    return `
+        <${ tag }>${ value }</${ tag }>
+    `;
+}
+
+function createImageSitemap(imageURL) {
+    return `
+        <image:image>
+            <image:loc>${imageURL}</image:loc>
+        </image:image>
+    `;
+}
+
+function notIsHTTPURL(text) {
+    return !(/https?:\/\//ig).test(text);
+}
+
+function getImagesUrl(entry, siteConfig) {
+    const reImageMatch = /<img\s+src="((https?:\/\/)?[\w\.\/\-@\?=&]+)"/ig;
+    const reSourceMatch = /"((https?:\/\/)?[\w\.\/\-@\?=&]+)"/ig;
+    const html = fs.readFileSync(entry.source, { encoding : 'utf8'})
+    const images = html.match(reImageMatch);
+
+    if (images === null) {
+        return [];
+    }
+
+    const URLs = images.map(image => {
+        let currentURL = image.match(reSourceMatch)[0].replace(/^\"|\"$/ig, '');
+
+        if (notIsHTTPURL(currentURL)) {
+            currentURL = currentURL.replace(/^\/|\.\//, '');
+            currentURL = siteConfig.siteUrl + currentURL;
+        }
+
+        return currentURL;
+    });
+
+    return URLs;
+}
+
+function generateImagesMap(entry, siteConfig) {
+    let imagesURLS = [];
+    let XMLImageList = '';
+
+    // Crawling page for images
+    imagesURLS = getImagesUrl(entry, siteConfig);
+
+    // if truthy create image sitemap
+    if (imagesURLS.length) {
+        XMLImageList = imagesURLS.map(imageURL => createImageSitemap(imageURL)).join('')
+    }
+
+    return XMLImageList;
+}
+
+/**
+ * processEntry
+ *
+ * @param entry
+ * @param siteConfig
+ * @return {string}
+ */
+function processEntry(entry, siteConfig) {
+    const returnArr = [siteConfig.spacing + '<url>'];
+
+    const loc = entry.getLoc ? entry.getLoc(siteConfig.siteUrl, entry.loc, entry) : entry.loc;
+    returnArr.push(siteConfig.spacing + siteConfig.spacing + wrapTag('loc', loc) + (siteConfig.images ? generateImagesMap(entry, siteConfig) : ''));
+
+    let lastmod = entry.lastmod;
+    if (lastmod) {
+        //format mtime to ISO (same as +00:00)
+        lastmod = new Date(lastmod).toISOString();
+        returnArr.push(siteConfig.spacing + siteConfig.spacing + wrapTag('lastmod', lastmod));
+    }
+
+    const changefreq = entry.changefreq;
+    if (changefreq) {
+        returnArr.push(siteConfig.spacing + siteConfig.spacing + wrapTag('changefreq', changefreq));
+    }
+
+    let priority;
+
+    if (typeof entry.priority === 'function') {
+        priority = entry.priority(siteConfig.siteUrl, entry.loc, entry);
+    } else if (typeof entry.priority !== 'undefined') {
+        priority = entry.priority;
+    }
+    if (typeof priority !== 'undefined') {
+        returnArr.push(siteConfig.spacing + siteConfig.spacing + wrapTag('priority', priority));
+    }
+
+    const hreflang = entry.hreflang;
+    if (hreflang && hreflang.length > 0) {
+        const file = entry.file;
+        hreflang.forEach(function(item) {
+            const href = item.getHref(siteConfig.siteUrl, file, item.lang, loc);
+            const tag = '<xhtml:link rel="alternate" hreflang="' + item.lang + '" href="' + href + '" />';
+            returnArr.push(siteConfig.spacing + siteConfig.spacing + tag);
+        });
+    }
+
+    returnArr.push(siteConfig.spacing + '</url>');
+    return returnArr.join(siteConfig.newLine);
+}
+
+function prepareSitemap(entries, config) {
+    const entriesHref = entries.some(function(entry) {
+        return entry && entry.hreflang && entry.hreflang.length;
+    });
+    return (entriesHref ? headerHref : header)
+        .concat(entries.map(function(entry) {
+            return processEntry(entry, config);
+        }))
+        .concat(footer)
+        .join(config.newLine)
+        .toString();
+}
+
+const VALID_CHANGE_FREQUENCIES = [
+    'always',
+    'hourly',
+    'daily',
+    'weekly',
+    'monthly',
+    'yearly',
+    'never'
+];
+
+function isChangefreqValid(changefreq) {
+    // empty changefreq is valid
+    if (!changefreq) {
+        return true;
+    }
+    return includes(VALID_CHANGE_FREQUENCIES, changefreq.toLowerCase());
+}
+
+exports.getEntryConfig = getEntryConfig;
+exports.isChangefreqValid = isChangefreqValid;
+exports.prepareSitemap = prepareSitemap;
+exports.processEntry = processEntry;

package/vendor/gulp-sitemap/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "gulp-sitemap",
+  "version": "8.0.0",
+  "description": "Generate a search engine friendly sitemap.xml using a Gulp stream",
+  "repository": "pgilad/gulp-sitemap",
+  "license": "MIT",
+  "author": "Gilad Peleg <gilad@giladpeleg.com> (https://www.giladpeleg.com)",
+  "main": "index.js",
+  "files": [
+    "index.js",
+    "lib"
+  ],
+  "engines": {
+    "node": ">=10"
+  },
+  "scripts": {
+    "test": "mocha -R spec test/*.spec.js"
+  },
+  "keywords": [
+    "gulpplugin",
+    "gulp",
+    "js",
+    "javascript",
+    "SEO",
+    "sitemap",
+    "sitemap.xml",
+    "Google",
+    "search-engine",
+    "xml"
+  ],
+  "dependencies": {
+    "chalk": "^2.4.2",
+    "fancy-log": "^1.3.3",
+    "lodash": "^4.17.15",
+    "multimatch": "^4.0.0",
+    "plugin-error": "^1.0.1",
+    "slash": "^3.0.0",
+    "through2": "^3.0.1",
+    "vinyl": "^2.2.0"
+  },
+  "devDependencies": {
+    "gulp": "^4.0.2",
+    "gulp-rename": "^1.4.0",
+    "mocha": "^6.2.2",
+    "should": "^13.2.3",
+    "strip-ansi": "^5.2.0"
+  }
+}