@speclynx/apidom-ns-openapi-3-0 4.0.1 → 4.0.3

package/src/refractor/visitors/FallbackVisitor.ts

@@ -0,0 +1,24 @@
+import { Element, cloneDeep } from '@speclynx/apidom-datamodel';
+import { Path } from '@speclynx/apidom-traverse';
+
+import Visitor, { VisitorOptions } from './Visitor.ts';
+
+/**
+ * This visitor is responsible for falling back to current traversed element
+ * Given OpenApi3_0Visitor expects ObjectElement to be traversed. If
+ * different Element is provided FallBackVisitor is responsible to assigning
+ * this Element as current element.
+ */
+export type { VisitorOptions as FallbackVisitorOptions };
+
+/**
+ * @public
+ */
+class FallbackVisitor extends Visitor {
+  enter(path: Path<Element>) {
+    this.element = this.consume ? path.node : cloneDeep(path.node);
+    path.stop();
+  }
+}
+
+export default FallbackVisitor;

package/src/refractor/visitors/SpecificationExtensionVisitor.cjs

@@ -0,0 +1,18 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+exports.default = void 0;
+var _apidomDatamodel = require("@speclynx/apidom-datamodel");
+var _SpecificationVisitor = _interopRequireDefault(require("./SpecificationVisitor.cjs"));
+/**
+ * @public
+ */
+class SpecificationExtensionVisitor extends _SpecificationVisitor.default {
+  MemberElement(path) {
+    this.element = (0, _apidomDatamodel.cloneDeep)(path.node);
+    this.element.classes.push('specification-extension');
+    path.stop();
+  }
+}
+var _default = exports.default = SpecificationExtensionVisitor;

package/src/refractor/visitors/SpecificationExtensionVisitor.mjs

@@ -0,0 +1,13 @@
+import { cloneDeep } from '@speclynx/apidom-datamodel';
+import SpecificationVisitor from "./SpecificationVisitor.mjs";
+/**
+ * @public
+ */
+class SpecificationExtensionVisitor extends SpecificationVisitor {
+  MemberElement(path) {
+    this.element = cloneDeep(path.node);
+    this.element.classes.push('specification-extension');
+    path.stop();
+  }
+}
+export default SpecificationExtensionVisitor;

package/src/refractor/visitors/SpecificationExtensionVisitor.ts

@@ -0,0 +1,22 @@
+import { MemberElement, cloneDeep } from '@speclynx/apidom-datamodel';
+import { Path } from '@speclynx/apidom-traverse';
+
+import SpecificationVisitor, { SpecificationVisitorOptions } from './SpecificationVisitor.ts';
+
+export type { SpecificationVisitorOptions as SpecificationExtensionVisitorOptions };
+
+/**
+ * @public
+ */
+class SpecificationExtensionVisitor extends SpecificationVisitor {
+  declare public element: MemberElement;
+
+  MemberElement(path: Path<MemberElement>) {
+    this.element = cloneDeep(path.node);
+    this.element.classes.push('specification-extension');
+
+    path.stop();
+  }
+}
+
+export default SpecificationExtensionVisitor;

package/src/refractor/visitors/SpecificationVisitor.cjs

