fast-xml-validator 1.3.0 → 1.4.1

package/src/validators/CommentCdataReader.js

@@ -0,0 +1,106 @@
+'use strict';
+
+import ControlCharValidator from './ControlCharValidator.js';
+
+/**
+ * CommentCdataReader — single responsibility: recognize and consume
+ * `<!-- comment -->`, `<![CDATA[ ... ]]>` and `<!DOCTYPE ...>` constructs
+ * starting at a given index (which points at the `!`), returning the index
+ * of the last character consumed (the closing `>`).
+ *
+ * DOCTYPE handling is fully delegated to a DocTypeValidator instance passed
+ * to `read()` by the caller (SyntaxValidator), since DOCTYPE parsing is a
+ * large, separate concern in its own right.
+ *
+ * Opt-in checks (via `invalidCharSequence`):
+ *   - `comment: true`  -> literal `--` inside a comment's body is rejected
+ *     (besides the sequence immediately before the closing `-->`).
+ */
+export default class CommentCdataReader {
+  constructor(options = {}) {
+    this.checkCommentDashes = options.invalidCharSequence?.comment === true;
+  }
+
+  /**
+   * @param {string} xmlData
+   * @param {number} i - index of the '!' character
+   * @param {import('./DocTypeValidator.js').default} docTypeValidator
+   * @returns {number} index of the last character consumed
+   */
+  read(xmlData, i, docTypeValidator) {
+    if (xmlData.length > i + 2 && xmlData[i + 1] === '-' && xmlData[i + 2] === '-') {
+      return this._readComment(xmlData, i);
+    } else if (
+      xmlData.length > i + 7 &&
+      xmlData[i + 1] === 'D' &&
+      xmlData[i + 2] === 'O' &&
+      xmlData[i + 3] === 'C' &&
+      xmlData[i + 4] === 'T' &&
+      xmlData[i + 5] === 'Y' &&
+      xmlData[i + 6] === 'P' &&
+      xmlData[i + 7] === 'E'
+    ) {
+      return docTypeValidator.validateDocType(xmlData, i - 1);
+    } else if (
+      xmlData.length > i + 8 &&
+      xmlData[i + 1] === '[' &&
+      xmlData[i + 2] === 'C' &&
+      xmlData[i + 3] === 'D' &&
+      xmlData[i + 4] === 'A' &&
+      xmlData[i + 5] === 'T' &&
+      xmlData[i + 6] === 'A' &&
+      xmlData[i + 7] === '['
+    ) {
+      return this._readCdata(xmlData, i);
+    } else {
+      throw new Error("Invalid construct starting with '<!'.");
+    }
+  }
+
+  _readComment(xmlData, i) {
+    const bodyStart = i + 3;
+    for (i = bodyStart; i < xmlData.length; i++) {
+      if (xmlData[i] === '-' && xmlData[i + 1] === '-' && xmlData[i + 2] === '>') {
+        i += 2;
+        break;
+      }
+    }
+    if (xmlData[i] !== '>') {
+      throw new Error('Comment is not closed with "-->".');
+    }
+
+    const body = xmlData.substring(bodyStart, i - 2);
+    const illegalIdx = ControlCharValidator.findIllegalIndex(body);
+    if (illegalIdx !== -1) {
+      const code = body.charCodeAt(illegalIdx);
+      throw new Error(`Illegal control character ${ControlCharValidator.describe(code)} in comment.`);
+    }
+    if (this.checkCommentDashes && body.indexOf('--') !== -1) {
+      throw new Error(`Comment must not contain '--'.`);
+    }
+
+    return i;
+  }
+
+  _readCdata(xmlData, i) {
+    const bodyStart = i + 8;
+    for (i = bodyStart; i < xmlData.length; i++) {
+      if (xmlData[i] === ']' && xmlData[i + 1] === ']' && xmlData[i + 2] === '>') {
+        i += 2;
+        break;
+      }
+    }
+    if (xmlData[i] !== '>') {
+      throw new Error('CDATA section is not closed with "]]>".');
+    }
+
+    const body = xmlData.substring(bodyStart, i - 2);
+    const illegalIdx = ControlCharValidator.findIllegalIndex(body);
+    if (illegalIdx !== -1) {
+      const code = body.charCodeAt(illegalIdx);
+      throw new Error(`Illegal control character ${ControlCharValidator.describe(code)} in CDATA section.`);
+    }
+
+    return i;
+  }
+}

