@speclynx/apidom-core 4.0.1 → 4.0.3

package/src/media-types.mjs

@@ -0,0 +1,18 @@
+import { NotImplementedError } from '@speclynx/apidom-error';
+
+/**
+ * @public
+ */
+class MediaTypes extends Array {
+  unknownMediaType = 'application/octet-stream';
+  filterByFormat() {
+    throw new NotImplementedError('filterByFormat method in MediaTypes class is not yet implemented.');
+  }
+  findBy() {
+    throw new NotImplementedError('findBy method in MediaTypes class is not yet implemented.');
+  }
+  latest() {
+    throw new NotImplementedError('latest method in MediaTypes class is not yet implemented.');
+  }
+}
+export default MediaTypes;

package/src/media-types.ts

@@ -0,0 +1,24 @@
+import { NotImplementedError } from '@speclynx/apidom-error';
+
+/**
+ * @public
+ */
+class MediaTypes<T> extends Array<T> {
+  unknownMediaType = 'application/octet-stream';
+
+  filterByFormat() {
+    throw new NotImplementedError(
+      'filterByFormat method in MediaTypes class is not yet implemented.',
+    );
+  }
+
+  findBy() {
+    throw new NotImplementedError('findBy method in MediaTypes class is not yet implemented.');
+  }
+
+  latest() {
+    throw new NotImplementedError('latest method in MediaTypes class is not yet implemented.');
+  }
+}
+
+export default MediaTypes;

package/src/merge/deepmerge.cjs

