@globalpayments/vega 2.58.0 → 2.59.1

package/dist/collection/components/vega-rich-text-editor/dto/content-state.js

@@ -1,18 +1,20 @@
-import { RTEImageBlock } from './blocks/image-block';
 import { RTEListBlock } from './blocks/list-block';
-import { RTETextBlock } from './blocks/text-block';
 import { ModifyContentActionType } from './actions/modify-content-action.abstract';
-import { AppendChildNodesAction } from './actions/append-child-nodes-action';
+import { AppendChildrenAction } from './actions/append-child-nodes-action';
 import { generateUUID } from '../../../utils/misc';
 import { RTEListItemBlock } from './blocks/list-item-block';
 import { SyncUpSelectionAction } from './actions/sync-up-selection-action';
 import { ActionHandleStrategyRegistry } from './action-handle-strategies/action-handle-strategy-registry';
-import { BlockRemoveChildBlockStrategy } from './action-handle-strategies/modify-content-strategies/block-remove-child-block-strategy';
-import { BlockAppendBlocksStrategy } from './action-handle-strategies/modify-content-strategies/block-append-blocks-strategy';
-import { BlockInsertBlocksBeforeStrategy } from './action-handle-strategies/modify-content-strategies/block-insert-blocks-before-strategy';
-import { BlockInsertBlocksAfterStrategy } from './action-handle-strategies/modify-content-strategies/block-insert-blocks-after-strategy';
-import { RTECodeBlock } from './blocks/code-block';
 import { BlockTransformToCodeBlockStrategy } from './action-handle-strategies/modify-content-strategies/block-transform-to-code-block-strategy';
+import ElementToDtoStrategyProcessor from '../slimmers/controllers/helper/element-to-dto-strategy/element-to-dto-strategy-processor';
+import { isNonNullable } from '../../../types/type-guard';
+import RTEDTOClassManager from '../../../helpers/rte-manager/dto-class-manager';
+import { UpdateCursorPositionStrategy } from './action-handle-strategies/modify-content-strategies/update-cursor-position-strategy';
+import { RemoveChildrenStrategy } from './action-handle-strategies/modify-content-strategies/remove-children-strategy';
+import { AppendChildrenStrategy } from './action-handle-strategies/modify-content-strategies/append-children-strategy';
+import { InsertChildrenBeforeStrategy } from './action-handle-strategies/modify-content-strategies/insert-children-before-strategy';
+import { InsertChildrenAfterStrategy } from './action-handle-strategies/modify-content-strategies/insert-children-after-strategy';
+import './setup';
 /**
  * Class representing the content state of the rich text editor.
  */
