cloudstructs 0.9.8 → 0.9.10

package/node_modules/juice/LICENSE.md

@@ -0,0 +1,21 @@
+# MIT License
+
+Copyright (c) 2021 Automattic
+
+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/node_modules/juice/README.md

@@ -0,0 +1,201 @@
+[![Build Status](https://travis-ci.org/Automattic/juice.svg?branch=master)](https://travis-ci.org/Automattic/juice)
+[![Dependency Status](https://david-dm.org/Automattic/juice.svg)](https://david-dm.org/Automattic/juice)
+
+# Juice ![](https://i.imgur.com/jN8Ht.gif)
+
+Given HTML, juice will inline your CSS properties into the `style` attribute.
+
+[Some projects using Juice](PROJECTS.md)
+
+## How to use
+
+Juice has a number of functions based on whether you want to process a file, HTML string, or a cheerio document, and whether you want juice to automatically get remote stylesheets, scripts and image dataURIs to inline.
+
+To inline HTML without getting remote resources, using default options:
+
+```js
+var juice = require('juice');
+var result = juice("<style>div{color:red;}</style><div/>");
+```
+
+result will be:
+```html
+<div style="color: red;"></div>
+```
+
+[Try out the web client version](https://automattic.github.io/juice/)
+
+## What is this useful for ?
+
+- HTML emails. For a comprehensive list of supported selectors see [here](https://www.campaignmonitor.com/css/)
+- Embedding HTML in 3rd-party websites.
+
+## Documentation
+
+Juice is exposed as a standard module, and from CLI with a smaller set of options.
+
+### Options
+
+All juice methods take an options object that can contain any of these properties, though not every method uses all of these:
+
+* `applyAttributesTableElements` - whether to create attributes for styles in `juice.styleToAttribute` on elements set in `juice.tableElements`. Defaults to `true`.
+
+* `applyHeightAttributes` - whether to use any CSS pixel heights to create `height` attributes on elements set in `juice.heightElements`. Defaults to `true`.
+
+* `applyStyleTags` - whether to inline styles in `<style></style>` Defaults to `true`.
+
+* `applyWidthAttributes` - whether to use any CSS pixel widths to create `width` attributes on elements set in `juice.widthElements`. Defaults to `true`.
+
+* `extraCss` - extra css to apply to the file. Defaults to `""`.
+
+* `insertPreservedExtraCss` - whether to insert into the document any preserved `@media` or `@font-face` content from `extraCss` when using `preserveMediaQueries`, `preserveFontFaces` or `preserveKeyFrames`. When `true` order of preference to append the `<style>` element is into `head`, then `body`, then at the end of the document. When a `string` the value is treated as a CSS/jQuery/cheerio selector, and when found, the `<style>` tag will be appended to the end of the first match. Defaults to `true`.
+
+* `inlinePseudoElements` - Whether to insert pseudo elements (`::before` and `::after`) as `<span>` into the DOM. *Note*: Inserting pseudo elements will modify the DOM and may conflict with CSS selectors elsewhere on the page (e.g., `:last-child`).
+
+* `preserveFontFaces` - preserves all `@font-face` within `<style></style>` tags as a refinement when `removeStyleTags` is `true`. Other styles are removed. Defaults to `true`.
+
+* `preserveImportant` - preserves `!important` in values. Defaults to `false`.
+
+* `preserveMediaQueries` - preserves all media queries (and contained styles) within `<style></style>` tags as a refinement when `removeStyleTags` is `true`. Other styles are removed. Defaults to `true`.
+
+* `preserveKeyFrames` - preserves all key frames within `<style></style>` tags as a refinement when `removeStyleTags` is `true`. Other styles are removed. Defaults to `true`.
+
+* `preservePseudos` - preserves all rules containing pseudo selectors defined in `ignoredPseudos` within `<style></style>` tags as a refinement when `removeStyleTags` is `true`. Other styles are removed. Defaults to `true`.
+
+* `removeStyleTags` - whether to remove the original `<style></style>` tags after (possibly) inlining the css from them. Defaults to `true`.
+
+* `resolveCSSVariables` - whether to resolve CSS variables. Defaults to `true`.
+
+* `webResources` - An options object that will be passed to [web-resource-inliner](https://www.npmjs.com/package/web-resource-inliner) for juice functions that will get remote resources (`juiceResources` and `juiceFile`). Defaults to `{}`.
+
+* `xmlMode` - whether to output XML/XHTML with all tags closed. Note that the input *must* also be valid XML/XHTML or you will get undesirable results. Defaults to `false`.
+
+
+### Methods
+
+#### juice(html [, options])
+
+Returns string containing inlined HTML. Does not fetch remote resources.
+
+ * `html` - html string, accepts complete documents as well as fragments
+ * `options` - optional, see Options above
+
+#### juice.juiceResources(html, options, callback)
+
+Callback returns string containing inlined HTML. Fetches remote resources.
+
+ * `html` - html string
+ * `options` - see Options above
+ * `callback(err, html)`
+   - `err` - `Error` object or `null`
+   - `html` - inlined HTML
+
+#### juice.juiceFile(filePath, options, callback)
+
+Callback returns string containing inlined HTML. Fetches remote resources.
+
+ * `filePath` - path to the html file to be juiced
+ * `options` - see Options above
+ * `callback(err, html)`
+   - `err` - `Error` object or `null`
+   - `html` - inlined HTML
+
+#### juice.juiceDocument($ [, options])
+
+This takes a cheerio instance and performs inlining in-place.  Returns the
+same cheerio instance.  Does not fetch remote resources.
+
+ * `$` - a cheerio instance, be sure to use the same cheerio version that juice uses
+ * `options` - optional, see Options above`
+
+#### juice.inlineContent(html, css [, options])
+
+This takes html and css and returns new html with the provided css inlined.
+It does not look at `<style>` or `<link rel="stylesheet">` elements at all.
+
+ * `html` - html string
+ * `css` - css string
+ * `options` - optional, see Options above
+
+#### juice.inlineDocument($, css [, options])
+
+Given a cheerio instance and css, this modifies the cheerio instance so that the provided css is inlined. It does not look at `<style>` or `<link rel="stylesheet">` elements at all.
+
+ * `$` - a cheerio instance, be sure to use the same cheerio version that juice uses
+ * `css` - css string
+ * `options` - optional, see Options above
+
+### Global settings
+
+#### juice.codeBlocks
+
+An object where each value has a `start` and `end` to specify fenced code blocks that should be ignored during parsing and inlining. For example, Handlebars (hbs) templates are `juice.codeBlocks.HBS = {start: '{{', end: '}}'}`. `codeBlocks` can fix problems where otherwise juice might interpret code like `<=` as HTML, when it is meant to be template language code. Note that `codeBlocks` is a dictionary which can contain many different code blocks, so don't do `juice.codeBlocks = {...}` do `juice.codeBlocks.myBlock = {...}`
+
+#### juice.ignoredPseudos
+
+Array of ignored pseudo-selectors such as 'hover' and 'active'.
+
+#### juice.widthElements
+
+Array of HTML elements that can receive `width` attributes.
+
+#### juice.heightElements
+
+Array of HTML elements that can receive `height` attributes.
+
+#### juice.styleToAttribute
+
+Object of style property names (key) to their respective attribute names (value).
+
+#### juice.tableElements
+
+Array of table HTML elements that can receive attributes defined in `juice.styleToAttribute`.
+
+#### juice.nonVisualElements
+
+Array of elements that will not have styles inlined because they are not intended to render.
+
+#### juiceClient.excludedProperties
+
+Array of css properties that won't be inlined.
+
+### Special markup
+
+#### data-embed
+When a `data-embed` attribute is present on a stylesheet `<link>` that has been inlined into the document as a `<style></style>` tag by the web-resource-inliner juice will not inline the styles and will not remove the `<style></style>` tags.
+
+This can be used to embed email client support hacks that rely on css selectors into your email templates.
+
+### CLI Options
+
+To use Juice from CLI, run `juice [options] input.html output.html`
+
+For a listing of all available options, just type `juice -h`.
+
+> Note that if you want to just type `juice` from the command line, you should `npm install juice -g` so it is globally available.
+
+CLI Options:
+
+The CLI should have all the above [options](#options) with the names changed from camel case to hyphen-delimited, so for example `extraCss` becomes `extra-css` and `webResources.scripts` becomes `web-resources-scripts`.
+
+These are additional options not included in the standard `juice` options listed above:
+
+- `--css [filepath]` will load and inject CSS into `extraCss`.
+- `--options-file [filepath]` will load and inject options from a JSON file. Options from the CLI will be given priority over options in the file when there is a conflict.
+- `codeBlocks` is optionally supported in the options file if you include it. This will allow you to support different template languages in a build process.
+
+### Running Juice in the Browser
+
+Attempting to Browserify `require('juice')` fails because portions of Juice and its dependencies interact with the file system using the standard `require('fs')`. However, you can `require('juice/client')` via Browserify which has support for `juiceDocument`, `inlineDocument`, and `inlineContent`, but not `juiceFile`, `juiceResources`, or `inlineExternal`. *Note that automated tests are not running in the browser yet.*
+
+## License
+
+MIT Licensed, see License.md
+
+### 3rd-party
+
+- Uses [cheerio](https://github.com/cheeriojs/cheerio) for the underlying DOM
+representation.
+- Uses [mensch](https://github.com/brettstimmerman/mensch) to parse out CSS and
+[Slick](https://github.com/subtleGradient/slick) to tokenize them.
+- Icon by [UnheardSounds](http://unheardsounds.deviantart.com/gallery/26536908#/d2ngozi)

package/node_modules/juice/bin/juice

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+
+var juice = require('..');
+var cli = require('../lib/cli');
+var fs = require('fs');
+var path = require('path');
+
+var program = cli.getProgram();
+
+if (program.args.length < 2) {
+  program.help();
+}
+
+var [inputFile, outputFile] = program.args;
+var options = cli.argsToOptions(program);
+var queue = [];
+
+if (options.optionsFile) {
+  var optionsFromFile = require(path.resolve(process.cwd(),options.optionsFile));
+  options = Object.assign({}, optionsFromFile, options, {
+    webResources: Object.assign(
+      {},
+      optionsFromFile && optionsFromFile.webResources,
+      options && options.webResources
+    )
+  });
+}
+
+if (options.cssFile) {
+  queue.push(function() {
+    fs.readFile(options.cssFile, function(err, css) {
+      if (handleError(err)) { return; }
+      options.extraCss = css.toString();
+      next();
+    });
+  });
+}
+
+next();
+
+function doJuice() {
+  delete options.cssFile;
+  delete options.optionsFile;
+
+  juice.juiceFile(inputFile, options, function(err, html) {
+    if (handleError(err)) { return; }
+    fs.writeFile(outputFile, html, handleError);
+  });
+}
+
+function next() {
+  if (queue.length) {
+    return queue.pop()();
+  }
+  doJuice();
+}
+
+function handleError(err) {
+  if (err) {
+    console.error(err.stack);
+    process.exit(1);
+  }
+  return !!err;
+}

package/node_modules/juice/client.js

@@ -0,0 +1,29 @@
+'use strict';
+
+var cheerio = require('./lib/cheerio');
+var makeJuiceClient = require('./lib/inline');
+
+/**
+ * Note that makeJuiceClient will take a base object (in this case a function) and enhance it
+ * with a lot of useful properties and functions.
+ *
+ * This client adopts cheerio as a DOM parser and adds an "inlineContent" function that let
+ * users to specify the CSS to be inlined instead of extracting it from the html.
+ * 
+ * The weird "makeJuiceClient" behaviour is there in order to keep backward API compatibility.
+ */
+var juiceClient = makeJuiceClient(function(html,options) {
+  return cheerio(html, { xmlMode: options && options.xmlMode}, juiceDocument, [options]);
+});
+
+var juiceDocument = function(html, options) {
+  return juiceClient.juiceDocument(html, options);
+}
+
+juiceClient.inlineContent = function(html, css, options) {
+  return cheerio(html, { xmlMode: options && options.xmlMode}, juiceClient.inlineDocument, [css, options]);
+};
+
+juiceClient.codeBlocks = cheerio.codeBlocks;
+
+module.exports = juiceClient;

package/node_modules/juice/index.js

@@ -0,0 +1,69 @@
+ 'use strict';
+
+/**
+ * Module dependencies.
+ */
+
+var utils = require('./lib/utils');
+var packageJson = require('./package.json');
+var fs = require('fs');
+var path = require('path');
+var inline = require('web-resource-inliner');
+var juiceClient = require('./client');
+var cheerio = require('./lib/cheerio');
+var juice = juiceClient;
+
+module.exports = juice;
+
+juice.version = packageJson.version;
+
+juice.Selector = utils.Selector;
+juice.Property = utils.Property;
+juice.utils = utils;
+
+juice.juiceFile = juiceFile;
+juice.juiceResources = juiceResources;
+juice.inlineExternal = inlineExternal;
+
+function juiceFile(filePath, options, callback) {
+  // set default options
+  fs.readFile(filePath, 'utf8', function(err, content) {
+    if (err) {
+      return callback(err);
+    }
+    options = utils.getDefaultOptions(options); // so we can mutate options without guilt
+    // Optional support for codeBlocks within optionsFile
+    if (options.codeBlocks) {
+      Object.keys(options.codeBlocks).forEach(function(key) {
+        juice.codeBlocks[key] = options.codeBlocks[key];
+      });
+    }
+    if (!options.webResources.relativeTo) {
+      var rel = path.dirname(path.relative(process.cwd(),filePath));
+      options.webResources.relativeTo = rel;
+    }
+    juiceResources(content, options, callback);
+  });
+}
+
+function inlineExternal(html, inlineOptions, callback) {
+  var options = Object.assign({fileContent: html}, inlineOptions);
+  inline.html(options, callback);
+}
+
+function juiceResources(html, options, callback) {
+  options = utils.getDefaultOptions(options);
+
+  var onInline = function(err, html) {
+    if (err) {
+      return callback(err);
+    }
+
+    return callback(null,
+      cheerio(html, { xmlMode: options && options.xmlMode}, juiceClient.juiceDocument, [options])
+    );
+  };
+
+  options.webResources.relativeTo = options.webResources.relativeTo || options.url; // legacy support
+  inlineExternal(html, options.webResources, onInline);
+}

package/node_modules/juice/juice.d.ts

@@ -0,0 +1,66 @@
+// Type definitions for Juice 3.0.0
+// Project: https://github.com/Automattic/juice
+// Definitions by: Kamil Nikel <https://github.com/knikel>
+
+/* =================== USAGE ===================
+   import juice = require('juice');
+   =============================================== */
+
+export = juice;
+
+declare function juice(html: string, options?: juice.Options): string;
+
+declare namespace juice {
+
+  export function juiceResources(html: string, options: Options, callback: Callback): string
+
+  export function juiceFile(filePath: string, options: Options, callback: Callback): string
+
+  export function juiceDocument($: any, options?: Options): any
+
+  export function inlineContent(html: string, css: string, options?: Options): string
+
+  export function inlineDocument($: any, css: string, options?: Options): any
+
+  export let codeBlocks: { [index: string]: { start: string, end: string } };
+  export let excludedProperties: string[];
+  export let heightElements: HTMLElement[];
+  export let ignoredPseudos: string[];
+  export let nonVisualElements: HTMLElement[];
+  export let styleToAttribute: { [index: string]: string };
+  export let tableElements: HTMLElement[];
+  export let widthElements: HTMLElement[];
+
+  export interface Callback { (err: Error, html: string): any; }
+
+  interface Options {
+    extraCss?: string;
+    applyStyleTags?: boolean;
+    removeStyleTags?: boolean;
+    preserveMediaQueries?: boolean;
+    preserveFontFaces?: boolean;
+    preserveKeyFrames?: boolean;
+    preservePseudos?: boolean;
+    insertPreservedExtraCss?: boolean;
+    applyWidthAttributes?: boolean;
+    applyHeightAttributes?: boolean;
+    applyAttributesTableElements?: boolean;
+    webResources?: WebResourcesOptions;
+    inlinePseudoElements?: boolean;
+    xmlMode?: boolean;
+    preserveImportant?: boolean;
+    resolveCSSVariables?: boolean;
+  }
+
+  interface WebResourcesOptions {
+    fileContent?: string;
+    inlineAttribute?: string;
+    images?: boolean | number;
+    svgs?: boolean | number;
+    scripts?: boolean | number;
+    links?: boolean | number;
+    relativeTo?: string;
+    rebaseRelativeTo?: string;
+    strict?: boolean;
+  }
+}

package/node_modules/juice/lib/cheerio.js

@@ -0,0 +1,72 @@
+'use strict';
+
+/**
+ * Module dependencies.
+ */
+var cheerio = require('cheerio');
+var utils = require('./utils');
+
+var cheerioLoad = function(html, options, encodeEntities) {
+  options = Object.assign({decodeEntities: false, _useHtmlParser2:true}, options);
+  html = encodeEntities(html);
+  return cheerio.load(html, options);
+};
+
+var createEntityConverters = function () {
+  var codeBlockLookup = [];
+
+  var encodeCodeBlocks = function(html) {
+    var blocks = module.exports.codeBlocks;
+    Object.keys(blocks).forEach(function(key) {
+      var re = new RegExp(blocks[key].start + '([\\S\\s]*?)' + blocks[key].end, 'g');
+      html = html.replace(re, function(match, subMatch) {
+        codeBlockLookup.push(match);
+        return 'JUICE_CODE_BLOCK_' + (codeBlockLookup.length - 1) + '_';
+      });
+    });
+    return html;
+  };
+
+  var decodeCodeBlocks = function(html) {
+    for(var index = 0; index < codeBlockLookup.length; index++) {
+      var re = new RegExp('JUICE_CODE_BLOCK_' + index + '_(="")?', 'gi');
+      html = html.replace(re, function() {
+        return codeBlockLookup[index];
+      });
+    }
+    return html;
+  };
+
+  return {
+    encodeEntities: encodeCodeBlocks,
+    decodeEntities: decodeCodeBlocks,
+  };
+};
+
+/**
+ * Parses the input, calls the callback on the parsed DOM, and generates the output
+ *
+ * @param {String} html input html to be processed
+ * @param {Object} options for the parser
+ * @param {Function} callback to be invoked on the DOM
+ * @param {Array} callbackExtraArguments to be passed to the callback
+ * @return {String} resulting html
+ */
+module.exports = function(html, options, callback, callbackExtraArguments) {
+  var entityConverters = createEntityConverters();
+
+  var $ = cheerioLoad(html, options, entityConverters.encodeEntities);
+  var args = [ $ ];
+  args.push.apply(args, callbackExtraArguments);
+  var doc = callback.apply(undefined, args) || $;
+
+  if (options && options.xmlMode) {
+    return entityConverters.decodeEntities(doc.xml());
+  }
+  return entityConverters.decodeEntities(doc.html());
+};
+
+module.exports.codeBlocks = {
+  EJS: { start: '<%', end: '%>' },
+  HBS: { start: '{{', end: '}}' }
+};

package/node_modules/juice/lib/cli.js

@@ -0,0 +1,142 @@
+'use strict';
+
+var { program } = require('commander');
+var pkg = require('../package');
+
+var cli = {};
+
+module.exports = cli;
+
+cli.getProgram = function() {
+  program.name = pkg.name;
+
+  program.version(pkg.version)
+    .usage('[options] input.html output.html');
+
+  Object.keys(cli.options).forEach(function(key) {
+    program.option('--' + key + ' [value]', cli.options[key].def);
+  });
+
+  program.parse(process.argv);
+
+  return program;
+};
+
+cli.options = {
+  'css': {
+    pMap: 'css',
+    map: 'cssFile',
+    def: 'Add an extra CSS file by name' },
+  'options-file': {
+    pMap: 'optionsFile',
+    def: 'Load options from a JSON file' },
+  'extra-css': {
+    pMap: 'extraCss',
+    def: 'Add extra CSS' },
+  'insert-preserved-extra-css': {
+    pMap: 'insertPreservedExtraCss',
+    def: 'insert preserved @font-face and @media into document?',
+    coercion: JSON.parse },
+  'apply-style-tags': {
+    pMap: 'applyStyleTags',
+    def: 'inline from style tags?',
+    coercion: JSON.parse },
+  'remove-style-tags': {
+    pMap: 'removeStyleTags',
+    def: 'remove style tags?',
+    coercion: JSON.parse },
+  'preserve-important': {
+    pMap: 'preserveImportant',
+    def: 'preserve important?',
+    coercion: JSON.parse },
+  'preserve-media-queries': {
+    pMap: 'preserveMediaQueries',
+    def: 'preserve media queries?',
+    coercion: JSON.parse },
+  'preserve-font-faces': {
+    pMap: 'preserveFontFaces',
+    def: 'preserve font faces?',
+    coercion: JSON.parse },
+  'preserve-key-frames': {
+    pMap: 'preserveKeyFrames',
+    def: 'preserve key frames?',
+    coercion: JSON.parse },
+  'preserve-pseudos': {
+    pMap: 'preservePseudos',
+    def: 'preserve pseudo selectors?',
+    coercion: JSON.parse },
+  'apply-width-attributes': {
+    pMap: 'applyWidthAttributes',
+    def: 'apply width attributes to relevent elements?',
+    coercion: JSON.parse },
+  'apply-height-attributes': {
+    pMap: 'applyHeightAttributes',
+    def: 'apply height attributes to relevent elements?',
+    coercion: JSON.parse },
+  'apply-attributes-table-elements': {
+    pMap: 'applyAttributesTableElements',
+    def: 'apply attributes with and equivalent CSS value to table elements?',
+    coercion: JSON.parse },
+  'xml-mode': {
+    pMap: 'xmlMode',
+    def: 'generate output with tags closed?  input must be valid XML',
+    coercion: JSON.parse },
+  'resolve-css-variables': {
+    pMap: 'resolveCSSVariables',
+    def: 'resolve CSS variables',
+    coercion: JSON.parse },
+  'web-resources-inline-attribute': {
+    pMap: 'webResourcesInlineAttribute',
+    map: 'inlineAttribute',
+    def: 'see docs for web-resource-inliner inlineAttribute',
+    coercion: JSON.parse },
+  'web-resources-images': {
+    pMap: 'webResourcesImages',
+    map: 'images',
+    def: 'see docs for web-resource-inliner images',
+    coercion: JSON.parse },
+  'web-resources-links': {
+    pMap: 'webResourcesLinks',
+    map: 'links',
+    def: 'see docs for web-resource-inliner links',
+    coercion: JSON.parse },
+  'web-resources-scripts': {
+    pMap: 'webResourcesScripts',
+    map: 'scripts',
+    def: 'see docs for web-resource-inliner scripts',
+    coercion: JSON.parse },
+  'web-resources-relative-to': {
+    pMap: 'webResourcesRelativeTo',
+    map: 'relativeTo',
+    def: 'see docs for web-resource-inliner relativeTo' },
+  'web-resources-rebase-relative-to': {
+    pMap: 'webResourcesRebaseRelativeTo',
+    map: 'rebaseRelativeTo',
+    def: 'see docs for web-resource-inliner rebaseRelativeTo' },
+  'web-resources-strict': {
+    pMap: 'webResourcesStrict',
+    map: 'strict',
+    def: 'see docs for web-resource-inliner strict',
+    coercion: JSON.parse }
+};
+
+cli.argsToOptions = function(program) {
+  var result = { webResources: {} };
+  Object.keys(cli.options).forEach(function(key) {
+    var option = cli.options[key];
+    var value = program[option.pMap];
+    if (value !== undefined) {
+      if (option.coercion) {
+        value = option.coercion(value);
+      }
+
+      if (option.pMap.match(/webResources/)) {
+        result.webResources[option.map] = value;
+      } else {
+        result[option.map || option.pMap] = value;
+      }
+    }
+  });
+
+  return result;
+};