@@ -0,0 +1,88 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+exports.default = void 0;
+var _ramda = require("ramda");
+var _ramdaAdjunct = require("ramda-adjunct");
+var _apidomDatamodel = require("@speclynx/apidom-datamodel");
+var _apidomTraverse = require("@speclynx/apidom-traverse");
+var _Visitor = _interopRequireDefault(require("./Visitor.cjs"));
+var _FallbackVisitor = _interopRequireDefault(require("./FallbackVisitor.cjs"));
+/**
+ * This is a base Type for every visitor that does
+ * internal look-ups to retrieve other child visitors.
+ * @public
+ */
+
+/**
+ * @public
+ */
+class SpecificationVisitor extends _Visitor.default {
+  specObj;
+  passingOptionsNames = ['specObj', 'openApiGenericElement', 'sourceContext', 'openApiSemanticElement', 'consume'];
+  openApiGenericElement;
+  sourceContext;
+  openApiSemanticElement;
+  constructor({
+    specObj,
+    passingOptionsNames,
+    openApiGenericElement,
+    openApiSemanticElement,
+    ...rest
+  }) {
+    super({
+      ...rest
+    });
+    this.specObj = specObj;
+    this.openApiGenericElement = openApiGenericElement;
+    this.openApiSemanticElement = openApiSemanticElement;
+    if (Array.isArray(passingOptionsNames)) {
+      this.passingOptionsNames = passingOptionsNames;
+    }
+  }
+  retrievePassingOptions() {
+    return (0, _ramda.pick)(this.passingOptionsNames, this);
+  }
+  retrieveFixedFields(specPath) {
+    const fixedFields = (0, _ramda.path)(['visitors', ...specPath, 'fixedFields'], this.specObj);
+    if (typeof fixedFields === 'object' && fixedFields !== null) {
+      return Object.keys(fixedFields);
+    }
+    return [];
+  }
+  retrieveVisitor(specPath) {
+    if ((0, _ramda.pathSatisfies)(_ramdaAdjunct.isFunction, ['visitors', ...specPath], this.specObj)) {
+      return (0, _ramda.path)(['visitors', ...specPath], this.specObj);
+    }
+    return (0, _ramda.path)(['visitors', ...specPath, '$visitor'], this.specObj);
+  }
+  retrieveVisitorInstance(specPath, options = {}) {
+    const passingOpts = this.retrievePassingOptions();
+    const VisitorClz = this.retrieveVisitor(specPath);
+    const visitorOpts = {
+      ...passingOpts,
+      ...options
+    };
+    return new VisitorClz(visitorOpts);
+  }
+  toRefractedElement(specPath, element, options = {}) {
+    /**
+     * This is `Visitor shortcut`: a mechanism for short-circuiting the traversal and replacing
+     * it by basic node cloning.
+     *
+     * Visiting the element is equivalent to cloning it if the prototype of a visitor
+     * is the same as the prototype of FallbackVisitor. If that's the case, we can avoid
+     * bootstrapping the traversal cycle for fields that don't require any special visiting.
+     */
+    const visitor = this.retrieveVisitorInstance(specPath, options);
+    if (visitor instanceof _FallbackVisitor.default && visitor?.constructor === _FallbackVisitor.default) {
+      return this.consume ? element : (0, _apidomDatamodel.cloneDeep)(element);
+    }
+    (0, _apidomTraverse.traverse)(element, visitor, {
+      nodeTypeGetter: _apidomTraverse.getNodePrimitiveType
+    });
+    return visitor.element;
+  }
+}
+var _default = exports.default = SpecificationVisitor;

package/src/refractor/visitors/SpecificationVisitor.mjs