@@ -27,29 +29,17 @@ export class VegaRTEContent {
    * Converts a JSON array of blocks to a class array of RTEContentBlock.
    *
    * @param {VegaRTEContentBlock[]} value The JSON array of blocks to convert.
+   * @param {VegaRTETransformOptions} options - Optional transformation options.
    * @returns {VegaRTEContent} The converted array of RTEContentBlock.
    */
-  static fromJSON(value) {
+  static fromJSON(value, options = { autoMatchFormat: true }) {
     const blocks = value.map((block) => {
-      switch (block.type) {
-        case 'paragraph':
-        case 'title':
-        case 'subtitle':
-        case 'heading-1':
-        case 'heading-2':
-        case 'heading-3': {
-          return RTETextBlock.from(block);
-        }
-        case 'image':
-          return RTEImageBlock.from(block);
-        case 'bullet-list':
-        case 'number-list':
-          return RTEListBlock.from(block);
-        case 'code-block':
-          return RTECodeBlock.from(block);
-        default: {
-          throw new Error(`[Vega] Unknown block type: ${block.type}`);
-        }
+      const BlockClass = RTEDTOClassManager.getRTEBlockClass(block.type);
+      if (BlockClass) {
+        return BlockClass.from(block, options);
+      }
+      else {
+        throw new Error(`[Vega] Unknown block type: ${block.type}`);
       }
     });
     return new VegaRTEContent(blocks);
@@ -74,6 +64,43 @@ export class VegaRTEContent {
       },
     ]);
   }
+  /**
+   * Converts HTML content to a VegaRTEContent instance.
+   *
+   * @param {string} html - The HTML string to convert.
+   * @param {VegaRTETransformOptions} options - Optional transformation options.
+   * @returns {VegaRTEContent} The converted content state.
+   */
+  static fromHtml(html, options = { autoMatchFormat: true, skipCustomAnnotations: false }) {
+    /**
+     * remove redundant spaces between tags, for example:
+     * case1:
+     * '<p>\n\t <span>test</span>\n\t </p>' will be formatted into '<p><span>test</span></p>'
+     * '<p>
+     * 		test
+     * 	</p>' will be formatted into '<p>test</p>'
+     *
+     * case2:
+     * <h1>
+     * _test&*....
+     * </h1> will be formatted into <h1>_test&*....</h1>
+     *
+     * The blank space between individual tags should be preserved:
+     * <span> </span>
+     */
+    const formattedHtml = html
+      .replace(/>\s+<\/?/g, (match) => {
+      return match.endsWith('</') ? match : '><';
+    })
+      .replace(/(>)[\n\t]+(?=[a-zA-Z0-9_\W])/g, '$1')
+      .replace(/([a-zA-Z0-9_\W])[\n\t]+(?=<)/g, '$1');
+    const body = new DOMParser().parseFromString(formattedHtml, 'text/html').body;
+    const blocks = ElementToDtoStrategyProcessor.process(Array.from(body.childNodes), options)
+      .filter(isNonNullable)
+      .map((output) => output.toDto(options))
+      .filter(isNonNullable);
+    return new VegaRTEContent(blocks);
+  }
   /**
    * Clones the content state.
    *
@@ -93,6 +120,15 @@ export class VegaRTEContent {
   toJSON() {
     return this.children.map((block) => block.toJSON());
   }
+  /**
+   * Converts the content state to HTML.
+   *
+   * @param {VegaRTETransformOptions} [options] - Optional rendering context for the content.
+   * @returns {string} The HTML representation of the content state.
+   */
+  toHtml(options) {
+    return this.children.map((block) => block.toHtml(options)).join('');
+  }
   /**
    * Internal method to add the block item, remove the block item
    *
@@ -110,7 +146,7 @@ export class VegaRTEContent {
   toListItem(block) {
     block.children.map((node) => node.apply(new SyncUpSelectionAction()));
     const listItemBlock = new RTEListItemBlock(generateUUID());
-    listItemBlock.apply(new AppendChildNodesAction(block['children']));
+    listItemBlock.apply(new AppendChildrenAction(block['children']));
     listItemBlock['annotationMap'] = block['annotationMap'];
     return listItemBlock;
   }
@@ -167,9 +203,10 @@ export class VegaRTEContent {
   }
 }
 (() => {
-  ActionHandleStrategyRegistry.register(ModifyContentActionType.DELETE_CHILD, VegaRTEContent.name, new BlockRemoveChildBlockStrategy());
-  ActionHandleStrategyRegistry.register(ModifyContentActionType.APPEND_CHILD_NODES, VegaRTEContent.name, new BlockAppendBlocksStrategy());
-  ActionHandleStrategyRegistry.register(ModifyContentActionType.INSERT_BLOCKS_BEFORE, VegaRTEContent.name, new BlockInsertBlocksBeforeStrategy());
-  ActionHandleStrategyRegistry.register(ModifyContentActionType.INSERT_BLOCKS_AFTER, VegaRTEContent.name, new BlockInsertBlocksAfterStrategy());
+  ActionHandleStrategyRegistry.register(ModifyContentActionType.DELETE_CHILDREN, VegaRTEContent.name, new RemoveChildrenStrategy());
+  ActionHandleStrategyRegistry.register(ModifyContentActionType.APPEND_CHILDREN, VegaRTEContent.name, new AppendChildrenStrategy());
+  ActionHandleStrategyRegistry.register(ModifyContentActionType.INSERT_CHILDREN_BEFORE, VegaRTEContent.name, new InsertChildrenBeforeStrategy());
+  ActionHandleStrategyRegistry.register(ModifyContentActionType.INSERT_CHILDREN_AFTER, VegaRTEContent.name, new InsertChildrenAfterStrategy());
   ActionHandleStrategyRegistry.register(ModifyContentActionType.TRANSFORM_TO_CODE_BLOCK, VegaRTEContent.name, new BlockTransformToCodeBlockStrategy());
+  ActionHandleStrategyRegistry.register(ModifyContentActionType.UPDATE_CURSOR_POSITION, VegaRTEContent.name, new UpdateCursorPositionStrategy());
 })();

package/dist/collection/components/vega-rich-text-editor/dto/nodes/code-block-node.js

@@ -1,13 +1,14 @@
 import { ModifyContentActionType } from '../actions/modify-content-action.abstract';
-import { NodeTypeEnum, RTENode } from './node.abstract';
+import { NodeTypeEnum } from './node.abstract';
 import { ActionHandleStrategyRegistry } from '../action-handle-strategies/action-handle-strategy-registry';
 import { UpdateCodeBlockStrategy } from '../action-handle-strategies/modify-content-strategies/update-code-block-strategy';
 import { SelectionChangeAction } from '../actions/selection-change-action';
 import { CodeNodeSetSelectionRangeAnnotationStrategy } from '../action-handle-strategies/apply-annotation-strategies/code-node-set-selection-range-strategy';
+import { RTEDecoratorNode } from './decorator-node';
 /**
  * RTE code node DTO class.
  */
-export class RTECodeBlockNode extends RTENode {
+export class RTECodeBlockNode extends RTEDecoratorNode {
   constructor(id, content, language, parentBlock) {
     super(id);
     this.type = NodeTypeEnum.CODE_BLOCK_NODE;
@@ -25,6 +26,12 @@ export class RTECodeBlockNode extends RTENode {
   toJSON() {
     return { id: this.id, type: 'text', text: this.text, language: this.language };
   }
+  /**
+   * @inheritDoc
+   */
+  toHtml() {
+    return `<code style='box-sizing: border-box;color: rgba(var(--v-text-primary, 32, 54, 69, 1));text-align: left;font-family: "Roboto Mono";font-weight: 400;line-height: 22px;font-size: 16px;white-space: pre-wrap;min-height: 22px;tab-size: 2px;'>${this.text}</code>`;
+  }
   /**
    * @inheritDoc
    */

package/dist/collection/components/vega-rich-text-editor/dto/nodes/decorator-node.js

@@ -0,0 +1,58 @@
+import { findParent } from '../../../../utils/ui';
+import stateEntityRenderingRegistry from '../../slimmers/controllers/state-entity-rendering-registry';
+import { RTENode } from './node.abstract';
+/**
+ * Abstract class for decorator nodes. A decorator node modifies content like an image node that will delete the whole node when the delete button is pressed.
+ */
+export class RTEDecoratorNode extends RTENode {
+  constructor() {
+    super(...arguments);
+    this.type = 'decorator-node';
+    this.isSelected = false;
+  }
+  /**
+   * Check the element is a decorator node container.
+   *
+   * @param {HTMLElement} element - The checked element.
+   * @returns {boolean} - The result of the check.
+   */
+  static isDecoratorNodeContainerElement(element) {
+    return element && element.classList.contains(RTEDecoratorNode.DECORATOR_CONTAINER_CLASS);
+  }
+  /**
+   * Get the decorator node element within the container.
+   *
+   * @param {HTMLElement} container - The container element.
+   * @returns {Nullable<HTMLElement>} - The decorator node element, if found.
+   */
+  static getDecoratorNodeElement(container) {
+    return container.querySelector(`.${RTEDecoratorNode.DECORATOR_NODE_CLASS}`);
+  }
+  /**
+   * @inheritDoc
+   */
+  getRangeEndOffset() {
+    return 1;
+  }
+  /**
+   * @inheritDoc
+   */
+  getRangeContainer() {
+    const element = stateEntityRenderingRegistry.getDOMByEntity(this);
+    if (element) {
+      return findParent(element, `.${RTEDecoratorNode.DECORATOR_CONTAINER_CLASS}`);
+    }
+  }
+  /**
+   * The decorator node is not content editable from the outside.
+   *
+   * @returns {boolean} - Always returns false for decorator nodes.
+   */
+  isContentEditable() {
+    return false;
+  }
+}
+// CSS class names for the decorator node parent element
+RTEDecoratorNode.DECORATOR_CONTAINER_CLASS = 'v-internal-decorator-container';
+// CSS class names for the decorator node element
+RTEDecoratorNode.DECORATOR_NODE_CLASS = 'v-internal-decorator-node';

package/dist/collection/components/vega-rich-text-editor/dto/nodes/image-node.js

@@ -1,4 +1,15 @@
-import { NodeTypeEnum, RTENode } from './node.abstract';
+var __rest = (this && this.__rest) || function (s, e) {
+  var t = {};
+  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+    t[p] = s[p];
+  if (s != null && typeof Object.getOwnPropertySymbols === "function")
+    for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+      if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+        t[p[i]] = s[p[i]];
+    }
+  return t;
+};
+import { NodeTypeEnum } from './node.abstract';
 import { ImageAnnotation } from '../annotations/image-annotation';
 import { ModifyContentActionType } from '../actions/modify-content-action.abstract';
 import { NodeAnnotationTypeEnum } from '../annotations/node-annotation.abstract';
@@ -7,10 +18,12 @@ import { ActionHandleStrategyRegistry } from '../action-handle-strategies/action
 import { ImageSetAnnotationMapStrategy } from '../action-handle-strategies/apply-annotation-strategies/image-set-annotation-map-strategy';
 import { ImageUpdateUrlStrategy } from '../action-handle-strategies/modify-content-strategies/image-update-url-strategy';
 import { AnnotationAction } from '../actions/annotation-action.abstract';
+import { CommonAnnotation } from '../annotations/common-annotation.abstract';
+import { RTEDecoratorNode } from './decorator-node';
 /**
  * Image node
  */
-export class RTEImageNode extends RTENode {
+export class RTEImageNode extends RTEDecoratorNode {
   constructor(id, url, parentBlock, annotationMap) {
     super(id, annotationMap);
     this.type = NodeTypeEnum.IMAGE;
@@ -22,19 +35,21 @@ export class RTEImageNode extends RTENode {
    *
    * @param {VegaRTEImageNode} node - The node to be converted.
    * @param {RTEImageBlock} parentBlock - The parent block
+   * @param {VegaRTETransformOptions} options - Optional transformation options.
    * @returns {RTEImageNode} An instance of `RTEImageBlock`
    */
-  static from(node, parentBlock) {
+  static from(node, parentBlock, options = { autoMatchFormat: true }) {
     const imageNode = new RTEImageNode(node.id, node.url, parentBlock);
-    let annotations;
-    if (!node.annotations || Object.keys(node.annotations).length === 0) {
-      annotations = { size: 'md' };
-    }
-    else {
-      annotations = node.annotations;
-    }
+    const autoMatchFormat = !!options.autoMatchFormat;
+    const _a = Object.assign({}, node.annotations), { size } = _a, otherAnnotations = __rest(_a, ["size"]);
+    const annotations = Object.assign(Object.assign({}, otherAnnotations), { size: size !== null && size !== void 0 ? size : (autoMatchFormat ? 'md' : undefined) });
     imageNode.annotationMap = new Map(Object.keys(annotations)
-      .map(() => ImageAnnotation.from(annotations.size, annotations.alt))
+      .map((type) => {
+      if (type === 'size' || type === 'alt') {
+        return ImageAnnotation.from(annotations.size, annotations.alt);
+      }
+      return this.createAnnotationEntity(type, annotations[type]);
+    })
       .filter(isNonNullable));
     return imageNode;
   }
@@ -42,14 +57,13 @@ export class RTEImageNode extends RTENode {
    * @inheritDoc
    */
   toJSON() {
-    const imageAnnotation = this.annotationMap.get(NodeAnnotationTypeEnum.IMAGE);
-    const annotations = {};
-    if (imageAnnotation === null || imageAnnotation === void 0 ? void 0 : imageAnnotation.size) {
-      annotations.size = imageAnnotation.size;
-    }
-    if (imageAnnotation === null || imageAnnotation === void 0 ? void 0 : imageAnnotation.alt) {
-      annotations.alt = imageAnnotation.alt;
-    }
+    const annotations = Array.from(this.annotationMap.values())
+      .filter((annotation) => annotation instanceof ImageAnnotation || annotation instanceof CommonAnnotation)
+      .reduce((record, annotation) => {
+      return Object.assign(Object.assign({}, record), annotation.toJSON());
+    }, {});
+    if (annotations.alt == '')
+      delete annotations.alt;
     return Object.assign(Object.assign({ id: this.id }, (Object.keys(annotations).length > 0 ? { annotations } : {})), { type: 'image', url: this.url });
   }
   /**
@@ -58,6 +72,18 @@ export class RTEImageNode extends RTENode {
   clone() {
     return new RTEImageNode(this.id, this.url, this.parent, super.cloneAnnotations());
   }
+  /**
+   * @inheritDoc
+   */
+  toHtml() {
+    const imageAnnotation = this.getAnnotationByType(NodeAnnotationTypeEnum.IMAGE);
+    const attrStr = super.generateAttributeString(...[
+      imageAnnotation && imageAnnotation.alt ? `alt="${imageAnnotation.alt}"` : null,
+      `src="${this.url}"`,
+      imageAnnotation && imageAnnotation.size ? `data-size="${imageAnnotation.size}"` : null,
+    ].filter(isNonNullable));
+    return `<img${attrStr}>`;
+  }
   /**
    * @inheritDoc
    */

package/dist/collection/components/vega-rich-text-editor/dto/nodes/node.abstract.js

@@ -3,6 +3,14 @@ import stateEntityRenderingRegistry from '../../slimmers/controllers/state-entit
 import domNodeSubjectFactory from '../../../../helpers/change-manager/subject/dom-node-subject/dom-node-subject-factory';
 import { VegaInternalRichTextEditorFlushChanges } from '../../../../helpers/event-manager/event-id/vega-internal-event-id';
 import { ModifyContentAction } from '../actions/modify-content-action.abstract';
+import { NodeAnnotation } from '../annotations/node-annotation.abstract';
+import { camelToDashCase } from '../../../../utils/string';
+import { isNonNullable } from '../../../../types/type-guard';
+import { CustomAttributeAnnotation } from '../annotations/custom-attribute-annotation';
+import { CustomClassAnnotation } from '../annotations/custom-class-annotation';
+import { CommonAnnotationTypeEnum } from '../annotations/common-annotation.abstract';
+import { CustomStyleAnnotation } from '../annotations/custom-style-annotation';
+import { methodPlaceholder } from 'vega-slimmer/core';
 export var NodeTypeEnum;
 (function (NodeTypeEnum) {
   NodeTypeEnum["TEXT"] = "TEXT";
@@ -20,6 +28,34 @@ export class RTENode {
       this.annotationMap = annotationMap;
     }
   }
+  /**
+   * Creates a new instance of the RTENode from the given JSON data.
+   *
+   * @param {unknown} json - The JSON data to create the node from.
+   * @param {RTEBlock} parentBlock - The parent block of the node.
+   * @param {VegaRTETransformOptions} options - Options for transforming the node.
+   */
+  static from(json, parentBlock, options) {
+    throw new Error(`[Vega] ${this.constructor.name}.from(${JSON.stringify(json)}, ${parentBlock}, ${options}) is not implemented. Please implement this method in the subclass.`);
+  }
+  /**
+   * Creates different types of text annotations based on the provided type and value.
+   *
+   * @param {keyof VegaRTETextAnnotations} type - The key of the type.
+   * @param {unknown} value - The value that will be used to create the specific type of annotation entity based on the `type` provided.
+   * @returns {Nullable<[RTENodeAnnotationMapKey, RTENodeAnnotationMapValue]>} Returning a nullable tuple containing a key and a
+   * value from the `RTENodeAnnotationMapKey` and `RTENodeAnnotationMapValue` types.
+   */
+  static createAnnotationEntity(type, value) {
+    switch (type) {
+      case 'customAttribute':
+        return CustomAttributeAnnotation.from(value);
+      case 'customClass':
+        return CustomClassAnnotation.from(value);
+      case 'customStyle':
+        return CustomStyleAnnotation.from(value);
+    }
+  }
   /**
    * Get annotation by type
    *
@@ -52,6 +88,69 @@ export class RTENode {
     }
     return this;
   }
+  /**
+   * Get styles from annotations
+   *
+   * @param {RTERenderContext} [options={ standalone: false }] - Options to control style mode
+   * @returns {AnnotationStyle} - Annotation styles
+   */
+  getStyles(options = { standalone: false }) {
+    const styles = Array.from(this.annotationMap.values())
+      .filter((annotation) => annotation instanceof NodeAnnotation || annotation instanceof CustomStyleAnnotation)
+      .map((annotation) => annotation.renderStyle(options))
+      .filter(Boolean);
+    return this.mergeAnnotationStyles(styles, ['textDecoration']);
+  }
+  /**
+   * Get classes from annotations
+   *
+   * @param {RTERenderContext} [options={ standalone: false }] - Options to control style mode
+   * @returns {string} - Annotation style
+   */
+  getClasses(options = { standalone: false }) {
+    return Array.from(this.annotationMap.values())
+      .filter((annotation) => annotation instanceof NodeAnnotation || annotation instanceof CustomClassAnnotation)
+      .map((annotation) => annotation.renderClass(options))
+      .filter(isNonNullable)
+      .reduce((pre, cur) => [pre, cur].join(' ').trim(), '');
+  }
+  /**
+   * Get custom attribute annotation, excluding "class" and "style"
+   *
+   * @returns {CustomAttributeAnnotation} - custom attribute annotation
+   */
+  getCustomAttributesAnnotation() {
+    return this.annotationMap.get(CommonAnnotationTypeEnum.CUSTOM_ATTRIBUTE);
+  }
+  /**
+   * Check if the node is a text node.
+   *
+   * @returns {boolean} - True if the node is a text node, false otherwise.
+   */
+  isTextNode() {
+    return false;
+  }
+  /**
+   * Generate attributes as string
+   *
+   * @param {...string} attrs - Additional attributes to include
+   * @returns {string} - Attributes as string
+   */
+  generateAttributeString(...attrs) {
+    var _a;
+    const styles = Object.entries(Object.assign({}, this.getStyles({ standalone: true })))
+      .map(([key, value]) => `${camelToDashCase(key)}: ${value};`)
+      .join('');
+    const customClassAnnotation = this.annotationMap.get(CommonAnnotationTypeEnum.CUSTOM_CLASS);
+    const customAttributeString = ((_a = this.getCustomAttributesAnnotation()) === null || _a === void 0 ? void 0 : _a.toString(attrs)) || [];
+    const attributes = [
+      ...customAttributeString,
+      customClassAnnotation === null || customClassAnnotation === void 0 ? void 0 : customClassAnnotation.toString(),
+      styles ? `style="${styles}"` : null,
+      ...attrs,
+    ].filter(isNonNullable);
+    return attributes.length ? ` ${attributes.join(' ')}` : '';
+  }
   /**
    * apply annotation action or modify content action
    *
@@ -85,4 +184,50 @@ export class RTENode {
   cloneAnnotations() {
     return new Map(Array.from(this.annotationMap.entries()).map(([key, value]) => [key, value.clone()]));
   }
+  /* istanbul ignore next */
+  /**
+   * Placeholder for the method to be implemented in sub classes.
+   *
+   * @param {AnnotationAction} action Annotation action
+   */
+  doAnnotationActionApply(action) {
+    methodPlaceholder(action);
+  }
+  /* istanbul ignore next */
+  /**
+   * Placeholder for the method to be implemented in sub classes.
+   *
+   * @param {ModifyContentAction} action ModifyContentAction
+   */
+  doModifyActionApply(action) {
+    methodPlaceholder(action);
+  }
+  /**
+   * Merge an array of annotation styles into a single style object.
+   * e.g.,
+   * { textDecoration: 'underline', textDecoration: 'line-through' }
+   * -> { textDecoration: 'underline line-through' }
+   *
+   * @param {AnnotationStyle[]} styles - Array of annotation style objects to merge.
+   * @param {string[]} canMergeKeyList - List of style keys that can be merged by concatenation.
+   * @returns {AnnotationStyle} - The merged annotation style object.
+   */
+  mergeAnnotationStyles(styles, canMergeKeyList) {
+    const merged = {};
+    for (const style of styles) {
+      for (const key in style) {
+        const value = style[key];
+        const existing = merged[key];
+        if (typeof existing === 'string' &&
+          typeof value === 'string' &&
+          canMergeKeyList.includes(key)) {
+          merged[key] = Array.from(new Set(`${existing} ${value}`.split(/\s+/).filter(Boolean))).join(' ');
+        }
+        else {
+          merged[key] = value;
+        }
+      }
+    }
+    return merged;
+  }
 }