@@ -0,0 +1,165 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+exports.emptyElement = exports.defaultOptions = exports.default = void 0;
+var _apidomDatamodel = require("@speclynx/apidom-datamodel");
+var _value = _interopRequireDefault(require("../transformers/serializers/value.cjs"));
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+
+const emptyElement = element => {
+  const meta = !element.isMetaEmpty ? element.meta.cloneDeep() : undefined;
+  const attributes = !element.isAttributesEmpty ? (0, _apidomDatamodel.cloneDeep)(element.attributes) : undefined;
+
+  // @ts-ignore
+  return new element.constructor(undefined, meta, attributes);
+};
+exports.emptyElement = emptyElement;
+const cloneUnlessOtherwiseSpecified = (element, options) => options.clone && options.isMergeableElement(element) ? deepmerge(emptyElement(element), element, options) : element;
+const getMergeFunction = (keyElement, options) => {
+  if (typeof options.customMerge !== 'function') {
+    return deepmerge;
+  }
+  const customMerge = options.customMerge(keyElement, options);
+  return typeof customMerge === 'function' ? customMerge : deepmerge;
+};
+const getMetaMergeFunction = options => {
+  if (typeof options.customMetaMerge !== 'function') {
+    return targetMeta => targetMeta.cloneDeep();
+  }
+  return options.customMetaMerge;
+};
+const getAttributesMergeFunction = options => {
+  if (typeof options.customAttributesMerge !== 'function') {
+    return targetAttributes => (0, _apidomDatamodel.cloneDeep)(targetAttributes);
+  }
+  return options.customAttributesMerge;
+};
+const mergeArrayElement = (targetElement, sourceElement, options) => {
+  const Ctor = targetElement.constructor;
+  const merged = targetElement.concat(sourceElement);
+  return new Ctor(merged.map(item => cloneUnlessOtherwiseSpecified(item, options)));
+};
+const mergeObjectElement = (targetElement, sourceElement, options) => {
+  const destination = (0, _apidomDatamodel.isObjectElement)(targetElement) ? emptyElement(targetElement) : emptyElement(sourceElement);
+  if ((0, _apidomDatamodel.isObjectElement)(targetElement)) {
+    targetElement.forEach((value, key, member) => {
+      const clonedMember = (0, _apidomDatamodel.cloneShallow)(member);
+      clonedMember.value = cloneUnlessOtherwiseSpecified(value, options);
+      destination.content.push(clonedMember);
+    });
+  }
+  sourceElement.forEach((value, key, member) => {
+    const keyValue = (0, _value.default)(key);
+    let clonedMember;
+    if ((0, _apidomDatamodel.isObjectElement)(targetElement) && targetElement.hasKey(keyValue) && options.isMergeableElement(value)) {
+      const targetValue = targetElement.get(keyValue);
+      clonedMember = (0, _apidomDatamodel.cloneShallow)(member);
+      clonedMember.value = getMergeFunction(key, options)(targetValue, value, options);
+    } else {
+      clonedMember = (0, _apidomDatamodel.cloneShallow)(member);
+      clonedMember.value = cloneUnlessOtherwiseSpecified(value, options);
+    }
+    destination.remove(keyValue);
+    destination.content.push(clonedMember);
+  });
+  return destination;
+};
+const defaultOptions = exports.defaultOptions = {
+  clone: true,
+  isMergeableElement: element => (0, _apidomDatamodel.isObjectElement)(element) || (0, _apidomDatamodel.isArrayElement)(element),
+  arrayElementMerge: mergeArrayElement,
+  objectElementMerge: mergeObjectElement,
+  customMerge: undefined,
+  customMetaMerge: undefined,
+  customAttributesMerge: undefined
+};
+
+/**
+ * @public
+ */
+const deepmerge = (targetElement, sourceElement, options) => {
+  const mergedOptions = {
+    ...defaultOptions,
+    ...options
+  };
+  mergedOptions.isMergeableElement = mergedOptions.isMergeableElement ?? defaultOptions.isMergeableElement;
+  mergedOptions.arrayElementMerge = mergedOptions.arrayElementMerge ?? defaultOptions.arrayElementMerge;
+  mergedOptions.objectElementMerge = mergedOptions.objectElementMerge ?? defaultOptions.objectElementMerge;
+  const sourceIsArrayElement = (0, _apidomDatamodel.isArrayElement)(sourceElement);
+  const targetIsArrayElement = (0, _apidomDatamodel.isArrayElement)(targetElement);
+  const sourceAndTargetTypesMatch = sourceIsArrayElement === targetIsArrayElement;
+  if (!sourceAndTargetTypesMatch) {
+    return cloneUnlessOtherwiseSpecified(sourceElement, mergedOptions);
+  }
+
+  // merging two elements
+  const mergedElement = sourceIsArrayElement && typeof mergedOptions.arrayElementMerge === 'function' ? mergedOptions.arrayElementMerge(targetElement, sourceElement, mergedOptions) : mergedOptions.objectElementMerge(targetElement, sourceElement, mergedOptions);
+
+  // merging meta & attributes
+  if (!targetElement.isMetaEmpty && !sourceElement.isMetaEmpty) {
+    mergedElement.meta = getMetaMergeFunction(mergedOptions)(targetElement.meta, sourceElement.meta);
+  } else if (!targetElement.isMetaEmpty) {
+    mergedElement.meta = targetElement.meta.cloneDeep();
+  } else if (!sourceElement.isMetaEmpty) {
+    mergedElement.meta = sourceElement.meta.cloneDeep();
+  }
+  if (!targetElement.isAttributesEmpty && !sourceElement.isAttributesEmpty) {
+    mergedElement.attributes = getAttributesMergeFunction(mergedOptions)(targetElement.attributes, sourceElement.attributes);
+  } else if (!targetElement.isAttributesEmpty) {
+    mergedElement.attributes = (0, _apidomDatamodel.cloneDeep)(targetElement.attributes);
+  } else if (!sourceElement.isAttributesEmpty) {
+    mergedElement.attributes = (0, _apidomDatamodel.cloneDeep)(sourceElement.attributes);
+  }
+  return mergedElement;
+};
+deepmerge.all = (list, options) => {
+  if (!Array.isArray(list)) {
+    throw new TypeError('First argument of deepmerge should be an array.');
+  }
+  if (list.length === 0) {
+    return new _apidomDatamodel.ObjectElement();
+  }
+  return list.reduce((target, source) => {
+    return deepmerge(target, source, options);
+  }, emptyElement(list[0]));
+};
+var _default = exports.default = deepmerge;

package/src/merge/deepmerge.mjs

