@swagger-api/apidom-core 0.76.1 → 0.77.0

package/es/clone/errors/CloneError.mjs

@@ -0,0 +1,3 @@
+import { ApiDOMStructuredError } from '@swagger-api/apidom-error';
+class CloneError extends ApiDOMStructuredError {}
+export default CloneError;

package/es/clone/errors/DeepCloneError.mjs

@@ -0,0 +1,3 @@
+import CloneError from "./CloneError.mjs";
+class DeepCloneError extends CloneError {}
+export default DeepCloneError;

package/es/clone/errors/ShallowCloneError.mjs

@@ -0,0 +1,3 @@
+import CloneError from "./CloneError.mjs";
+class ShallowCloneError extends CloneError {}
+export default ShallowCloneError;

package/es/clone/index.mjs

@@ -0,0 +1,98 @@
+import { ArraySlice, ObjectSlice, KeyValuePair } from 'minim';
+import { isElement } from "../predicates/index.mjs";
+import DeepCloneError from "./errors/DeepCloneError.mjs";
+import ShallowCloneError from "./errors/ShallowCloneError.mjs";
+const invokeClone = value => {
+  if (typeof (value === null || value === void 0 ? void 0 : value.clone) === 'function') {
+    return value.clone();
+  }
+  return value;
+};
+export const cloneDeep = value => {
+  if (value instanceof ObjectSlice) {
+    const items = [...value].map(invokeClone);
+    return new ObjectSlice(items);
+  }
+  if (value instanceof ArraySlice) {
+    const items = [...value].map(invokeClone);
+    return new ArraySlice(items);
+  }
+  if (typeof (value === null || value === void 0 ? void 0 : value.clone) === 'function') {
+    return value.clone();
+  }
+  throw new DeepCloneError("Value provided to cloneDeep function couldn't be cloned", {
+    value
+  });
+};
+cloneDeep.safe = value => {
+  try {
+    return cloneDeep(value);
+  } catch {
+    return value;
+  }
+};
+const cloneShallowKeyValuePair = keyValuePair => {
+  const {
+    key,
+    value
+  } = keyValuePair;
+  return new KeyValuePair(key, value);
+};
+const cloneShallowArraySlice = arraySlice => {
+  const items = [...arraySlice];
+  return new ArraySlice(items);
+};
+const cloneShallowObjectSlice = objectSlice => {
+  const items = [...objectSlice];
+  return new ObjectSlice(items);
+};
+
+/* eslint-disable no-underscore-dangle */
+const cloneShallowElement = element => {
+  // @ts-ignore
+  const copy = new element.constructor();
+  copy.element = element.element;
+  if (element.meta.length > 0) {
+    copy._meta = cloneDeep(element.meta);
+  }
+  if (element.attributes.length > 0) {
+    copy._attributes = cloneDeep(element.attributes);
+  }
+  if (isElement(element.content)) {
+    const content = element.content;
+    copy.content = cloneShallowElement(content);
+  } else if (Array.isArray(element.content)) {
+    copy.content = [...element.content];
+  } else if (element.content instanceof KeyValuePair) {
+    copy.content = cloneShallowKeyValuePair(element.content);
+  } else {
+    copy.content = element.content;
+  }
+  return copy;
+};
+/* eslint-enable */
+
+export const cloneShallow = value => {
+  if (value instanceof KeyValuePair) {
+    return cloneShallowKeyValuePair(value);
+  }
+  if (value instanceof ObjectSlice) {
+    return cloneShallowObjectSlice(value);
+  }
+  if (value instanceof ArraySlice) {
+    return cloneShallowArraySlice(value);
+  }
+  if (isElement(value)) {
+    return cloneShallowElement(value);
+  }
+  throw new ShallowCloneError("Value provided to cloneShallow function couldn't be cloned", {
+    value
+  });
+};
+cloneShallow.safe = value => {
+  try {
+    return cloneShallow(value);
+  } catch {
+    return value;
+  }
+};

package/es/{deepmerge.js → deepmerge.mjs}

