fast-xml-validator 1.3.0 → 1.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fast-xml-validator",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "description": "Validate XML for Syntax and Business rules without C/C++ based libraries",
   "main": "./lib/fxv.cjs",
   "type": "module",
@@ -66,6 +66,7 @@
   ],
   "dependencies": {
     "detailed-xml-validator": "^2.2.0",
+    "path-expression-matcher": "^1.6.2",
     "xml-naming": "^0.3.0"
   }
 }

package/src/SyntaxValidator.js

@@ -0,0 +1,414 @@
+'use strict';
+
+import ValidationError from './ValidationError.js';
+import { isWhiteSpace, getLineNumberForPosition, isIllegalControlCode } from './util.js';
+import XmlNameValidator from './validators/XmlNameValidator.js';
+import XmlDeclarationValidator from './validators/XmlDeclarationValidator.js';
+import AttributeStringValidator from './validators/AttributeStringValidator.js';
+import CommentCdataReader from './validators/CommentCdataReader.js';
+import ControlCharValidator from './validators/ControlCharValidator.js';
+import SkipTagMatcher from './validators/SkipTagMatcher.js';
+import RawSubtreeReader from './validators/RawSubtreeReader.js';
+import DocTypeValidator from './validators/DocTypeValidator.js';
+
+const defaultOptions = {
+  allowBooleanAttributes: false,
+  unpairedTags: [],
+  docType: {
+    maxEntityCount: Infinity,
+    maxEntitySize: Infinity,
+  },
+  invalidCharSequence: {
+    comment: false,   // '--' inside a comment body
+    tagValue: false,  // ']]>' inside element text content
+    attrLt: false,    // '<' inside an attribute value
+  },
+  xmlDeclaraion: {
+    optional: true,
+    argPosition: true,
+  },
+  multipleRoots: true,
+  skipTags: [],
+};
+
+/**
+ * SyntaxValidator — validates that an XML document is well-formed.
+ *
+ * This is an orchestrator: it owns the top-level character scan and the
+ * open/close tag stack, and delegates every other concern to a focused,
+ * single-responsibility collaborator:
+ *
+ *   - XmlDeclarationValidator  — the `<?xml ... ?>` prolog
+ *   - DocTypeValidator         — `<!DOCTYPE ...>`
+ *   - CommentCdataReader       — `<!-- -->` and `<![CDATA[ ]]>`
+ *   - AttributeStringValidator — a tag's attribute expression
+ *   - XmlNameValidator         — element/attribute/PI name well-formedness
+ *   - ControlCharValidator     — illegal control characters (always on)
+ *   - SkipTagMatcher / RawSubtreeReader — `skipTags` support
+ *
+ * Usage: `new SyntaxValidator(options).validate(xmlData)` or the static
+ * convenience `SyntaxValidator.validate(xmlData, options)`.
+ */
+export default class SyntaxValidator {
+  constructor(options) {
+    this.options = mergeOptions(defaultOptions, options);
+  }
+
+  /** Static convenience wrapper — matches the historical fxv v1 API. */
+  static validate(xmlData, options) {
+    return new SyntaxValidator(options).validate(xmlData);
+  }
+
+  validate(xmlData) {
+    const options = this.options;
+
+    const tags = [];
+    let tagFound = false;
+    let reachedRoot = false;
+    let docTypeSeen = false;
+
+    if (xmlData[0] === '\ufeff') {
+      xmlData = xmlData.substr(1);
+    }
+
+    const throwError = (code, message, lineNumber) => {
+      throw new ValidationError(message, code, lineNumber.line || lineNumber, lineNumber.col);
+    };
+
+    const declValidator = new XmlDeclarationValidator(options.xmlDeclaraion, throwError);
+    const declResult = declValidator.validate(xmlData);
+    const xmlVersion = declResult.version;
+    xmlData = xmlData.substring(declResult.end);
+
+    const docTypeValidator = new DocTypeValidator(options.docType, xmlVersion);
+    const commentCdataReader = new CommentCdataReader(options);
+    const nameValidator = new XmlNameValidator(xmlVersion);
+    const attrValidator = new AttributeStringValidator(options, nameValidator, xmlVersion);
+    const skipMatcher = new SkipTagMatcher(options.skipTags);
+
+    const checkTagValueSeq = options.invalidCharSequence?.tagValue === true;
+
+    const checkDocTypePlacement = (startBang) => {
+      const isDoctype = xmlData.substring(startBang, startBang + 9).toUpperCase() === '<!DOCTYPE';
+      if (!isDoctype) return;
+      if (docTypeSeen) {
+        throwError('InvalidXml', 'Multiple DOCTYPE declarations found.', getLineNumberForPosition(xmlData, startBang));
+      }
+      if (tagFound || tags.length > 0) {
+        throwError('InvalidXml', 'DOCTYPE must appear before the root element.', getLineNumberForPosition(xmlData, startBang));
+      }
+      docTypeSeen = true;
+    };
+
+    for (let i = 0; i < xmlData.length; i++) {
+      if (xmlData[i] === '<' && xmlData[i + 1] === '?') {
+        i += 2;
+        i = this._readPI(xmlData, i, nameValidator, throwError);
+      } else if (xmlData[i] === '<') {
+        let tagStartPos = i;
+        i++;
+
+        if (xmlData[i] === '!') {
+          try {
+            checkDocTypePlacement(tagStartPos);
+            i = commentCdataReader.read(xmlData, i, docTypeValidator);
+          } catch (err) {
+            throwError('InvalidDocType', err.message, getLineNumberForPosition(xmlData, i - 1));
+          }
+          continue;
+        } else {
+          let closingTag = false;
+          if (xmlData[i] === '/') {
+            closingTag = true;
+            i++;
+          }
+
+          let tagName = '';
+          for (;
+            i < xmlData.length &&
+            xmlData[i] !== '>' &&
+            xmlData[i] !== ' ' &&
+            xmlData[i] !== '\t' &&
+            xmlData[i] !== '\n' &&
+            xmlData[i] !== '\r';
+            i++
+          ) {
+            tagName += xmlData[i];
+          }
+          tagName = tagName.trim();
+
+          if (tagName[tagName.length - 1] === '/') {
+            tagName = tagName.substring(0, tagName.length - 1);
+            i--;
+          }
+
+          if (!nameValidator.isValidQName(tagName)) {
+            let msg;
+            if (tagName.trim().length === 0) {
+              msg = "Invalid space after '<'.";
+            } else {
+              msg = "Tag '" + tagName + "' is an invalid name.";
+            }
+            throwError('InvalidTag', msg, getLineNumberForPosition(xmlData, tagStartPos));
+          }
+
+          const result = this._readAttributeStr(xmlData, i);
+          if (result === false) {
+            throwError('InvalidAttr', "Attributes for '" + tagName + "' have open quote.", getLineNumberForPosition(xmlData, i));
+          }
+          let attrStr = result.value;
+          i = result.index;
+
+          if (attrStr[attrStr.length - 1] === '/') {
+            const attrStrStart = i - attrStr.length;
+            attrStr = attrStr.substring(0, attrStr.length - 1);
+            const isValid = attrValidator.validate(attrStr);
+            if (isValid === true) {
+              if (reachedRoot === true && !options.multipleRoots) {
+                throwError('InvalidXml', 'Multiple possible root nodes found.', getLineNumberForPosition(xmlData, tagStartPos));
+              }
+              tagFound = true;
+              if (tags.length === 0) {
+                reachedRoot = true;
+              }
+              skipMatcher.push(tagName);
+              skipMatcher.pop();
+            } else {
+              throwError(isValid.err.code, isValid.err.msg, getLineNumberForPosition(xmlData, attrStrStart + isValid.err.line));
+            }
+          } else if (closingTag) {
+            if (!result.tagClosed) {
+              throwError('InvalidTag', "Closing tag '" + tagName + "' doesn't have proper closing.", getLineNumberForPosition(xmlData, i));
+            } else if (attrStr.trim().length > 0) {
+              throwError('InvalidTag', "Closing tag '" + tagName + "' can't have attributes or invalid starting.", getLineNumberForPosition(xmlData, tagStartPos));
+            } else if (tags.length === 0) {
+              throwError('InvalidTag', "Closing tag '" + tagName + "' has not been opened.", getLineNumberForPosition(xmlData, tagStartPos));
+            } else {
+              const otg = tags.pop();
+              if (tagName !== otg.tagName) {
+                let openPos = getLineNumberForPosition(xmlData, otg.tagStartPos);
+                throwError(
+                  'InvalidTag',
+                  "Expected closing tag '" + otg.tagName + "' (opened in line " + openPos.line + ", col " + openPos.col + ") instead of closing tag '" + tagName + "'.",
+                  getLineNumberForPosition(xmlData, tagStartPos)
+                );
+              }
+              skipMatcher.pop();
+              if (tags.length === 0) {
+                reachedRoot = true;
+              }
+            }
+          } else {
+            // Opening tag — decide whether this subtree should be skipped
+            // from validation entirely before validating its attributes.
+            const skip = skipMatcher.push(tagName);
+
+            if (!skip) {
+              const isValid = attrValidator.validate(attrStr);
+              if (isValid !== true) {
+                throwError(isValid.err.code, isValid.err.msg, getLineNumberForPosition(xmlData, i - attrStr.length + isValid.err.line));
+              }
+            }
+
+            if (reachedRoot === true && !options.multipleRoots) {
+              throwError('InvalidXml', 'Multiple possible root nodes found.', getLineNumberForPosition(xmlData, i));
+            } else if (options.unpairedTags.indexOf(tagName) !== -1) {
+              skipMatcher.pop();
+            } else if (skip) {
+              // Consume the whole skipped subtree now, as opaque raw text,
+              // then continue scanning right after its closing tag.
+              i = RawSubtreeReader.consume(xmlData, tagName, i + 1);
+              skipMatcher.pop();
+              if (tags.length === 0) reachedRoot = true;
+              tagFound = true;
+              continue;
+            } else {
+              tags.push({ tagName, tagStartPos });
+            }
+            tagFound = true;
+          }
+
+          //skip tag text value
+          //It may include comments and CDATA value
+          let prevTwo = '';
+          for (i++; i < xmlData.length; i++) {
+            if (xmlData[i] === '<') {
+              if (xmlData[i + 1] === '!') {
+                i++;
+                try {
+                  checkDocTypePlacement(i - 1);
+                  i = commentCdataReader.read(xmlData, i, docTypeValidator);
+                } catch (err) {
+                  throwError('InvalidDocType', err.message, getLineNumberForPosition(xmlData, i - 1));
+                }
+                prevTwo = '';
+                continue;
+              } else if (xmlData[i + 1] === '?') {
+                i += 2;
+                i = this._readPI(xmlData, i, nameValidator, throwError);
+                prevTwo = '';
+              } else {
+                break;
+              }
+            } else if (xmlData[i] === '&') {
+              const afterAmp = this._validateAmpersand(xmlData, i);
+              if (afterAmp === -1)
+                throwError('InvalidChar', "char '&' is not expected.", getLineNumberForPosition(xmlData, i));
+              i = afterAmp;
+              prevTwo = '';
+            } else {
+              const code = xmlData.charCodeAt(i);
+              if (isIllegalControlCode(code)) {
+                throwError('IllegalCharacter', `Illegal control character ${ControlCharValidator.describe(code)} in document content.`, getLineNumberForPosition(xmlData, i));
+              }
+              if (reachedRoot === true && tags.length === 0 && !isWhiteSpace(xmlData[i])) {
+                throwError('InvalidXml', 'Extra text at the end', getLineNumberForPosition(xmlData, i));
+              }
+              if (checkTagValueSeq) {
+                prevTwo = (prevTwo + xmlData[i]).slice(-2);
+                if (prevTwo === ']]' && xmlData[i + 1] === '>') {
+                  throwError('InvalidXml', "Element text content must not contain ']]>'.", getLineNumberForPosition(xmlData, i - 1));
+                }
+              }
+            }
+          } //end of reading tag text value
+          if (xmlData[i] === '<') {
+            i--;
+          }
+        }
+      } else {
+        if (isWhiteSpace(xmlData[i])) {
+          continue;
+        }
+        if (reachedRoot) {
+          throwError('InvalidXml', "Extra text at the end: '" + xmlData[i] + "' is not expected.", getLineNumberForPosition(xmlData, i));
+        }
+        throwError('InvalidChar', "char '" + xmlData[i] + "' is not expected.", getLineNumberForPosition(xmlData, i));
+      }
+    }
+
+    if (!tagFound) {
+      throwError('InvalidXml', 'Start tag expected.', { line: 1, col: 1 });
+    } else if (tags.length === 1) {
+      throwError('InvalidTag', "Unclosed tag '" + tags[0].tagName + "'.", getLineNumberForPosition(xmlData, tags[0].tagStartPos));
+    } else if (tags.length > 0) {
+      throwError('InvalidXml', "Invalid '" +
+        JSON.stringify(tags.map(t => t.tagName)).replace(/\r?\n/g, '') +
+        "' found.", { line: 1, col: 1 });
+    }
+
+    return true;
+  }
+
+  _readPI(xmlData, i, nameValidator, throwError) {
+    const piStart = i;
+    const nameStart = i;
+    let nameValidated = false;
+
+    for (; i < xmlData.length; i++) {
+      const ch = xmlData[i];
+
+      if (!nameValidated && (ch === ' ' || ch === '?')) {
+        const piName = xmlData.substr(nameStart, i - nameStart);
+        nameValidated = true;
+
+        if (piName.toLowerCase() === 'xml') {
+          throwError(
+            'InvalidXml',
+            'XML declaration allowed only at the start of the document.',
+            getLineNumberForPosition(xmlData, piStart - 2)
+          );
+        } else if (!nameValidator.isValidName(piName)) {
+          throwError(
+            'InvalidXml',
+            `Processing instruction target "${piName}" is not a valid XML Name.`,
+            getLineNumberForPosition(xmlData, piStart - 2)
+          );
+        }
+      }
+
+      if (ch === '?' && xmlData[i + 1] === '>') {
+        i++;
+        return i;
+      }
+    }
+
+    throwError(
+      'InvalidXml',
+      'Processing instruction is not closed with "?>".',
+      getLineNumberForPosition(xmlData, piStart - 2)
+    );
+  }
+
+  _readAttributeStr(xmlData, i) {
+    let attrStr = '';
+    let startChar = '';
+    let tagClosed = false;
+    for (; i < xmlData.length; i++) {
+      if (xmlData[i] === '"' || xmlData[i] === "'") {
+        if (startChar === '') {
+          startChar = xmlData[i];
+        } else if (startChar !== xmlData[i]) {
+          // opposite quote inside value — allowed
+        } else {
+          startChar = '';
+        }
+      } else if (xmlData[i] === '>') {
+        if (startChar === '') {
+          tagClosed = true;
+          break;
+        }
+      }
+      attrStr += xmlData[i];
+    }
+    if (startChar !== '') {
+      return false;
+    }
+    return { value: attrStr, index: i, tagClosed };
+  }
+
+  _validateNumberAmpersand(xmlData, i) {
+    let re = /\d/;
+    if (xmlData[i] === 'x') {
+      i++;
+      re = /[\da-fA-F]/;
+    }
+    for (; i < xmlData.length; i++) {
+      if (xmlData[i] === ';') return i;
+      if (!xmlData[i].match(re)) break;
+    }
+    return -1;
+  }
+
+  _validateAmpersand(xmlData, i) {
+    i++;
+    if (xmlData[i] === ';') return -1;
+    if (xmlData[i] === '#') {
+      i++;
+      return this._validateNumberAmpersand(xmlData, i);
+    }
+    let count = 0;
+    for (; i < xmlData.length; i++, count++) {
+      if (xmlData[i].match(/\w/) && count < 20) continue;
+      if (xmlData[i] === ';') break;
+      return -1;
+    }
+    return i;
+  }
+}
+
+function mergeOptions(defaults, options) {
+  const merged = Object.assign({}, defaults, options);
+  merged.docType = Object.assign({}, defaults.docType, options?.docType);
+  merged.invalidCharSequence = Object.assign({}, defaults.invalidCharSequence, options?.invalidCharSequence);
+  merged.xmlDeclaraion = Object.assign(
+    {},
+    defaults.xmlDeclaraion,
+    options?.xmlDeclaraion,
+    options?.xmlDeclaration // accept the correctly-spelled alias too
+  );
+  merged.skipTags = options?.skipTags || defaults.skipTags;
+  return merged;
+}
+
+export { SyntaxValidator };