@@ -0,0 +1,149 @@
+import { ObjectElement, isObjectElement, isArrayElement, cloneDeep, cloneShallow } from '@speclynx/apidom-datamodel';
+import toValue from "../transformers/serializers/value.mjs";
+/**
+ * @public
+ */
+/**
+ * @public
+ */
+/**
+ * @public
+ */
+/**
+ * @public
+ */
+/**
+ * @public
+ */
+/**
+ * @public
+ */
+/**
+ * @public
+ */
+/**
+ * @public
+ */
+/**
+ * @public
+ */
+/**
+ * @public
+ */
+export const emptyElement = element => {
+  const meta = !element.isMetaEmpty ? element.meta.cloneDeep() : undefined;
+  const attributes = !element.isAttributesEmpty ? cloneDeep(element.attributes) : undefined;
+
+  // @ts-ignore
+  return new element.constructor(undefined, meta, attributes);
+};
+const cloneUnlessOtherwiseSpecified = (element, options) => options.clone && options.isMergeableElement(element) ? deepmerge(emptyElement(element), element, options) : element;
+const getMergeFunction = (keyElement, options) => {
+  if (typeof options.customMerge !== 'function') {
+    return deepmerge;
+  }
+  const customMerge = options.customMerge(keyElement, options);
+  return typeof customMerge === 'function' ? customMerge : deepmerge;
+};
+const getMetaMergeFunction = options => {
+  if (typeof options.customMetaMerge !== 'function') {
+    return targetMeta => targetMeta.cloneDeep();
+  }
+  return options.customMetaMerge;
+};
+const getAttributesMergeFunction = options => {
+  if (typeof options.customAttributesMerge !== 'function') {
+    return targetAttributes => cloneDeep(targetAttributes);
+  }
+  return options.customAttributesMerge;
+};
+const mergeArrayElement = (targetElement, sourceElement, options) => {
+  const Ctor = targetElement.constructor;
+  const merged = targetElement.concat(sourceElement);
+  return new Ctor(merged.map(item => cloneUnlessOtherwiseSpecified(item, options)));
+};
+const mergeObjectElement = (targetElement, sourceElement, options) => {
+  const destination = isObjectElement(targetElement) ? emptyElement(targetElement) : emptyElement(sourceElement);
+  if (isObjectElement(targetElement)) {
+    targetElement.forEach((value, key, member) => {
+      const clonedMember = cloneShallow(member);
+      clonedMember.value = cloneUnlessOtherwiseSpecified(value, options);
+      destination.content.push(clonedMember);
+    });
+  }
+  sourceElement.forEach((value, key, member) => {
+    const keyValue = toValue(key);
+    let clonedMember;
+    if (isObjectElement(targetElement) && targetElement.hasKey(keyValue) && options.isMergeableElement(value)) {
+      const targetValue = targetElement.get(keyValue);
+      clonedMember = cloneShallow(member);
+      clonedMember.value = getMergeFunction(key, options)(targetValue, value, options);
+    } else {
+      clonedMember = cloneShallow(member);
+      clonedMember.value = cloneUnlessOtherwiseSpecified(value, options);
+    }
+    destination.remove(keyValue);
+    destination.content.push(clonedMember);
+  });
+  return destination;
+};
+export const defaultOptions = {
+  clone: true,
+  isMergeableElement: element => isObjectElement(element) || isArrayElement(element),
+  arrayElementMerge: mergeArrayElement,
+  objectElementMerge: mergeObjectElement,
+  customMerge: undefined,
+  customMetaMerge: undefined,
+  customAttributesMerge: undefined
+};
+
+/**
+ * @public
+ */
+const deepmerge = (targetElement, sourceElement, options) => {
+  const mergedOptions = {
+    ...defaultOptions,
+    ...options
+  };
+  mergedOptions.isMergeableElement = mergedOptions.isMergeableElement ?? defaultOptions.isMergeableElement;
+  mergedOptions.arrayElementMerge = mergedOptions.arrayElementMerge ?? defaultOptions.arrayElementMerge;
+  mergedOptions.objectElementMerge = mergedOptions.objectElementMerge ?? defaultOptions.objectElementMerge;
+  const sourceIsArrayElement = isArrayElement(sourceElement);
+  const targetIsArrayElement = isArrayElement(targetElement);
+  const sourceAndTargetTypesMatch = sourceIsArrayElement === targetIsArrayElement;
+  if (!sourceAndTargetTypesMatch) {
+    return cloneUnlessOtherwiseSpecified(sourceElement, mergedOptions);
+  }
+
+  // merging two elements
+  const mergedElement = sourceIsArrayElement && typeof mergedOptions.arrayElementMerge === 'function' ? mergedOptions.arrayElementMerge(targetElement, sourceElement, mergedOptions) : mergedOptions.objectElementMerge(targetElement, sourceElement, mergedOptions);
+
+  // merging meta & attributes
+  if (!targetElement.isMetaEmpty && !sourceElement.isMetaEmpty) {
+    mergedElement.meta = getMetaMergeFunction(mergedOptions)(targetElement.meta, sourceElement.meta);
+  } else if (!targetElement.isMetaEmpty) {
+    mergedElement.meta = targetElement.meta.cloneDeep();
+  } else if (!sourceElement.isMetaEmpty) {
+    mergedElement.meta = sourceElement.meta.cloneDeep();
+  }
+  if (!targetElement.isAttributesEmpty && !sourceElement.isAttributesEmpty) {
+    mergedElement.attributes = getAttributesMergeFunction(mergedOptions)(targetElement.attributes, sourceElement.attributes);
+  } else if (!targetElement.isAttributesEmpty) {
+    mergedElement.attributes = cloneDeep(targetElement.attributes);
+  } else if (!sourceElement.isAttributesEmpty) {
+    mergedElement.attributes = cloneDeep(sourceElement.attributes);
+  }
+  return mergedElement;
+};
+deepmerge.all = (list, options) => {
+  if (!Array.isArray(list)) {
+    throw new TypeError('First argument of deepmerge should be an array.');
+  }
+  if (list.length === 0) {
+    return new ObjectElement();
+  }
+  return list.reduce((target, source) => {
+    return deepmerge(target, source, options);
+  }, emptyElement(list[0]));
+};
+export default deepmerge;