@@ -0,0 +1,82 @@
+import { pathSatisfies, path, pick } from 'ramda';
+import { isFunction } from 'ramda-adjunct';
+import { cloneDeep } from '@speclynx/apidom-datamodel';
+import { traverse, getNodePrimitiveType } from '@speclynx/apidom-traverse';
+import Visitor from "./Visitor.mjs";
+import FallbackVisitor from "./FallbackVisitor.mjs";
+/**
+ * This is a base Type for every visitor that does
+ * internal look-ups to retrieve other child visitors.
+ * @public
+ */
+/**
+ * @public
+ */
+class SpecificationVisitor extends Visitor {
+  specObj;
+  passingOptionsNames = ['specObj', 'openApiGenericElement', 'sourceContext', 'openApiSemanticElement', 'consume'];
+  openApiGenericElement;
+  sourceContext;
+  openApiSemanticElement;
+  constructor({
+    specObj,
+    passingOptionsNames,
+    openApiGenericElement,
+    openApiSemanticElement,
+    ...rest
+  }) {
+    super({
+      ...rest
+    });
+    this.specObj = specObj;
+    this.openApiGenericElement = openApiGenericElement;
+    this.openApiSemanticElement = openApiSemanticElement;
+    if (Array.isArray(passingOptionsNames)) {
+      this.passingOptionsNames = passingOptionsNames;
+    }
+  }
+  retrievePassingOptions() {
+    return pick(this.passingOptionsNames, this);
+  }
+  retrieveFixedFields(specPath) {
+    const fixedFields = path(['visitors', ...specPath, 'fixedFields'], this.specObj);
+    if (typeof fixedFields === 'object' && fixedFields !== null) {
+      return Object.keys(fixedFields);
+    }
+    return [];
+  }
+  retrieveVisitor(specPath) {
+    if (pathSatisfies(isFunction, ['visitors', ...specPath], this.specObj)) {
+      return path(['visitors', ...specPath], this.specObj);
+    }
+    return path(['visitors', ...specPath, '$visitor'], this.specObj);
+  }
+  retrieveVisitorInstance(specPath, options = {}) {
+    const passingOpts = this.retrievePassingOptions();
+    const VisitorClz = this.retrieveVisitor(specPath);
+    const visitorOpts = {
+      ...passingOpts,
+      ...options
+    };
+    return new VisitorClz(visitorOpts);
+  }
+  toRefractedElement(specPath, element, options = {}) {
+    /**
+     * This is `Visitor shortcut`: a mechanism for short-circuiting the traversal and replacing
+     * it by basic node cloning.
+     *
+     * Visiting the element is equivalent to cloning it if the prototype of a visitor
+     * is the same as the prototype of FallbackVisitor. If that's the case, we can avoid
+     * bootstrapping the traversal cycle for fields that don't require any special visiting.
+     */
+    const visitor = this.retrieveVisitorInstance(specPath, options);
+    if (visitor instanceof FallbackVisitor && visitor?.constructor === FallbackVisitor) {
+      return this.consume ? element : cloneDeep(element);
+    }
+    traverse(element, visitor, {
+      nodeTypeGetter: getNodePrimitiveType
+    });
+    return visitor.element;
+  }
+}
+export default SpecificationVisitor;

package/src/refractor/visitors/SpecificationVisitor.ts

@@ -0,0 +1,112 @@
+import { pathSatisfies, path, pick } from 'ramda';
+import { isFunction } from 'ramda-adjunct';
+import { ObjectElement, cloneDeep } from '@speclynx/apidom-datamodel';
+import { traverse, getNodePrimitiveType } from '@speclynx/apidom-traverse';
+
+import OpenApi3_0Element from '../../elements/OpenApi3-0.ts';
+import Visitor, { VisitorOptions } from './Visitor.ts';
+import type specification from '../specification.ts';
+import FallbackVisitor from './FallbackVisitor.ts';
+
+/**
+ * This is a base Type for every visitor that does
+ * internal look-ups to retrieve other child visitors.
+ * @public
+ */
+export interface SpecificationVisitorOptions extends VisitorOptions {
+  readonly specObj: typeof specification;
+  readonly passingOptionsNames?: string[];
+  readonly openApiGenericElement?: ObjectElement;
+  readonly sourceContext?: Record<string, unknown>;
+  readonly openApiSemanticElement?: OpenApi3_0Element;
+}
+
+/**
+ * @public
+ */
+class SpecificationVisitor extends Visitor {
+  protected readonly specObj: typeof specification;
+
+  protected readonly passingOptionsNames: string[] = [
+    'specObj',
+    'openApiGenericElement',
+    'sourceContext',
+    'openApiSemanticElement',
+    'consume',
+  ];
+
+  protected openApiGenericElement?: ObjectElement;
+
+  protected sourceContext?: Record<string, unknown>;
+
+  protected openApiSemanticElement?: OpenApi3_0Element;
+
+  constructor({
+    specObj,
+    passingOptionsNames,
+    openApiGenericElement,
+    openApiSemanticElement,
+    ...rest
+  }: SpecificationVisitorOptions) {
+    super({ ...rest });
+    this.specObj = specObj;
+    this.openApiGenericElement = openApiGenericElement;
+    this.openApiSemanticElement = openApiSemanticElement;
+
+    if (Array.isArray(passingOptionsNames)) {
+      this.passingOptionsNames = passingOptionsNames;
+    }
+  }
+
+  retrievePassingOptions() {
+    return pick(this.passingOptionsNames as (keyof this)[], this) as unknown as Record<
+      string,
+      unknown
+    >;
+  }
+
+  retrieveFixedFields(specPath: string[]) {
+    const fixedFields = path(['visitors', ...specPath, 'fixedFields'], this.specObj);
+    if (typeof fixedFields === 'object' && fixedFields !== null) {
+      return Object.keys(fixedFields);
+    }
+    return [];
+  }
+
+  retrieveVisitor(specPath: string[]) {
+    if (pathSatisfies(isFunction, ['visitors', ...specPath], this.specObj)) {
+      return path(['visitors', ...specPath], this.specObj);
+    }
+
+    return path(['visitors', ...specPath, '$visitor'], this.specObj);
+  }
+
+  retrieveVisitorInstance(specPath: string[], options = {}): Visitor {
+    const passingOpts = this.retrievePassingOptions();
+    const VisitorClz = this.retrieveVisitor(specPath) as typeof Visitor;
+    const visitorOpts = { ...passingOpts, ...options };
+
+    return new VisitorClz(visitorOpts);
+  }
+
+  toRefractedElement(specPath: string[], element: any, options = {}) {
+    /**
+     * This is `Visitor shortcut`: a mechanism for short-circuiting the traversal and replacing
+     * it by basic node cloning.
+     *
+     * Visiting the element is equivalent to cloning it if the prototype of a visitor
+     * is the same as the prototype of FallbackVisitor. If that's the case, we can avoid
+     * bootstrapping the traversal cycle for fields that don't require any special visiting.
+     */
+    const visitor = this.retrieveVisitorInstance(specPath, options);
+
+    if (visitor instanceof FallbackVisitor && visitor?.constructor === FallbackVisitor) {
+      return this.consume ? element : cloneDeep(element);
+    }
+
+    traverse(element, visitor, { nodeTypeGetter: getNodePrimitiveType });
+    return visitor.element;
+  }
+}
+
+export default SpecificationVisitor;