package/src/validators/ControlCharValidator.js

@@ -0,0 +1,44 @@
+'use strict';
+
+import { isIllegalControlCode } from '../util.js';
+
+/**
+ * ControlCharValidator — single responsibility: detect illegal control
+ * characters (0x00-0x08, 0x0B, 0x0C, 0x0E-0x1F) anywhere they appear as
+ * literal characters in the document (element text, attribute values,
+ * comments, CDATA, PI content, etc.).
+ *
+ * This check is always on — it is not gated by any option — since illegal
+ * control characters make a document non-well-formed per the XML spec.
+ */
+export default class ControlCharValidator {
+  /**
+   * Scan `str` for the first illegal control character.
+   * @param {string} str
+   * @returns {number} local index (within `str`) of the first offending
+   *   character, or -1 if none found.
+   */
+  static findIllegalIndex(str) {
+    const len = str.length;
+    for (let i = 0; i < len; i++) {
+      if (isIllegalControlCode(str.charCodeAt(i))) return i;
+    }
+    return -1;
+  }
+
+  /**
+   * @param {string} str
+   * @returns {boolean}
+   */
+  static hasIllegalChar(str) {
+    return this.findIllegalIndex(str) !== -1;
+  }
+
+  /**
+   * Convenience formatter for error messages.
+   * @param {number} code - char code
+   */
+  static describe(code) {
+    return `0x${code.toString(16).padStart(2, '0')}`;
+  }
+}

package/src/validators/DocTypeValidator.js