package/src/merge/deepmerge.ts

@@ -0,0 +1,274 @@
+import {
+  ObjectElement,
+  ArrayElement,
+  MemberElement,
+  Element,
+  Metadata,
+  isObjectElement,
+  isArrayElement,
+  cloneDeep,
+  cloneShallow,
+} from '@speclynx/apidom-datamodel';
+
+import toValue from '../transformers/serializers/value.ts';
+
+/**
+ * @public
+ */
+export type ObjectOrArrayElement = ObjectElement | ArrayElement;
+
+/**
+ * @public
+ */
+export type AnyElement = ObjectElement | ArrayElement | Element;
+
+/**
+ * @public
+ */
+export type DeepMerge = (
+  targetElement: ObjectOrArrayElement,
+  sourceElement: ObjectOrArrayElement,
+  options?: DeepMergeOptions,
+) => AnyElement;
+
+/**
+ * @public
+ */
+export type CustomMerge = (keyElement: Element, options: DeepMergeOptions) => DeepMerge;
+
+/**
+ * @public
+ */
+export type CustomMetaMerge = (
+  targetElementMeta: Metadata,
+  sourceElementMeta: Metadata,
+) => Metadata;
+
+/**
+ * @public
+ */
+export type CustomAttributesMerge = (
+  targetElementAttributes: ObjectElement,
+  sourceElementAttributes: ObjectElement,
+) => ObjectElement;
+
+/**
+ * @public
+ */
+export type ArrayElementMerge = (
+  targetElement: ArrayElement,
+  sourceElement: ArrayElement,
+  options: DeepMergeOptions,
+) => ArrayElement;
+
+/**
+ * @public
+ */
+export type ObjectElementMerge = (
+  targetElement: ObjectElement,
+  source: ObjectElement,
+  options: DeepMergeOptions,
+) => ObjectElement;
+
+/**
+ * @public
+ */
+export type DeepMergeUserOptions = {
+  clone?: boolean;
+  isMergeableElement?: (element: Element) => boolean;
+  arrayElementMerge?: ArrayElementMerge;
+  objectElementMerge?: ObjectElementMerge;
+  customMerge?: CustomMerge;
+  customMetaMerge?: CustomMetaMerge;
+  customAttributesMerge?: CustomAttributesMerge;
+};
+
+/**
+ * @public
+ */
+export type DeepMergeOptions = DeepMergeUserOptions & {
+  clone: boolean;
+  isMergeableElement: (element: Element) => boolean;
+  arrayElementMerge: ArrayElementMerge;
+  objectElementMerge: ObjectElementMerge;
+  customMerge: CustomMerge | undefined;
+  customMetaMerge: CustomMetaMerge | undefined;
+  customAttributesMerge: CustomAttributesMerge | undefined;
+};
+
+export const emptyElement = (element: ObjectElement | ArrayElement) => {
+  const meta = !element.isMetaEmpty ? element.meta.cloneDeep() : undefined;
+  const attributes = !element.isAttributesEmpty ? cloneDeep(element.attributes) : undefined;
+
+  // @ts-ignore
+  return new element.constructor(undefined, meta, attributes);
+};
+
+const cloneUnlessOtherwiseSpecified = (
+  element: AnyElement,
+  options: DeepMergeOptions,
+): AnyElement =>
+  options.clone && options.isMergeableElement(element)
+    ? deepmerge(
+        emptyElement(element as ObjectOrArrayElement),
+        element as ObjectOrArrayElement,
+        options,
+      )
+    : element;
+
+const getMergeFunction = (keyElement: Element, options: DeepMergeOptions): DeepMerge => {
+  if (typeof options.customMerge !== 'function') {
+    return deepmerge;
+  }
+  const customMerge = options.customMerge(keyElement, options);
+  return typeof customMerge === 'function' ? customMerge : deepmerge;
+};
+
+const getMetaMergeFunction = (options: DeepMergeOptions): CustomMetaMerge => {
+  if (typeof options.customMetaMerge !== 'function') {
+    return (targetMeta) => targetMeta.cloneDeep();
+  }
+  return options.customMetaMerge;
+};
+
+const getAttributesMergeFunction = (options: DeepMergeOptions): CustomAttributesMerge => {
+  if (typeof options.customAttributesMerge !== 'function') {
+    return (targetAttributes) => cloneDeep(targetAttributes);
+  }
+  return options.customAttributesMerge;
+};
+
+const mergeArrayElement: ArrayElementMerge = (targetElement, sourceElement, options) => {
+  const Ctor = targetElement.constructor as new (content: Element[]) => ArrayElement;
+  const merged = targetElement.concat(sourceElement) as ArrayElement;
+  return new Ctor(merged.map((item: Element) => cloneUnlessOtherwiseSpecified(item, options)));
+};
+
+const mergeObjectElement: ObjectElementMerge = (targetElement, sourceElement, options) => {
+  const destination = isObjectElement(targetElement)
+    ? emptyElement(targetElement)
+    : emptyElement(sourceElement);
+
+  if (isObjectElement(targetElement)) {
+    targetElement.forEach((value, key, member) => {
+      const clonedMember = cloneShallow(member as MemberElement);
+      clonedMember.value = cloneUnlessOtherwiseSpecified(value, options);
+      destination.content.push(clonedMember);
+    });
+  }
+
+  sourceElement.forEach((value, key, member) => {
+    const keyValue = toValue(key) as string;
+    let clonedMember;
+
+    if (
+      isObjectElement(targetElement) &&
+      targetElement.hasKey(keyValue) &&
+      options.isMergeableElement(value)
+    ) {
+      const targetValue = targetElement.get(keyValue)!;
+      clonedMember = cloneShallow(member as MemberElement);
+      clonedMember.value = getMergeFunction(key, options)(
+        targetValue as ObjectOrArrayElement,
+        value as ObjectOrArrayElement,
+        options,
+      );
+    } else {
+      clonedMember = cloneShallow(member as MemberElement);
+      clonedMember.value = cloneUnlessOtherwiseSpecified(value as AnyElement, options);
+    }
+
+    destination.remove(keyValue);
+    destination.content.push(clonedMember);
+  });
+
+  return destination;
+};
+
+export const defaultOptions: DeepMergeOptions = {
+  clone: true,
+  isMergeableElement: (element) => isObjectElement(element) || isArrayElement(element),
+  arrayElementMerge: mergeArrayElement,
+  objectElementMerge: mergeObjectElement,
+  customMerge: undefined,
+  customMetaMerge: undefined,
+  customAttributesMerge: undefined,
+};
+
+/**
+ * @public
+ */
+const deepmerge = (
+  targetElement: ObjectOrArrayElement,
+  sourceElement: ObjectOrArrayElement,
+  options?: DeepMergeUserOptions,
+): AnyElement => {
+  const mergedOptions: DeepMergeOptions = { ...defaultOptions, ...options };
+  mergedOptions.isMergeableElement =
+    mergedOptions.isMergeableElement ?? defaultOptions.isMergeableElement;
+  mergedOptions.arrayElementMerge =
+    mergedOptions.arrayElementMerge ?? defaultOptions.arrayElementMerge;
+  mergedOptions.objectElementMerge =
+    mergedOptions.objectElementMerge ?? defaultOptions.objectElementMerge;
+
+  const sourceIsArrayElement = isArrayElement(sourceElement);
+  const targetIsArrayElement = isArrayElement(targetElement);
+  const sourceAndTargetTypesMatch = sourceIsArrayElement === targetIsArrayElement;
+
+  if (!sourceAndTargetTypesMatch) {
+    return cloneUnlessOtherwiseSpecified(sourceElement, mergedOptions);
+  }
+
+  // merging two elements
+  const mergedElement =
+    sourceIsArrayElement && typeof mergedOptions.arrayElementMerge === 'function'
+      ? mergedOptions.arrayElementMerge(
+          targetElement as ArrayElement,
+          sourceElement as ArrayElement,
+          mergedOptions,
+        )
+      : mergedOptions.objectElementMerge(
+          targetElement as ObjectElement,
+          sourceElement as ObjectElement,
+          mergedOptions,
+        );
+
+  // merging meta & attributes
+  if (!targetElement.isMetaEmpty && !sourceElement.isMetaEmpty) {
+    mergedElement.meta = getMetaMergeFunction(mergedOptions)(
+      targetElement.meta,
+      sourceElement.meta,
+    );
+  } else if (!targetElement.isMetaEmpty) {
+    mergedElement.meta = targetElement.meta.cloneDeep();
+  } else if (!sourceElement.isMetaEmpty) {
+    mergedElement.meta = sourceElement.meta.cloneDeep();
+  }
+  if (!targetElement.isAttributesEmpty && !sourceElement.isAttributesEmpty) {
+    mergedElement.attributes = getAttributesMergeFunction(mergedOptions)(
+      targetElement.attributes,
+      sourceElement.attributes,
+    );
+  } else if (!targetElement.isAttributesEmpty) {
+    mergedElement.attributes = cloneDeep(targetElement.attributes);
+  } else if (!sourceElement.isAttributesEmpty) {
+    mergedElement.attributes = cloneDeep(sourceElement.attributes);
+  }
+
+  return mergedElement;
+};
+
+deepmerge.all = (list: ObjectOrArrayElement[], options?: DeepMergeUserOptions) => {
+  if (!Array.isArray(list)) {
+    throw new TypeError('First argument of deepmerge should be an array.');
+  }
+  if (list.length === 0) {
+    return new ObjectElement();
+  }
+
+  return list.reduce((target, source) => {
+    return deepmerge(target, source, options);
+  }, emptyElement(list[0]));
+};
+
+export default deepmerge;