package/src/fxv.d.ts

@@ -15,6 +15,47 @@ export type docTypeOptions = {
   maxEntitySize?: number;
 }
 
+export type invalidCharSequenceOptions = {
+  /**
+   * Error if a comment body contains the literal sequence `--`
+   * (besides the `--` immediately before the closing `-->`).
+   *
+   * Defaults to `false`.
+   */
+  comment?: boolean;
+
+  /**
+   * Error if element text content contains the literal sequence `]]>`.
+   *
+   * Defaults to `false`.
+   */
+  tagValue?: boolean;
+
+  /**
+   * Error if an attribute value contains a literal `<`.
+   *
+   * Defaults to `false`.
+   */
+  attrLt?: boolean;
+};
+
+export type xmlDeclarationOptions = {
+  /**
+   * When `false`, the document MUST start with an `<?xml ... ?>` declaration.
+   *
+   * Defaults to `true`.
+   */
+  optional?: boolean;
+
+  /**
+   * When `true`, `version`/`encoding`/`standalone` must appear in that fixed
+   * order inside the XML declaration. When `false`, any order is accepted.
+   *
+   * Defaults to `true`.
+   */
+  argPosition?: boolean;
+};
+
 export type validationOptions = {
   /**
    * Whether to allow attributes without value
@@ -31,6 +72,27 @@ export type validationOptions = {
   unpairedTags?: string[];
 
   docType?: docTypeOptions;
+
+  /** Opt-in checks for otherwise-legal-looking but suspicious sequences. */
+  invalidCharSequence?: invalidCharSequenceOptions;
+
+  /** Controls handling of the `<?xml ... ?>` prolog. */
+  xmlDeclaraion?: xmlDeclarationOptions;
+
+  /**
+   * Allow more than one root-level element (as if wrapped in a virtual root).
+   *
+   * Defaults to `false`.
+   */
+  multipleRoots?: boolean;
+
+  /**
+   * Path expressions (see the `path-expression-matcher` package) for tags
+   * whose subtree should be excluded from validation entirely.
+   *
+   * Defaults to `[]`
+   */
+  skipTags?: string[];
 };
 
 export type ValidationError = {
@@ -43,6 +105,8 @@ export type ValidationError = {
 };
 
 export class SyntaxValidator {
+  constructor(options?: validationOptions);
+  validate(xmlData: string): true;
   static validate(xmlData: string, options?: validationOptions): true | ValidationError;
 }
 

package/src/fxv.js

@@ -1,12 +1,6 @@
 'use strict';
 
-import { validate as validateSyntax } from './validator.js';
+import SyntaxValidator from './SyntaxValidator.js';
 import BusinessRulesValidator from 'detailed-xml-validator';
 
-class SyntaxValidator {
-  static validate(xmlData, options) {
-    return validateSyntax(xmlData, options);
-  }
-}
-
-export { SyntaxValidator, BusinessRulesValidator };
+export { SyntaxValidator, BusinessRulesValidator };

package/src/util.js

@@ -25,9 +25,35 @@ export function isEmptyObject(obj) {
 }
 
 export function getValue(v) {
-  if (exports.isExist(v)) {
+  if (isExist(v)) {
     return v;
   } else {
     return '';
   }
 }
+
+export function isWhiteSpace(char) {
+  return char === ' ' || char === '\t' || char === '\n' || char === '\r';
+}
+
+/**
+ * True for character codes that are illegal as literal characters anywhere in
+ * an XML document (element text, attribute values, comments): 0x00-0x08,
+ * 0x0B, 0x0C, 0x0E-0x1F. Tab/LF/CR (0x09/0x0A/0x0D) are legal whitespace and
+ * are excluded.
+ */
+export function isIllegalControlCode(code) {
+  return code <= 8 || code === 11 || code === 12 || (code >= 14 && code <= 31);
+}
+
+export function getLineNumberForPosition(xmlData, index) {
+  const lines = xmlData.substring(0, index).split(/\r?\n/);
+  return {
+    line: lines.length,
+    col: lines[lines.length - 1].length + 1,
+  };
+}
+
+export function getPositionFromMatch(match) {
+  return match.startIndex + match[1].length;
+}

package/src/validators/AttributeStringValidator.js

@@ -0,0 +1,115 @@
+'use strict';
+
+import { getAllMatches, getPositionFromMatch } from '../util.js';
+import ControlCharValidator from './ControlCharValidator.js';
+
+const validAttrStrRegxp = new RegExp('(\\s*)([^\\s=]+)(\\s*=)?(\\s*([\'"])(([\\s\\S])*?)\\5)?', 'g');
+
+/**
+ * AttributeStringValidator — single responsibility: validate the raw
+ * attribute-expression substring of a start tag (everything between the tag
+ * name and the closing `>`/`/>`).
+ *
+ * Checks performed (always on):
+ *   - proper whitespace separation between attributes
+ *   - attribute names are valid QNames
+ *   - no duplicate attribute names
+ *   - `=` present without a value -> "without value"
+ *   - value present but not quoted -> UnquotedAttributeValue
+ *   - boolean attributes rejected unless `allowBooleanAttributes`
+ *   - illegal control characters inside the attribute value
+ *   - `xmlns:x=""` only allowed in XML 1.1
+ *
+ * Checks performed (opt-in via `invalidCharSequence.attrLt`):
+ *   - literal `<` inside an attribute value
+ */
+export default class AttributeStringValidator {
+  /**
+   * @param {object} options - the full validation options object
+   * @param {import('./XmlNameValidator.js').default} nameValidator
+   * @param {string} xmlVersion
+   */
+  constructor(options, nameValidator, xmlVersion) {
+    this.options = options;
+    this.nameValidator = nameValidator;
+    this.xmlVersion = xmlVersion;
+  }
+
+  /**
+   * @param {string} attrStr
+   * @returns {true | { err: { code: string, msg: string, line: number } }}
+   */
+  validate(attrStr) {
+    const matches = getAllMatches(attrStr, validAttrStrRegxp);
+    const attrNames = {};
+    const checkAttrLt = this.options.invalidCharSequence?.attrLt === true;
+
+    for (let i = 0; i < matches.length; i++) {
+      const m = matches[i];
+
+      if (m[1].length === 0) {
+        return this._err('InvalidAttr', "Attribute '" + m[2] + "' has no space in starting.", m);
+      }
+
+      const hasEquals = m[3] !== undefined;
+      const hasQuotedValue = m[4] !== undefined;
+
+      if (hasEquals && !hasQuotedValue) {
+        // Either `attr=` with nothing after it, or `attr=value` where value
+        // isn't wrapped in quotes — XML requires every attribute value to be
+        // quoted, so both shapes are rejected as UnquotedAttributeValue.
+        return this._err(
+          'UnquotedAttributeValue',
+          "Attribute '" + m[2] + "' is without value.",
+          m
+        );
+      } else if (!hasEquals && !this.options.allowBooleanAttributes) {
+        return this._err('InvalidAttr', "boolean attribute '" + m[2] + "' is not allowed.", m);
+      }
+
+      const attrName = m[2];
+
+      if (!this.nameValidator.isValidQName(attrName)) {
+        return this._err('InvalidAttr', "Attribute '" + attrName + "' is an invalid name.", m);
+      }
+
+      const attrValue = m[6] || '';
+
+      if (hasQuotedValue) {
+        const illegalIdx = ControlCharValidator.findIllegalIndex(attrValue);
+        if (illegalIdx !== -1) {
+          const code = attrValue.charCodeAt(illegalIdx);
+          return this._err(
+            'IllegalCharacter',
+            `Illegal control character ${ControlCharValidator.describe(code)} in attribute '${attrName}' value.`,
+            m
+          );
+        }
+
+        if (checkAttrLt && attrValue.indexOf('<') !== -1) {
+          return this._err('InvalidAttr', `Attribute '${attrName}' value must not contain '<'.`, m);
+        }
+      }
+
+      if (attrName.startsWith('xmlns:') && m[6] === '' && this.xmlVersion === '1.0') {
+        return this._err(
+          'InvalidAttr',
+          `Undeclaring the prefixed namespace ${attrName}="" is only permitted in XML 1.1 documents.`,
+          m
+        );
+      }
+
+      if (!Object.prototype.hasOwnProperty.call(attrNames, attrName)) {
+        attrNames[attrName] = 1;
+      } else {
+        return this._err('InvalidAttr', "Attribute '" + attrName + "' is repeated.", m);
+      }
+    }
+
+    return true;
+  }
+
+  _err(code, msg, match) {
+    return { err: { code, msg, line: getPositionFromMatch(match) } };
+  }
+}