package/src/refractor/visitors/Visitor.cjs

@@ -0,0 +1,36 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+var _apidomCore = require("@speclynx/apidom-core");
+var _apidomDatamodel = require("@speclynx/apidom-datamodel");
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+class Visitor {
+  element;
+  consume = false;
+  consumeSafe = false;
+  constructor(options = {}) {
+    Object.assign(this, options);
+  }
+  copyMetaAndAttributes(from, to) {
+    if (!from.isMetaEmpty && !to.isMetaEmpty) {
+      to.meta = to.meta.merge(from.meta);
+    } else if (!from.isMetaEmpty) {
+      to.meta = from.meta.cloneDeep();
+    }
+    if (!from.isAttributesEmpty && !to.isAttributesEmpty) {
+      to.attributes = (0, _apidomCore.deepmerge)(to.attributes, from.attributes);
+    } else if (!from.isAttributesEmpty) {
+      to.attributes = (0, _apidomDatamodel.cloneDeep)(from.attributes);
+    }
+    _apidomDatamodel.SourceMapElement.transfer(from, to);
+    _apidomDatamodel.StyleElement.transfer(from, to);
+  }
+}
+var _default = exports.default = Visitor;

package/src/refractor/visitors/Visitor.mjs

@@ -0,0 +1,33 @@
+import { deepmerge } from '@speclynx/apidom-core';
+import { SourceMapElement, StyleElement, cloneDeep } from '@speclynx/apidom-datamodel';
+
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+class Visitor {
+  element;
+  consume = false;
+  consumeSafe = false;
+  constructor(options = {}) {
+    Object.assign(this, options);
+  }
+  copyMetaAndAttributes(from, to) {
+    if (!from.isMetaEmpty && !to.isMetaEmpty) {
+      to.meta = to.meta.merge(from.meta);
+    } else if (!from.isMetaEmpty) {
+      to.meta = from.meta.cloneDeep();
+    }
+    if (!from.isAttributesEmpty && !to.isAttributesEmpty) {
+      to.attributes = deepmerge(to.attributes, from.attributes);
+    } else if (!from.isAttributesEmpty) {
+      to.attributes = cloneDeep(from.attributes);
+    }
+    SourceMapElement.transfer(from, to);
+    StyleElement.transfer(from, to);
+  }
+}
+export default Visitor;