@@ -0,0 +1,280 @@
+import { name as isXmlName } from 'xml-naming';
+
+const defaultOptions = {
+    maxEntityCount: Infinity,
+    maxEntitySize: Infinity,
+};
+
+export default class DocTypeValidator {
+    constructor(options, xmlVersion = '1.0') {
+        this.options = Object.assign({}, defaultOptions, options);
+        this.suppressValidationErr = !options;
+        this.xmlVersion = xmlVersion;
+    }
+
+    validateDocType(xmlData, i) {
+        if (
+            xmlData[i + 3] !== 'O' ||
+            xmlData[i + 4] !== 'C' ||
+            xmlData[i + 5] !== 'T' ||
+            xmlData[i + 6] !== 'Y' ||
+            xmlData[i + 7] !== 'P' ||
+            xmlData[i + 8] !== 'E'
+        ) {
+            throw new Error(`Invalid Tag instead of DOCTYPE`);
+        }
+
+        i += 9;
+        let angleBracketsCount = 1;
+        let hasBody = false;
+        let comment = false;
+        let entityCount = 0;
+
+        for (; i < xmlData.length; i++) {
+            if (xmlData[i] === '<' && !comment) {
+                if (hasBody && hasSeq(xmlData, '!ENTITY', i)) {
+                    i += 7;
+                    [entityCount, i] = this._validateEntityExp(xmlData, i + 1, entityCount);
+                    // continue;
+                } else if (hasBody && hasSeq(xmlData, '!ELEMENT', i)) {
+                    i += 8;
+                    i = this._validateElementExp(xmlData, i + 1);
+                    // continue;
+                } else if (hasBody && hasSeq(xmlData, '!ATTLIST', i)) {
+                    i += 8;
+                    i = this._validateAttlistExp(xmlData, i + 1);
+                    continue;
+                } else if (hasBody && hasSeq(xmlData, '!NOTATION', i)) {
+                    i += 9;
+                    i = this._validateNotationExp(xmlData, i + 1);
+                    // continue;
+                } else if (hasSeq(xmlData, '!--', i)) {
+                    comment = true;
+                } else {
+                    throw new Error(`Invalid DOCTYPE`);
+                }
+                angleBracketsCount++;
+            } else if (xmlData[i] === '>') {
+                if (comment) {
+                    if (xmlData[i - 1] === '-' && xmlData[i - 2] === '-') {
+                        comment = false;
+                        angleBracketsCount--;
+                    }
+                } else {
+                    angleBracketsCount--;
+                }
+                if (angleBracketsCount === 0) break;
+            } else if (xmlData[i] === '[') {
+                hasBody = true;
+            }
+        }
+
+        if (angleBracketsCount !== 0) {
+            throw new Error(`Unclosed DOCTYPE`);
+        }
+
+        return i;
+    }
+
+    _validateEntityExp(xmlData, i, entityCount) {
+        i = skipWhitespace(xmlData, i);
+
+        // Read and validate entity name
+        const nameStart = i;
+        while (i < xmlData.length && !/\s/.test(xmlData[i]) && xmlData[i] !== '"' && xmlData[i] !== "'") {
+            i++;
+        }
+        const entityName = xmlData.substring(nameStart, i);
+        validateName(entityName, this.xmlVersion);
+
+        i = skipWhitespace(xmlData, i);
+
+        // Check for unsupported constructs
+        if (!this.suppressValidationErr) {
+            if (xmlData.substring(i, i + 6).toUpperCase() === 'SYSTEM') {
+                throw new Error('External entities are not supported');
+            } else if (xmlData[i] === '%') {
+                throw new Error('Parameter entities are not supported');
+            }
+        }
+
+        // Read and validate the entity value (validates quoting + size limit)
+        let entityValue;
+        [i, entityValue] = readQuotedValue(xmlData, i, 'entity');
+
+        const { maxEntitySize, maxEntityCount } = this.options;
+
+        if (entityValue.length > maxEntitySize) {
+            throw new Error(
+                `Entity "${entityName}" size (${entityValue.length}) exceeds maximum allowed size (${maxEntitySize})`
+            );
+        }
+
+        // Only count non-parameter entities (parameter entities contain '&')
+        if (entityValue.indexOf('&') === -1) {
+            entityCount++;
+            if (entityCount > maxEntityCount) {
+                throw new Error(
+                    `Entity count (${entityCount}) exceeds maximum allowed (${maxEntityCount})`
+                );
+            }
+        }
+
+        return [entityCount, i - 1];
+    }
+
+    _validateNotationExp(xmlData, i) {
+        i = skipWhitespace(xmlData, i);
+
+        // Read and validate notation name
+        const nameStart = i;
+        while (i < xmlData.length && !/\s/.test(xmlData[i])) i++;
+        const notationName = xmlData.substring(nameStart, i);
+        !this.suppressValidationErr && validateName(notationName, this.xmlVersion);
+
+        i = skipWhitespace(xmlData, i);
+
+        const identifierType = xmlData.substring(i, i + 6).toUpperCase();
+        if (!this.suppressValidationErr && identifierType !== 'SYSTEM' && identifierType !== 'PUBLIC') {
+            throw new Error(`Expected SYSTEM or PUBLIC, found "${identifierType}"`);
+        }
+        i += identifierType.length;
+        i = skipWhitespace(xmlData, i);
+
+        if (identifierType === 'PUBLIC') {
+            [i] = readQuotedValue(xmlData, i, 'publicIdentifier');
+            i = skipWhitespace(xmlData, i);
+            if (xmlData[i] === '"' || xmlData[i] === "'") {
+                [i] = readQuotedValue(xmlData, i, 'systemIdentifier');
+            }
+        } else if (identifierType === 'SYSTEM') {
+            [i] = readQuotedValue(xmlData, i, 'systemIdentifier');
+        }
+
+        return --i;
+    }
+
+    _validateElementExp(xmlData, i) {
+        i = skipWhitespace(xmlData, i);
+
+        // Read and validate element name
+        const nameStart = i;
+        while (i < xmlData.length && !/\s/.test(xmlData[i])) i++;
+        const elementName = xmlData.substring(nameStart, i);
+        if (!this.suppressValidationErr && !isXmlName(elementName, { xmlVersion: this.xmlVersion })) {
+            throw new Error(`Invalid element name: "${elementName}"`);
+        }
+
+        i = skipWhitespace(xmlData, i);
+
+        // Validate content model keyword or group
+        if (xmlData[i] === 'E' && hasSeq(xmlData, 'MPTY', i)) {
+            i += 4;
+        } else if (xmlData[i] === 'A' && hasSeq(xmlData, 'NY', i)) {
+            i += 2;
+        } else if (xmlData[i] === '(') {
+            i++;
+            while (i < xmlData.length && xmlData[i] !== ')') i++;
+            if (xmlData[i] !== ')') throw new Error('Unterminated content model');
+        } else if (!this.suppressValidationErr) {
+            throw new Error(`Invalid Element Expression, found "${xmlData[i]}"`);
+        }
+
+        return i;
+    }
+
+    _validateAttlistExp(xmlData, i) {
+        i = skipWhitespace(xmlData, i);
+
+        // Read element name
+        const elemNameStart = i;
+        while (i < xmlData.length && !/\s/.test(xmlData[i])) i++;
+        const elementName = xmlData.substring(elemNameStart, i);
+        validateName(elementName, this.xmlVersion);
+
+        i = skipWhitespace(xmlData, i);
+
+        // Read attribute name
+        const attrNameStart = i;
+        while (i < xmlData.length && !/\s/.test(xmlData[i])) i++;
+        const attributeName = xmlData.substring(attrNameStart, i);
+        validateName(attributeName, this.xmlVersion);
+
+        i = skipWhitespace(xmlData, i);
+
+        // Read attribute type
+        if (xmlData.substring(i, i + 8).toUpperCase() === 'NOTATION') {
+            i += 8;
+            i = skipWhitespace(xmlData, i);
+            if (xmlData[i] !== '(') throw new Error(`Expected '(', found "${xmlData[i]}"`);
+            i++;
+            while (i < xmlData.length && xmlData[i] !== ')') {
+                const notationStart = i;
+                while (i < xmlData.length && xmlData[i] !== '|' && xmlData[i] !== ')') i++;
+                const notation = xmlData.substring(notationStart, i).trim();
+                validateName(notation, this.xmlVersion);
+                if (xmlData[i] === '|') {
+                    i++;
+                    i = skipWhitespace(xmlData, i);
+                }
+            }
+            if (xmlData[i] !== ')') throw new Error('Unterminated list of notations');
+            i++;
+        } else {
+            const typeStart = i;
+            while (i < xmlData.length && !/\s/.test(xmlData[i])) i++;
+            const attributeType = xmlData.substring(typeStart, i);
+            const validTypes = ['CDATA', 'ID', 'IDREF', 'IDREFS', 'ENTITY', 'ENTITIES', 'NMTOKEN', 'NMTOKENS'];
+            if (!this.suppressValidationErr && !validTypes.includes(attributeType.toUpperCase())) {
+                throw new Error(`Invalid attribute type: "${attributeType}"`);
+            }
+        }
+
+        i = skipWhitespace(xmlData, i);
+
+        // Read default value declaration
+        if (xmlData.substring(i, i + 9).toUpperCase() === '#REQUIRED') {
+            i += 9;
+        } else if (xmlData.substring(i, i + 8).toUpperCase() === '#IMPLIED') {
+            i += 8;
+        } else {
+            [i] = readQuotedValue(xmlData, i, 'ATTLIST default value');
+        }
+
+        return i;
+    }
+}
+
+// ─── Helpers ────────────────────────────────────────────────────────────────
+
+function skipWhitespace(data, index) {
+    while (index < data.length && /\s/.test(data[index])) index++;
+    return index;
+}
+
+function hasSeq(data, seq, i) {
+    for (let j = 0; j < seq.length; j++) {
+        if (seq[j] !== data[i + j + 1]) return false;
+    }
+    return true;
+}
+
+function validateName(name, xmlVersion = '1.0') {
+    if (!isXmlName(name, { xmlVersion })) throw new Error(`Invalid entity name "${name}"`);
+}
+
+/**
+ * Read a single- or double-quoted string and return [nextIndex, value].
+ */
+function readQuotedValue(xmlData, i, type) {
+    const startChar = xmlData[i];
+    if (startChar !== '"' && startChar !== "'") {
+        throw new Error(`Expected quoted string for ${type}, found "${startChar}"`);
+    }
+    i++;
+    const start = i;
+    while (i < xmlData.length && xmlData[i] !== startChar) i++;
+    if (xmlData[i] !== startChar) throw new Error(`Unterminated ${type} value`);
+    const value = xmlData.substring(start, i);
+    return [++i, value];
+}