package/src/merge/merge-left.cjs

@@ -0,0 +1,16 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+exports.default = void 0;
+var _mergeRight = _interopRequireDefault(require("./merge-right.cjs"));
+/**
+ * @public
+ */
+const mergeLeft = (...[sourceElement, targetElement, options]) => {
+  return (0, _mergeRight.default)(targetElement, sourceElement, options);
+};
+mergeLeft.all = (...[list, options]) => {
+  return _mergeRight.default.all([...list].reverse(), options);
+};
+var _default = exports.default = mergeLeft;

package/src/merge/merge-left.mjs

@@ -0,0 +1,11 @@
+import mergeRight from "./merge-right.mjs";
+/**
+ * @public
+ */
+const mergeLeft = (...[sourceElement, targetElement, options]) => {
+  return mergeRight(targetElement, sourceElement, options);
+};
+mergeLeft.all = (...[list, options]) => {
+  return mergeRight.all([...list].reverse(), options);
+};
+export default mergeLeft;

package/src/merge/merge-left.ts

@@ -0,0 +1,14 @@
+import mergeRight from './merge-right.ts';
+
+/**
+ * @public
+ */
+const mergeLeft: typeof mergeRight = (...[sourceElement, targetElement, options]) => {
+  return mergeRight(targetElement, sourceElement, options);
+};
+
+mergeLeft.all = ((...[list, options]) => {
+  return mergeRight.all([...list].reverse(), options);
+}) as typeof mergeRight.all;
+
+export default mergeLeft;