package/src/refractor/visitors/Visitor.ts

@@ -0,0 +1,47 @@
+import { deepmerge } from '@speclynx/apidom-core';
+import {
+  Element,
+  ObjectElement,
+  SourceMapElement,
+  StyleElement,
+  cloneDeep,
+} from '@speclynx/apidom-datamodel';
+
+/**
+ * @public
+ */
+export interface VisitorOptions {
+  readonly consume?: boolean;
+}
+
+/**
+ * @public
+ */
+class Visitor {
+  public element!: Element;
+
+  protected readonly consume: boolean = false;
+
+  protected consumeSafe: boolean = false;
+
+  constructor(options: VisitorOptions = {}) {
+    Object.assign(this, options);
+  }
+
+  public copyMetaAndAttributes(from: Element, to: Element) {
+    if (!from.isMetaEmpty && !to.isMetaEmpty) {
+      to.meta = to.meta.merge(from.meta);
+    } else if (!from.isMetaEmpty) {
+      to.meta = from.meta.cloneDeep();
+    }
+    if (!from.isAttributesEmpty && !to.isAttributesEmpty) {
+      to.attributes = deepmerge(to.attributes, from.attributes) as ObjectElement;
+    } else if (!from.isAttributesEmpty) {
+      to.attributes = cloneDeep(from.attributes);
+    }
+    SourceMapElement.transfer(from, to);
+    StyleElement.transfer(from, to);
+  }
+}
+
+export default Visitor;

package/src/refractor/visitors/generics/AlternatingVisitor.cjs

@@ -0,0 +1,42 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+exports.default = void 0;
+var _ramda = require("ramda");
+var _ramdaAdjunct = require("ramda-adjunct");
+var _SpecificationVisitor = _interopRequireDefault(require("../SpecificationVisitor.cjs"));
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+class AlternatingVisitor extends _SpecificationVisitor.default {
+  alternator;
+  constructor({
+    alternator,
+    ...rest
+  }) {
+    super({
+      ...rest
+    });
+    this.alternator = alternator || [];
+  }
+  enter(path) {
+    const element = path.node;
+    const functions = this.alternator.map(({
+      predicate,
+      specPath
+    }) => (0, _ramda.ifElse)(predicate, (0, _ramda.always)(specPath), _ramdaAdjunct.stubUndefined));
+    const specPath = (0, _ramdaAdjunct.dispatch)(functions)(element);
+    this.element = this.toRefractedElement(specPath, element);
+    path.stop();
+  }
+}
+var _default = exports.default = AlternatingVisitor;

package/src/refractor/visitors/generics/AlternatingVisitor.mjs

@@ -0,0 +1,35 @@
+import { ifElse, always } from 'ramda';
+import { dispatch, stubUndefined } from 'ramda-adjunct';
+import SpecificationVisitor from "../SpecificationVisitor.mjs";
+/**
+ * @public
+ */
+/**
+ * @public
+ */
+/**
+ * @public
+ */
+class AlternatingVisitor extends SpecificationVisitor {
+  alternator;
+  constructor({
+    alternator,
+    ...rest
+  }) {
+    super({
+      ...rest
+    });
+    this.alternator = alternator || [];
+  }
+  enter(path) {
+    const element = path.node;
+    const functions = this.alternator.map(({
+      predicate,
+      specPath
+    }) => ifElse(predicate, always(specPath), stubUndefined));
+    const specPath = dispatch(functions)(element);
+    this.element = this.toRefractedElement(specPath, element);
+    path.stop();
+  }
+}
+export default AlternatingVisitor;

package/src/refractor/visitors/generics/AlternatingVisitor.ts