package/src/validators/RawSubtreeReader.js

@@ -0,0 +1,47 @@
+'use strict';
+
+/**
+ * RawSubtreeReader — single responsibility: given the index right after a
+ * skipped tag's opening `>`, consume raw characters until the literal
+ * closing tag `</tagName>` (optional whitespace before `>`) is found.
+ *
+ * Deliberately does NOT try to parse anything in between: skipped content is
+ * assumed to be non-XML or otherwise not meant to be validated (script/style
+ * bodies, vendor blobs, etc.), so it may contain unmatched `<`, quotes, or
+ * anything else. This mirrors how CDATA content is treated — opaque text,
+ * found by looking for its one true terminator.
+ *
+ * Same-name tags never "nest" under this strategy — the first `</tagName>`
+ * found ends the skip, matching the common script/style use case. Use a more
+ * specific skip expression (e.g. targeting only the outermost occurrence) if
+ * your skipped content can itself contain literal `</tagName>` text.
+ */
+export default class RawSubtreeReader {
+  /**
+   * @param {string} xmlData
+   * @param {string} tagName
+   * @param {number} i - index right after the opening tag's '>'
+   * @returns {number} index of the matching closing tag's own '>'
+   */
+  static consume(xmlData, tagName, i) {
+    const needle = '</' + tagName;
+    let searchFrom = i;
+
+    while (true) {
+      const idx = xmlData.indexOf(needle, searchFrom);
+      if (idx === -1) {
+        throw new Error(`Unclosed skipped tag '${tagName}'.`);
+      }
+
+      let j = idx + needle.length;
+      while (j < xmlData.length && /\s/.test(xmlData[j])) j++;
+
+      if (xmlData[j] === '>') {
+        return j;
+      }
+      // Not actually a match (e.g. tagName is a prefix of a longer name) —
+      // keep looking further in the string.
+      searchFrom = idx + needle.length;
+    }
+  }
+}