@@ -1,17 +1,15 @@
-import _defineProperty from "@babel/runtime-corejs3/helpers/esm/defineProperty";
-function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
-function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
-import { ObjectElement, MemberElement } from 'minim';
-import { isObjectElement, isArrayElement } from "./predicates/index.js";
+import { ObjectElement } from 'minim';
+import { isObjectElement, isArrayElement } from "./predicates/index.mjs";
+import { cloneDeep, cloneShallow } from "./clone/index.mjs";
+import toValue from "./transformers/serializers/value/index.mjs";
 /* eslint-disable @typescript-eslint/no-use-before-define */
 const emptyElement = element => {
-  const meta = element.meta.clone();
-  const attributes = element.attributes.clone();
+  const meta = cloneDeep(element.meta);
+  const attributes = cloneDeep(element.attributes);
 
   // @ts-ignore
   return new element.constructor(undefined, meta, attributes);
 };
-const cloneMemberElement = memberElement => new MemberElement(memberElement.key, memberElement.value, memberElement.meta.clone(), memberElement.attributes.clone());
 const cloneUnlessOtherwiseSpecified = (element, options) => options.clone && options.isMergeableElement(element) ? deepmerge(emptyElement(element), element, options) : element;
 const getMergeFunction = (keyElement, options) => {
   if (typeof options.customMerge !== 'function') {
@@ -25,20 +23,20 @@ const mergeObjectElement = (targetElement, sourceElement, options) => {
   const destination = isObjectElement(targetElement) ? emptyElement(targetElement) : emptyElement(sourceElement);
   if (isObjectElement(targetElement)) {
     targetElement.forEach((value, key, member) => {
-      const clonedMember = cloneMemberElement(member);
+      const clonedMember = cloneShallow(member);
       clonedMember.value = cloneUnlessOtherwiseSpecified(value, options);
       destination.content.push(clonedMember);
     });
   }
   sourceElement.forEach((value, key, member) => {
-    const keyValue = key.toValue();
+    const keyValue = toValue(key);
     let clonedMember;
     if (isObjectElement(targetElement) && targetElement.hasKey(keyValue) && options.isMergeableElement(value)) {
       const targetValue = targetElement.get(keyValue);
-      clonedMember = cloneMemberElement(member);
+      clonedMember = cloneShallow(member);
       clonedMember.value = getMergeFunction(key, options)(targetValue, value);
     } else {
-      clonedMember = cloneMemberElement(member);
+      clonedMember = cloneShallow(member);
       clonedMember.value = cloneUnlessOtherwiseSpecified(value, options);
     }
     destination.remove(keyValue);
@@ -55,7 +53,10 @@ export default function deepmerge(targetElement, sourceElement, options) {
     objectElementMerge: mergeObjectElement,
     customMerge: undefined
   };
-  const mergedOptions = _objectSpread(_objectSpread({}, defaultOptions), options);
+  const mergedOptions = {
+    ...defaultOptions,
+    ...options
+  };
   mergedOptions.isMergeableElement = (_mergedOptions$isMerg = mergedOptions.isMergeableElement) !== null && _mergedOptions$isMerg !== void 0 ? _mergedOptions$isMerg : defaultOptions.isMergeableElement;
   mergedOptions.arrayElementMerge = (_mergedOptions$arrayE = mergedOptions.arrayElementMerge) !== null && _mergedOptions$arrayE !== void 0 ? _mergedOptions$arrayE : defaultOptions.arrayElementMerge;
   mergedOptions.objectElementMerge = (_mergedOptions$object = mergedOptions.objectElementMerge) !== null && _mergedOptions$object !== void 0 ? _mergedOptions$object : defaultOptions.objectElementMerge;

package/es/index.mjs

@@ -0,0 +1,46 @@
+export { dispatchPlugins as dispatchRefractorPlugins } from "./refractor/plugins/utils/index.mjs";
+export { default as refractorPluginElementIdentity } from "./refractor/plugins/element-identity.mjs";
+export { default as refractorPluginSemanticElementIdentity } from "./refractor/plugins/semantic-element-identity.mjs";
+export { default as MediaTypes } from "./media-types.mjs";
+export { Element, MemberElement, KeyValuePair, ObjectSlice, ArraySlice, refract } from 'minim';
+export { default as namespace, Namespace, createNamespace } from "./namespace.mjs";
+export { ObjectElement, ArrayElement, BooleanElement, NullElement, NumberElement, StringElement, LinkElement, RefElement, AnnotationElement, CommentElement, ParseResultElement, SourceMapElement } from "./refractor/registration.mjs";
+export { isElement, isStringElement, isNumberElement, isNullElement, isBooleanElement, isArrayElement, isObjectElement, isMemberElement, isLinkElement, isRefElement, isAnnotationElement, isParseResultElement, isSourceMapElement, isPrimitiveElement, hasElementSourceMap, includesSymbols, includesClasses } from "./predicates/index.mjs";
+export { default as createPredicate } from "./predicates/helpers.mjs";
+export { filter, reject, find, findAtOffset, some, traverse, parents } from "./traversal/index.mjs";
+export { visit, BREAK, mergeAllVisitors, getNodeType, cloneNode, keyMapDefault as keyMap } from "./traversal/visitor.mjs";
+export { transclude, default as Transcluder } from "./transcluder/index.mjs";
+export { dereference } from "./util.mjs";
+export { cloneShallow, cloneDeep } from "./clone/index.mjs";
+export { default as CloneError } from "./clone/errors/CloneError.mjs";
+export { default as DeepCloneError } from "./clone/errors/DeepCloneError.mjs";
+export { default as ShallowCloneError } from "./clone/errors/ShallowCloneError.mjs";
+/**
+ * Transforms data to an Element from a particular namespace.
+ */
+export { default as from } from "./transformers/from.mjs";
+/**
+ * Transforms the ApiDOM into JavaScript POJO.
+ * This POJO would be the result of interpreting the ApiDOM
+ * into JavaScript structure.
+ */
+export { default as toValue } from "./transformers/serializers/value/index.mjs";
+/**
+ * Transforms the ApiDOM into JSON string.
+ */
+export { default as toJSON } from "./transformers/serializers/json.mjs";
+/**
+ * Transforms the ApiDOM into YAML string.
+ */
+export { default as toYAML } from "./transformers/serializers/yaml-1-2.mjs";
+/**
+ * Creates a refract representation of an Element.
+ * https://github.com/refractproject/refract-spec
+ */
+export { default as dehydrate } from "./transformers/dehydrate.mjs";
+/**
+ * Create a refracted string representation of an Element.
+ */
+export { default as toString } from "./transformers/to-string.mjs";
+export { default as sexprs } from "./transformers/sexprs.mjs";
+export { default as deepmerge } from "./deepmerge.mjs";

package/es/{media-types.js → media-types.mjs}

@@ -1,10 +1,7 @@
-import _defineProperty from "@babel/runtime-corejs3/helpers/esm/defineProperty";
 import { NotImplementedError } from '@swagger-api/apidom-error';
 class MediaTypes extends Array {
-  constructor(...args) {
-    super(...args);
-    _defineProperty(this, "unknownMediaType", 'application/octet-stream');
-  }
+  unknownMediaType = 'application/octet-stream';
+
   // eslint-disable-next-line class-methods-use-this
   filterByFormat() {
     throw new NotImplementedError('"filterByFormat" method is not implemented.');

package/es/{namespace.js → namespace.mjs}

@@ -1,9 +1,9 @@
 import { Namespace as MinimNamespace } from 'minim';
 import { isPlainObject } from 'ramda-adjunct';
-import AnnotationElement from "./elements/Annotation.js";
-import CommentElement from "./elements/Comment.js";
-import ParseResultElement from "./elements/ParseResult.js";
-import SourceMapElement from "./elements/SourceMap.js";
+import AnnotationElement from "./elements/Annotation.mjs";
+import CommentElement from "./elements/Comment.mjs";
+import ParseResultElement from "./elements/ParseResult.mjs";
+import SourceMapElement from "./elements/SourceMap.mjs";
 export class Namespace extends MinimNamespace {
   constructor() {
     super();

package/es/predicates/{index.js → index.mjs}

@@ -1,11 +1,11 @@
 import { Element, StringElement, NumberElement, NullElement, BooleanElement, ArrayElement, ObjectElement, MemberElement, LinkElement, RefElement } from 'minim';
 import { all } from 'ramda';
 import { included } from 'ramda-adjunct';
-import AnnotationElement from "../elements/Annotation.js";
-import CommentElement from "../elements/Comment.js";
-import ParserResultElement from "../elements/ParseResult.js";
-import SourceMapElement from "../elements/SourceMap.js";
-import createPredicate, { isElementType as isElementTypeHelper } from "./helpers.js";
+import AnnotationElement from "../elements/Annotation.mjs";
+import CommentElement from "../elements/Comment.mjs";
+import ParserResultElement from "../elements/ParseResult.mjs";
+import SourceMapElement from "../elements/SourceMap.mjs";
+import createPredicate, { isElementType as isElementTypeHelper } from "./helpers.mjs";
 export const isElement = createPredicate(({
   hasBasicElementProps,
   primitiveEq

package/es/refractor/index.mjs

@@ -0,0 +1,30 @@
+import { dispatchPlugins } from "./plugins/utils/index.mjs";
+import { getNodeType } from "../traversal/visitor.mjs";
+import createToolbox from "./toolbox.mjs";
+const refract = (value, {
+  Type,
+  plugins = []
+}) => {
+  /**
+   * This is where values gets refracted into generic ApiDOM.
+   * We don't allow consumers to hook into this translation.
+   * Though we allow consumers to define their onw plugins on already transformed ApiDOM.
+   */
+  const element = new Type(value);
+
+  /**
+   * Run plugins only when necessary.
+   * Running plugins visitors means extra single traversal === performance hit.
+   */
+  return dispatchPlugins(element, plugins, {
+    toolboxCreator: createToolbox,
+    visitorOptions: {
+      nodeTypeGetter: getNodeType
+    }
+  });
+};
+export const createRefractor = Type => (value, options = {}) => refract(value, {
+  ...options,
+  Type
+});
+export default refract;

package/es/refractor/plugins/utils/{index.js → index.mjs}

@@ -1,7 +1,7 @@
 import { propOr } from 'ramda';
 import { invokeArgs } from 'ramda-adjunct';
-import createToolbox from "../../toolbox.js";
-import { getNodeType, mergeAllVisitors, visit } from "../../../traversal/visitor.js"; // eslint-disable-next-line import/prefer-default-export
+import createToolbox from "../../toolbox.mjs";
+import { getNodeType, mergeAllVisitors, visit } from "../../../traversal/visitor.mjs"; // eslint-disable-next-line import/prefer-default-export
 export const dispatchPlugins = (element, plugins, options = {}) => {
   if (plugins.length === 0) return element;
   const toolboxCreator = propOr(createToolbox, 'toolboxCreator', options);

package/es/refractor/{registration.js → registration.mjs}

@@ -1,9 +1,9 @@
 import { ObjectElement, ArrayElement, StringElement, BooleanElement, NullElement, NumberElement, LinkElement, RefElement } from 'minim';
-import AnnotationElement from "../elements/Annotation.js";
-import CommentElement from "../elements/Comment.js";
-import ParseResultElement from "../elements/ParseResult.js";
-import SourceMapElement from "../elements/SourceMap.js";
-import { createRefractor } from "./index.js";
+import AnnotationElement from "../elements/Annotation.mjs";
+import CommentElement from "../elements/Comment.mjs";
+import ParseResultElement from "../elements/ParseResult.mjs";
+import SourceMapElement from "../elements/SourceMap.mjs";
+import { createRefractor } from "./index.mjs";
 ObjectElement.refract = createRefractor(ObjectElement);
 ArrayElement.refract = createRefractor(ArrayElement);
 StringElement.refract = createRefractor(StringElement);

package/es/refractor/toolbox.mjs

@@ -0,0 +1,12 @@
+import * as basePredicates from "../predicates/index.mjs";
+import defaultNamespaceInstance from "../namespace.mjs";
+const createToolbox = () => {
+  const predicates = {
+    ...basePredicates
+  };
+  return {
+    predicates,
+    namespace: defaultNamespaceInstance
+  };
+};
+export default createToolbox;

package/es/transcluder/{Transcluder.js → Transcluder.mjs}

@@ -1,6 +1,6 @@
 import stampit from 'stampit';
 import { isUndefined } from 'ramda-adjunct';
-import { isObjectElement, isArrayElement, isMemberElement } from "../predicates/index.js";
+import { isObjectElement, isArrayElement, isMemberElement } from "../predicates/index.mjs";
 const computeEdges = (element, edges = new WeakMap()) => {
   if (isMemberElement(element)) {
     // @ts-ignore

package/es/transcluder/{index.js → index.mjs}

@@ -1,4 +1,4 @@
-import Transcluder from "./Transcluder.js";
+import Transcluder from "./Transcluder.mjs";
 /**
  * This is a mutating function. If you don't want your Element to be mutated,
  * clone in before passing it to this function.

package/es/transformers/dehydrate.mjs

@@ -0,0 +1,9 @@
+import defaultNamespaceInstance from "../namespace.mjs";
+/**
+ * Creates a refract representation of an Element.
+ * https://github.com/refractproject/refract-spec
+ */
+const dehydrate = (element, namespace = defaultNamespaceInstance) => {
+  return namespace.toRefract(element);
+};
+export default dehydrate;

package/es/transformers/from.mjs

@@ -0,0 +1,22 @@
+import { has } from 'ramda';
+import { isPlainObject, isString } from 'ramda-adjunct';
+import defaultNamespaceInstance from "../namespace.mjs";
+/**
+ * Transforms data to an Element from a particular namespace.
+ */
+const from = (data, namespace = defaultNamespaceInstance) => {
+  if (isString(data)) {
+    // JSON serialized refract
+    try {
+      return namespace.fromRefract(JSON.parse(data));
+    } catch {
+      // noop
+    }
+  }
+  if (isPlainObject(data) && has('element', data)) {
+    // refract javascript structure
+    return namespace.fromRefract(data);
+  }
+  return namespace.toElement(data);
+};
+export default from;

package/es/{serializers/json.js → transformers/serializers/json.mjs}

@@ -1,3 +1,3 @@
-import serializeValue from "./value/index.js";
+import serializeValue from "./value/index.mjs";
 const serializer = (element, replacer, space) => JSON.stringify(serializeValue(element), replacer, space);
 export default serializer;

package/es/transformers/serializers/value/ast/ephemeral-array.mjs

@@ -0,0 +1,17 @@
+class EphemeralArray {
+  type = 'EphemeralArray';
+  content = [];
+  reference = undefined;
+  constructor(content) {
+    this.content = content;
+    this.reference = [];
+  }
+  toReference() {
+    return this.reference;
+  }
+  toArray() {
+    this.reference.push(...this.content);
+    return this.reference;
+  }
+}
+export default EphemeralArray;

package/es/transformers/serializers/value/ast/ephemeral-object.mjs

@@ -0,0 +1,16 @@
+class EphemeralObject {
+  type = 'EphemeralObject';
+  content = [];
+  reference = undefined;
+  constructor(content) {
+    this.content = content;
+    this.reference = {};
+  }
+  toReference() {
+    return this.reference;
+  }
+  toObject() {
+    return Object.assign(this.reference, Object.fromEntries(this.content));
+  }
+}
+export default EphemeralObject;

package/es/{serializers/value/index.js → transformers/serializers/value/index.mjs}

@@ -1,7 +1,8 @@
 import stampit from 'stampit';
-import { visit } from "./visitor.js";
-import EphemeralArray from "./ast/ephemeral-array.js";
-import EphemeralObject from "./ast/ephemeral-object.js";
+import { visit } from "./visitor.mjs";
+import EphemeralArray from "./ast/ephemeral-array.mjs";
+import EphemeralObject from "./ast/ephemeral-object.mjs";
+import { isElement, isBooleanElement, isNumberElement, isStringElement, isNullElement } from "../../../predicates/index.mjs";
 /* eslint-disable @typescript-eslint/naming-convention */
 const Visitor = stampit.init(function _Visitor() {
   const references = new WeakMap();
@@ -56,6 +57,12 @@ const Visitor = stampit.init(function _Visitor() {
 /* eslint-enable */
 
 const serializer = element => {
+  if (!isElement(element)) return element;
+
+  // shortcut optimization for certain element types
+  if (isStringElement(element) || isNumberElement(element) || isBooleanElement(element) || isNullElement(element)) {
+    return element.toValue();
+  }
   return visit(element, Visitor());
 };
 export default serializer;

package/es/transformers/serializers/value/visitor.mjs

@@ -0,0 +1,49 @@
+import { T as stubTrue } from 'ramda';
+import { visit as astVisit, keyMapDefault as baseKeyMap, getNodeType as baseGetNodeType } from "../../../traversal/visitor.mjs";
+const nodeTypeGetter = node => {
+  if (typeof (node === null || node === void 0 ? void 0 : node.type) === 'string') {
+    return node.type;
+  }
+  return baseGetNodeType(node);
+};
+const keyMapDefault = {
+  EphemeralObject: ['content'],
+  EphemeralArray: ['content'],
+  ...baseKeyMap
+};
+
+// eslint-disable-next-line import/prefer-default-export
+export const visit = (root,
+// @ts-ignore
+visitor, {
+  keyMap = keyMapDefault,
+  ...rest
+} = {}) => {
+  return astVisit(root, visitor, {
+    keyMap,
+    // @ts-ignore
+    nodeTypeGetter,
+    nodePredicate: stubTrue,
+    detectCycles: false,
+    deleteNodeSymbol: Symbol.for('delete-node'),
+    skipVisitingNodeSymbol: Symbol.for('skip-visiting-node'),
+    ...rest
+  });
+};
+
+// @ts-ignore
+visit[Symbol.for('nodejs.util.promisify.custom')] = async (root, {
+  keyMap = keyMapDefault,
+  ...rest
+} = {}) => {
+  // @ts-ignore
+  return astVisit[Symbol.for('nodejs.util.promisify.custom')](root, visitor, {
+    keyMap,
+    nodeTypeGetter,
+    nodePredicate: stubTrue,
+    detectCycles: false,
+    deleteNodeSymbol: Symbol.for('delete-node'),
+    skipVisitingNodeSymbol: Symbol.for('skip-visiting-node'),
+    ...rest
+  });
+};

package/es/{serializers/yaml-1-2.js → transformers/serializers/yaml-1-2.mjs}

@@ -1,6 +1,6 @@
 import stampit from 'stampit';
-import { visit } from "../traversal/visitor.js";
-import serializeValue from "./value/index.js";
+import { visit } from "../../traversal/visitor.mjs";
+import serializeValue from "./value/index.mjs";
 const YamlVisitor = stampit({
   props: {
     result: '',

package/es/{sexprs.js → transformers/sexprs.mjs}

@@ -1,5 +1,5 @@
 import stampit from 'stampit';
-import { visit } from "./traversal/visitor.js";
+import { visit } from "../traversal/visitor.mjs";
 const SymbolicExpressionsVisitor = stampit({
   props: {
     nestingLevel: 0,

package/es/transformers/to-string.mjs

@@ -0,0 +1,10 @@
+import defaultNamespaceInstance from "../namespace.mjs";
+import dehydrate from "./dehydrate.mjs";
+/**
+ * Create a refracted string representation of an Element.
+ */
+const toString = (element, namespace = defaultNamespaceInstance) => {
+  const refractStructure = dehydrate(element, namespace);
+  return JSON.stringify(refractStructure);
+};
+export default toString;

package/es/traversal/{filter.js → filter.mjs}

@@ -1,5 +1,5 @@
 import { ArraySlice } from 'minim';
-import { PredicateVisitor, visit } from "./visitor.js"; // finds all elements matching the predicate
+import { PredicateVisitor, visit } from "./visitor.mjs"; // finds all elements matching the predicate
 const filter = (predicate, element) => {
   const visitor = PredicateVisitor({
     predicate

package/es/traversal/{find.js → find.mjs}

@@ -1,5 +1,5 @@
 import { pathOr } from 'ramda';
-import { PredicateVisitor, BREAK, visit } from "./visitor.js"; // find first element that satisfies the provided predicate
+import { PredicateVisitor, BREAK, visit } from "./visitor.mjs"; // find first element that satisfies the provided predicate
 const find = (predicate, element) => {
   const visitor = PredicateVisitor({
     predicate,

package/es/traversal/{findAtOffset.js → findAtOffset.mjs}

@@ -1,8 +1,9 @@
 import stampit from 'stampit';
 import { last, pathOr } from 'ramda';
 import { isNumber } from 'ramda-adjunct';
-import { hasElementSourceMap } from "../predicates/index.js";
-import { visit } from "./visitor.js";
+import { hasElementSourceMap } from "../predicates/index.mjs";
+import { visit } from "./visitor.mjs";
+import toValue from "../transformers/serializers/value/index.mjs";
 const Visitor = stampit({
   props: {
     result: [],
@@ -25,8 +26,8 @@ const Visitor = stampit({
       }
 
       const sourceMapElement = element.getMetaProperty('sourceMap');
-      const charStart = sourceMapElement.positionStart.get(2).toValue();
-      const charEnd = sourceMapElement.positionEnd.get(2).toValue();
+      const charStart = toValue(sourceMapElement.positionStart.get(2));
+      const charEnd = toValue(sourceMapElement.positionEnd.get(2));
       const isWithinOffsetRange = this.offset >= charStart && (this.offset < charEnd || this.includeRightBound && this.offset <= charEnd);
       if (isWithinOffsetRange) {
         this.result.push(element);

package/es/traversal/index.mjs

@@ -0,0 +1,7 @@
+export { default as filter } from "./filter.mjs";
+export { default as find } from "./find.mjs";
+export { default as findAtOffset } from "./findAtOffset.mjs";
+export { default as reject } from "./reject.mjs";
+export { default as some } from "./some.mjs";
+export { default as traverse } from "./traverse.mjs";
+export { default as parents } from "./parents.mjs";

package/es/traversal/{parents.js → parents.mjs}

@@ -1,5 +1,5 @@
 import stampit from 'stampit';
-import { visit } from "./visitor.js";
+import { visit } from "./visitor.mjs";
 /* eslint-disable no-param-reassign */
 const Visitor = stampit({
   props: {

package/es/traversal/{reject.js → reject.mjs}

@@ -1,5 +1,5 @@
 import { complement } from 'ramda';
-import filter from "./filter.js"; // complement of filter
+import filter from "./filter.mjs"; // complement of filter
 const reject = (predicate, element) => {
   return filter(complement(predicate), element);
 };

package/es/traversal/{some.js → some.mjs}

@@ -1,5 +1,5 @@
 import { isNotUndefined } from 'ramda-adjunct';
-import find from "./find.js"; // tests whether at least one element passes the predicate
+import find from "./find.mjs"; // tests whether at least one element passes the predicate
 const some = (predicate, element) => {
   return isNotUndefined(find(predicate, element));
 };

package/es/traversal/{traverse.js → traverse.mjs}

@@ -1,8 +1,8 @@
 import stampit from 'stampit';
 import { pathOr } from 'ramda';
 import { isFunction, noop } from 'ramda-adjunct';
-import { visit, PredicateVisitor } from "./visitor.js";
-import { isElement } from "../predicates/index.js";
+import { visit, PredicateVisitor } from "./visitor.mjs";
+import { isElement } from "../predicates/index.mjs";
 export const CallbackVisitor = stampit(PredicateVisitor, {
   props: {
     callback: noop