@@ -0,0 +1,45 @@
+import { ifElse, always } from 'ramda';
+import { dispatch, stubUndefined } from 'ramda-adjunct';
+import { Element } from '@speclynx/apidom-datamodel';
+import { Path } from '@speclynx/apidom-traverse';
+
+import SpecificationVisitor, { SpecificationVisitorOptions } from '../SpecificationVisitor.ts';
+
+/**
+ * @public
+ */
+export type Alternator = { predicate: (element: unknown) => boolean; specPath: string[] };
+
+/**
+ * @public
+ */
+export interface AlternatingVisitorOptions extends SpecificationVisitorOptions {
+  readonly alternator: Alternator[];
+}
+
+/**
+ * @public
+ */
+class AlternatingVisitor extends SpecificationVisitor {
+  protected alternator: Alternator[];
+
+  constructor({ alternator, ...rest }: AlternatingVisitorOptions) {
+    super({ ...rest });
+    this.alternator = alternator || [];
+  }
+
+  enter(path: Path<Element>) {
+    const element = path.node;
+    const functions = this.alternator.map(
+      ({ predicate, specPath }: { predicate: (element: unknown) => boolean; specPath: string[] }) =>
+        ifElse(predicate, always(specPath), stubUndefined),
+    );
+    const specPath = dispatch(functions)(element);
+
+    this.element = this.toRefractedElement(specPath, element);
+
+    path.stop();
+  }
+}
+
+export default AlternatingVisitor;

package/src/refractor/visitors/generics/FixedFieldsVisitor.cjs

@@ -0,0 +1,75 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+exports.default = void 0;
+var _apidomDatamodel = require("@speclynx/apidom-datamodel");
+var _apidomCore = require("@speclynx/apidom-core");
+var _SpecificationVisitor = _interopRequireDefault(require("../SpecificationVisitor.cjs"));
+var _predicates = require("../../predicates.cjs");
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+class FixedFieldsVisitor extends _SpecificationVisitor.default {
+  specPath;
+  ignoredFields;
+  canSupportSpecificationExtensions = true;
+  specificationExtensionPredicate = _predicates.isOpenApiExtension;
+  constructor({
+    specPath,
+    ignoredFields,
+    canSupportSpecificationExtensions,
+    specificationExtensionPredicate,
+    ...rest
+  }) {
+    super({
+      ...rest
+    });
+    this.specPath = specPath;
+    this.ignoredFields = ignoredFields || [];
+    if (typeof canSupportSpecificationExtensions === 'boolean') {
+      this.canSupportSpecificationExtensions = canSupportSpecificationExtensions;
+    }
+    if (typeof specificationExtensionPredicate === 'function') {
+      this.specificationExtensionPredicate = specificationExtensionPredicate;
+    }
+  }
+  ObjectElement(path) {
+    const objectElement = path.node;
+    const specPath = this.specPath(objectElement);
+    const fields = this.retrieveFixedFields(specPath);
+
+    // @ts-ignore
+    objectElement.forEach((value, key, memberElement) => {
+      const keyValue = (0, _apidomCore.toValue)(key);
+      if ((0, _apidomDatamodel.isStringElement)(key) && fields.includes(keyValue) && !this.ignoredFields.includes(keyValue)) {
+        const fixedFieldElement = this.toRefractedElement([...specPath, 'fixedFields', keyValue], value);
+        const newMemberElement = new _apidomDatamodel.MemberElement(this.consume ? key : (0, _apidomDatamodel.cloneDeep)(key), fixedFieldElement);
+        this.copyMetaAndAttributes(memberElement, newMemberElement);
+        this.element.content.push(newMemberElement);
+        // consume: release processed generic subtree
+        if (this.consume && this.consumeSafe && !memberElement.isFrozen) memberElement.value = undefined;
+      } else if (this.canSupportSpecificationExtensions && this.specificationExtensionPredicate(memberElement)) {
+        const extensionElement = this.toRefractedElement(['document', 'extension'], memberElement);
+        this.element.content.push(extensionElement);
+        // consume: release processed generic subtree
+        if (this.consume && this.consumeSafe && !memberElement.isFrozen) {
+          memberElement.value = undefined;
+        }
+      } else if (!this.ignoredFields.includes(keyValue)) {
+        this.element.content.push(this.consume ? memberElement : (0, _apidomDatamodel.cloneDeep)(memberElement));
+      }
+    });
+    this.copyMetaAndAttributes(objectElement, this.element);
+    path.stop();
+  }
+}
+var _default = exports.default = FixedFieldsVisitor;