package/src/validators/SkipTagMatcher.js

@@ -0,0 +1,54 @@
+'use strict';
+
+import { Expression, Matcher } from 'path-expression-matcher';
+
+/**
+ * SkipTagMatcher — single responsibility: decide whether a tag currently
+ * being opened should be excluded from validation, based on a list of path
+ * expressions supplied via `options.skipTags` (same expression syntax as
+ * `path-expression-matcher`, e.g. `"..script"`, `"root.data.raw"`,
+ * `"row[type=raw]"`).
+ *
+ * Skip decisions are only ever made for tags reached through normal
+ * (non-skipped) parsing — once a match is found, the caller
+ * (`SyntaxValidator`) consumes the whole matched subtree as opaque raw text
+ * (mirroring how CDATA is treated) and calls `pop()` once for that tag, so
+ * this matcher's path stack never needs to represent the skipped subtree's
+ * internal structure.
+ */
+export default class SkipTagMatcher {
+  /**
+   * @param {Array<string>} [skipTags]
+   */
+  constructor(skipTags = []) {
+    this._expressions = skipTags.map((expr) => new Expression(expr));
+    this._matcher = new Matcher();
+    this._enabled = this._expressions.length > 0;
+  }
+
+  get enabled() {
+    return this._enabled;
+  }
+
+  /**
+   * Push the tag currently being opened onto the path and report whether it
+   * (and its whole subtree) should be skipped.
+   * @param {string} tagName
+   * @param {Record<string,string>} [rawAttributes] - for `[attr=value]` conditions
+   * @returns {boolean}
+   */
+  push(tagName, rawAttributes) {
+    if (!this._enabled) return false;
+    this._matcher.push(tagName, rawAttributes || null);
+    for (let i = 0; i < this._expressions.length; i++) {
+      if (this._matcher.matches(this._expressions[i])) return true;
+    }
+    return false;
+  }
+
+  /** Pop the most recently pushed tag off the path (tag fully closed). */
+  pop() {
+    if (!this._enabled) return;
+    this._matcher.pop();
+  }
+}

package/src/validators/XmlDeclarationValidator.js

@@ -0,0 +1,103 @@
+'use strict';
+
+/**
+ * XmlDeclarationValidator — single responsibility: parse and validate the
+ * `<?xml version="..." encoding="..." standalone="..."?>` prolog.
+ *
+ * Behaviour is controlled by the `xmlDeclaraion` config block:
+ *
+ *   xmlDeclaraion: {
+ *     optional: true,     // when false, the document MUST start with a decl
+ *     argPosition: true,  // when true, version/encoding/standalone must
+ *                          // appear in that fixed order (spec-mandated);
+ *                          // set false to allow any order.
+ *   }
+ *
+ * (`argPostion` — the spelling used in the original design note — is also
+ * accepted as an alias for `argPosition`.)
+ */
+export default class XmlDeclarationValidator {
+  constructor(options = {}, throwError) {
+    this.optional = options.optional !== undefined ? options.optional : true;
+    this.argPosition = options.argPosition !== undefined
+      ? options.argPosition
+      : (options.argPostion !== undefined ? options.argPostion : true);
+    this._throwError = throwError;
+  }
+
+  /**
+   * @param {string} xmlData - full document (BOM already stripped)
+   * @returns {{ version: string, end: number }} version defaults to '1.0'
+   *   and end is 0 when there is no declaration present.
+   */
+  validate(xmlData) {
+    const hasDecl = xmlData.startsWith('<?xml');
+
+    if (!hasDecl) {
+      if (!this.optional) {
+        this._throwError('InvalidXml', 'XML declaration is required but missing.', { line: 1, col: 1 });
+      }
+      return { version: '1.0', end: 0 };
+    }
+
+    const piEnd = xmlData.indexOf('?>');
+    if (piEnd === -1) {
+      this._throwError('InvalidXml', 'XML declaration is not closed with "?>".', { line: 1, col: 1 });
+    }
+
+    const declBody = xmlData.substring(5, piEnd);
+    const end = piEnd + 2;
+
+    const ALLOWED = ['version', 'encoding', 'standalone'];
+    const attrRe = /\s+([\w]+)\s*=\s*(?:"([^"]*)"|'([^']*)')/g;
+
+    let version = '1.0';
+    let lastAllowedIdx = -1;
+    let match;
+
+    while ((match = attrRe.exec(declBody)) !== null) {
+      const attrName = match[1];
+      const attrValue = match[2] !== undefined ? match[2] : match[3];
+      const attrPos = match.index;
+
+      const allowedIdx = ALLOWED.indexOf(attrName);
+      if (allowedIdx === -1) {
+        this._throwError('InvalidXml',
+          'XML declaration contains unknown attribute "' + attrName + '". Allowed: version, encoding, standalone.',
+          { line: 1, col: 6 + attrPos });
+      }
+
+      if (this.argPosition && allowedIdx <= lastAllowedIdx) {
+        this._throwError('InvalidXml',
+          'XML declaration attribute "' + attrName + '" is out of order. Required order: version, encoding, standalone.',
+          { line: 1, col: 6 + attrPos });
+      }
+      lastAllowedIdx = allowedIdx;
+
+      if (attrName === 'version') {
+        if (attrValue !== '1.0' && attrValue !== '1.1') {
+          this._throwError('InvalidXml',
+            'XML declaration version "' + attrValue + '" is not supported. Must be "1.0" or "1.1".',
+            { line: 1, col: 6 + attrPos });
+        }
+        version = attrValue;
+      } else if (attrName === 'standalone') {
+        if (attrValue !== 'yes' && attrValue !== 'no') {
+          this._throwError('InvalidXml',
+            'XML declaration standalone "' + attrValue + '" is invalid. Must be "yes" or "no".',
+            { line: 1, col: 6 + attrPos });
+        }
+      }
+      // encoding: value format validation is out of scope
+    }
+
+    const leftover = declBody.replace(/\s+[\w]+\s*=\s*(?:"[^"]*"|'[^']*')/g, '').trim();
+    if (leftover.length > 0) {
+      this._throwError('InvalidXml',
+        'XML declaration contains invalid content: "' + leftover + '".',
+        { line: 1, col: 1 });
+    }
+
+    return { version, end };
+  }
+}

package/src/validators/XmlNameValidator.js

@@ -0,0 +1,24 @@
+'use strict';
+
+import { createValidator } from 'xml-naming';
+
+/**
+ * XmlNameValidator — single responsibility: expose XML Name / QName
+ * validators for a given xmlVersion, memoized per instance since element
+ * and attribute names repeat heavily across a document.
+ */
+export default class XmlNameValidator {
+  constructor(xmlVersion = '1.0') {
+    this.xmlVersion = xmlVersion;
+    this.qName = createValidator('qName', { xmlVersion });
+    this.name = createValidator('name', { xmlVersion });
+  }
+
+  isValidQName(value) {
+    return this.qName(value);
+  }
+
+  isValidName(value) {
+    return this.name(value);
+  }
+}