@uploadcare/file-uploader 0.50.1-alpha.2

package/blocks/CloudImageEditor/src/lib/applyFocusVisiblePolyfill.js

@@ -0,0 +1,256 @@
+/**
+ * Helper function for legacy browsers and iframes which sometimes focus on elements like document, body, and
+ * non-interactive SVG.
+ *
+ * @param {EventTarget} el
+ */
+function isValidFocusTarget(el) {
+  if (
+    el &&
+    el !== document &&
+    /** @type {Element} */ (el).nodeName !== 'HTML' &&
+    /** @type {Element} */ (el).nodeName !== 'BODY' &&
+    'classList' in el &&
+    'contains' in /** @type {Element} */ (el).classList
+  ) {
+    return true;
+  }
+  return false;
+}
+
+/**
+ * Computes whether the given element should automatically trigger the `focus-visible` class being added, i.e., whether
+ * it should always match `:focus-visible` when focused.
+ *
+ * @param {EventTarget} el
+ * @returns {boolean}
+ */
+function focusTriggersKeyboardModality(el) {
+  let { tagName } = /** @type {Element} */ (el);
+
+  if (tagName === 'INPUT' && !(/** @type {HTMLInputElement} */ (el).readOnly)) {
+    return true;
+  }
+
+  if (tagName === 'TEXTAREA' && !(/** @type {HTMLTextAreaElement} */ (el).readOnly)) {
+    return true;
+  }
+
+  if (/** @type {HTMLElement} */ (el).isContentEditable) {
+    return true;
+  }
+
+  return false;
+}
+
+let hadKeyboardEvent = true;
+let hadFocusVisibleRecently = false;
+
+/**
+ * Applies the :focus-visible polyfill at the given scope. A scope, in this case, is either the top-level Document or a
+ * Shadow Root.
+ *
+ * @param {Document | ShadowRoot} scope
+ * @param {(focusVisible: boolean, el: EventTarget) => void} [callback]
+ * @see https://github.com/WICG/focus-visible
+ */
+export function applyFocusVisiblePolyfill(scope, callback) {
+  let hadFocusVisibleRecentlyTimeout = null;
+
+  /**
+   * Add the `focus-visible` class to the given element if the author did not add it.
+   *
+   * @param {EventTarget} el
+   */
+  function addFocusVisibleClass(el) {
+    /** @type {Element} */ (el).setAttribute('focus-visible', '');
+    callback(true, el);
+  }
+
+  /**
+   * Remove the `focus-visible` class from the given element if the author did not originally add it.
+   *
+   * @param {EventTarget} el
+   */
+  function removeFocusVisibleClass(el) {
+    if (!(/** @type {Element} */ (el).hasAttribute('focus-visible'))) {
+      return;
+    }
+    /** @type {Element} */ (el).removeAttribute('focus-visible');
+    callback(false, el);
+  }
+
+  /**
+   * If the most recent user interaction was via the keyboard, and the keypress did not include a meta, alt/option, or
+   * control key, then the keyboard's modality. Otherwise, the modality is not the keyboard.Apply `focus-visible` to any
+   * current active element and keep track of our keyboard modality state with `hadKeyboardEvent`.
+   *
+   * @param {KeyboardEvent} e
+   */
+  function onKeyDown(e) {
+    if (e.metaKey || e.altKey || e.ctrlKey) {
+      return;
+    }
+
+    if (isValidFocusTarget(scope.activeElement)) {
+      addFocusVisibleClass(scope.activeElement);
+    }
+
+    hadKeyboardEvent = true;
+  }
+
+  /**
+   * If at any point a user clicks with a pointing device, ensure that we change the modality away from the keyboard.
+   * This avoids the situation where a user presses a key on an already focused element, and then clicks on a different
+   * element focusing it with a pointing device while we still think we're in keyboard modality.
+   *
+   * @param {Event} e
+   */
+  function onPointerDown(e) {
+    hadKeyboardEvent = false;
+  }
+
+  /**
+   * On `focus`, add the `focus-visible` class to the target if: - the target received focus as a result of keyboard
+   * navigation or - the event target is an element that will likely require interaction via the keyboard (e.g., a text
+   * box).
+   *
+   * @param {Event} e
+   */
+  function onFocus(e) {
+    // Prevent IE from focusing the document or HTML element.
+    if (!isValidFocusTarget(e.target)) {
+      return;
+    }
+
+    if (hadKeyboardEvent || focusTriggersKeyboardModality(e.target)) {
+      addFocusVisibleClass(e.target);
+    }
+  }
+
+  /**
+   * On `blur`, remove the `focus-visible` class from the target.
+   *
+   * @param {Event} e
+   */
+  function onBlur(e) {
+    if (!isValidFocusTarget(e.target)) {
+      return;
+    }
+
+    if (/** @type {Element} */ (e.target).hasAttribute('focus-visible')) {
+      // To detect a tab/window switch, we look for a blur event followed
+      // rapidly by a visibility change.
+      // If we don't see a visibility change within 100ms, it's probably a
+      // regular focus change.
+      hadFocusVisibleRecently = true;
+      window.clearTimeout(hadFocusVisibleRecentlyTimeout);
+      hadFocusVisibleRecentlyTimeout = window.setTimeout(() => {
+        hadFocusVisibleRecently = false;
+      }, 100);
+      removeFocusVisibleClass(e.target);
+    }
+  }
+
+  /**
+   * Add a group of listeners to detect usage of any pointing devices. These listeners will be added when the polyfill
+   * first loads and anytime the window is blurred so that they are active when the window regains focus.
+   */
+  function addInitialPointerMoveListeners() {
+    /* eslint-disable no-use-before-define */
+    document.addEventListener('mousemove', onInitialPointerMove);
+    document.addEventListener('mousedown', onInitialPointerMove);
+    document.addEventListener('mouseup', onInitialPointerMove);
+    document.addEventListener('pointermove', onInitialPointerMove);
+    document.addEventListener('pointerdown', onInitialPointerMove);
+    document.addEventListener('pointerup', onInitialPointerMove);
+    document.addEventListener('touchmove', onInitialPointerMove);
+    document.addEventListener('touchstart', onInitialPointerMove);
+    document.addEventListener('touchend', onInitialPointerMove);
+    /* eslint-enable no-use-before-define */
+  }
+
+  function removeInitialPointerMoveListeners() {
+    /* eslint-disable no-use-before-define */
+    document.removeEventListener('mousemove', onInitialPointerMove);
+    document.removeEventListener('mousedown', onInitialPointerMove);
+    document.removeEventListener('mouseup', onInitialPointerMove);
+    document.removeEventListener('pointermove', onInitialPointerMove);
+    document.removeEventListener('pointerdown', onInitialPointerMove);
+    document.removeEventListener('pointerup', onInitialPointerMove);
+    document.removeEventListener('touchmove', onInitialPointerMove);
+    document.removeEventListener('touchstart', onInitialPointerMove);
+    document.removeEventListener('touchend', onInitialPointerMove);
+    /* eslint-enable no-use-before-define */
+  }
+
+  /**
+   * If the user changes tabs, keep track of whether or not the previously focused element had .focus-visible.
+   *
+   * @param {Event} e
+   */
+  function onVisibilityChange(e) {
+    if (document.visibilityState === 'hidden') {
+      // If the tab becomes active again, the browser will handle calling focus
+      // on the element (Safari actually calls it twice).
+      // If this tab change caused a blur on an element with focus-visible,
+      // re-apply the class when the user switches back to the tab.
+      if (hadFocusVisibleRecently) {
+        hadKeyboardEvent = true;
+      }
+      addInitialPointerMoveListeners();
+    }
+  }
+
+  /**
+   * When the polyfill first loads, assume the user is in keyboard modality. If any event is received from a pointing
+   * device (e.g., mouse, pointer, touch), turn off keyboard modality. This accounts for situations where focus enters
+   * the page from the URL bar.
+   *
+   * @param {Event} e
+   */
+  function onInitialPointerMove(e) {
+    // Work around a Safari quirk that fires a mousemove on <html> whenever the
+    // window blurs, even if you're tabbing out of the page. ¯\_(ツ)_/¯
+    if (
+      /** @type {Element} */ (e.target).nodeName &&
+      /** @type {Element} */ (e.target).nodeName.toLowerCase() === 'html'
+    ) {
+      return;
+    }
+
+    hadKeyboardEvent = false;
+    removeInitialPointerMoveListeners();
+  }
+
+  // We are interested in changes at the global scope only for some kinds of states.
+  // For example, global pointer input, global key presses, and global
+  // visibility change should affect the state at every scope:
+  document.addEventListener('keydown', onKeyDown, true);
+  document.addEventListener('mousedown', onPointerDown, true);
+  document.addEventListener('pointerdown', onPointerDown, true);
+  document.addEventListener('touchstart', onPointerDown, true);
+  document.addEventListener('visibilitychange', onVisibilityChange, true);
+
+  addInitialPointerMoveListeners();
+
+  // We specifically care about state changes in the local scope for focus and blur.
+  // This is because focus/blur events that originate from within a
+  // shadow root are not re-dispatched from the host element if it was already
+  // the active element in its own scope:
+  scope.addEventListener('focus', onFocus, true);
+  scope.addEventListener('blur', onBlur, true);
+
+  return () => {
+    removeInitialPointerMoveListeners();
+
+    document.removeEventListener('keydown', onKeyDown, true);
+    document.removeEventListener('mousedown', onPointerDown, true);
+    document.removeEventListener('pointerdown', onPointerDown, true);
+    document.removeEventListener('touchstart', onPointerDown, true);
+    document.removeEventListener('visibilitychange', onVisibilityChange, true);
+
+    scope.removeEventListener('focus', onFocus, true);
+    scope.removeEventListener('blur', onBlur, true);
+  };
+}

package/blocks/CloudImageEditor/src/lib/classNames.d.ts

@@ -0,0 +1,3 @@
+export function classNames(...args: any[]): string;
+export function applyClassNames(element: any, ...args: any[]): void;
+//# sourceMappingURL=classNames.d.ts.map

package/blocks/CloudImageEditor/src/lib/classNames.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"classNames.d.ts","sourceRoot":"","sources":["classNames.js"],"names":[],"mappings":"AAeA,mDAWC;AAED,oEAKC"}

package/blocks/CloudImageEditor/src/lib/classNames.js

@@ -0,0 +1,34 @@
+function normalize(...args) {
+  return args.reduce((result, arg) => {
+    if (typeof arg === 'string') {
+      result[arg] = true;
+      return result;
+    }
+
+    for (let token of Object.keys(arg)) {
+      result[token] = arg[token];
+    }
+
+    return result;
+  }, {});
+}
+
+export function classNames(...args) {
+  let mapping = normalize(...args);
+  return Object.keys(mapping)
+    .reduce((result, token) => {
+      if (mapping[token]) {
+        result.push(token);
+      }
+
+      return result;
+    }, [])
+    .join(' ');
+}
+
+export function applyClassNames(element, ...args) {
+  let mapping = normalize(...args);
+  for (let token of Object.keys(mapping)) {
+    element.classList.toggle(token, mapping[token]);
+  }
+}

package/blocks/CloudImageEditor/src/lib/linspace.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @param {Number} a Start of sample (int)
+ * @param {Number} b End of sample (int)
+ * @param {Number} n Number of elements (int)
+ * @returns {Number[]}
+ */
+export function linspace(a: number, b: number, n: number): number[];
+//# sourceMappingURL=linspace.d.ts.map

package/blocks/CloudImageEditor/src/lib/linspace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"linspace.d.ts","sourceRoot":"","sources":["linspace.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,2DAFa,QAAQ,CASpB"}

package/blocks/CloudImageEditor/src/lib/linspace.js

@@ -0,0 +1,14 @@
+/**
+ * @param {Number} a Start of sample (int)
+ * @param {Number} b End of sample (int)
+ * @param {Number} n Number of elements (int)
+ * @returns {Number[]}
+ */
+export function linspace(a, b, n) {
+  let ret = Array(n);
+  n--;
+  for (let i = n; i >= 0; i--) {
+    ret[i] = Math.ceil((i * b + (n - i) * a) / n);
+  }
+  return ret;
+}

package/blocks/CloudImageEditor/src/lib/parseCropPreset.d.ts

@@ -0,0 +1,2 @@
+export function parseCropPreset(cropPreset: import('../../../../types/exported.d.ts').ConfigType['cropPreset']): import("../types.js").CropAspectRatio[] | undefined;
+//# sourceMappingURL=parseCropPreset.d.ts.map

package/blocks/CloudImageEditor/src/lib/parseCropPreset.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseCropPreset.d.ts","sourceRoot":"","sources":["parseCropPreset.js"],"names":[],"mappings":"AAGO,4CADK,OAAO,iCAAiC,EAAE,UAAU,CAAC,YAAY,CAAC,uDAW7E"}

package/blocks/CloudImageEditor/src/lib/parseCropPreset.js

@@ -0,0 +1,14 @@
+// @ts-check
+
+/** @param {import('../../../../types/exported.d.ts').ConfigType['cropPreset']} cropPreset */
+export const parseCropPreset = (cropPreset) => {
+  if (!cropPreset) return [];
+  const [w, h] = cropPreset.split(':').map(Number);
+  if (!Number.isFinite(w) || !Number.isFinite(h)) {
+    console.error(`Invalid crop preset: ${cropPreset}`);
+    return;
+  }
+  /** @type {import('../types.js').CropAspectRatio} */
+  const aspectRatio = { type: 'aspect-ratio', width: w, height: h };
+  return [aspectRatio];
+};

package/blocks/CloudImageEditor/src/lib/parseTabs.d.ts

@@ -0,0 +1,2 @@
+export function parseTabs(tabs: string): string[];
+//# sourceMappingURL=parseTabs.d.ts.map

package/blocks/CloudImageEditor/src/lib/parseTabs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseTabs.d.ts","sourceRoot":"","sources":["parseTabs.js"],"names":[],"mappings":"AAMO,gCADK,MAAM,YAQjB"}

package/blocks/CloudImageEditor/src/lib/parseTabs.js

@@ -0,0 +1,14 @@
+// @ts-check
+
+import { deserealizeCsv } from '../../../utils/comma-separated.js';
+import { ALL_TABS } from '../toolbar-constants.js';
+
+/** @param {string} tabs */
+export const parseTabs = (tabs) => {
+  if (!tabs) return ALL_TABS;
+  const tabList = deserealizeCsv(tabs).filter((tab) => ALL_TABS.includes(tab));
+  if (tabList.length === 0) {
+    return ALL_TABS;
+  }
+  return tabList;
+};

package/blocks/CloudImageEditor/src/lib/pick.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @param {{}} obj
+ * @param {String[]} keys
+ * @returns {{}}
+ */
+export function pick(obj: {}, keys: string[]): {};
+//# sourceMappingURL=pick.d.ts.map

package/blocks/CloudImageEditor/src/lib/pick.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pick.d.ts","sourceRoot":"","sources":["pick.js"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,0BAJW,EAAE,QACF,QAAQ,GACN,EAAE,CAWd"}

package/blocks/CloudImageEditor/src/lib/pick.js

@@ -0,0 +1,15 @@
+/**
+ * @param {{}} obj
+ * @param {String[]} keys
+ * @returns {{}}
+ */
+export function pick(obj, keys) {
+  let result = {};
+  for (let key of keys) {
+    let value = obj[key];
+    if (obj.hasOwnProperty(key) || value !== undefined) {
+      result[key] = value;
+    }
+  }
+  return result;
+}

package/blocks/CloudImageEditor/src/lib/preloadImage.d.ts

@@ -0,0 +1,11 @@
+export function preloadImage(src: any): {
+    promise: Promise<any>;
+    image: HTMLImageElement;
+    cancel: () => void;
+};
+export function batchPreloadImages(list: any): {
+    promise: Promise<PromiseSettledResult<any>[]>;
+    images: HTMLImageElement[];
+    cancel: () => void;
+};
+//# sourceMappingURL=preloadImage.d.ts.map

package/blocks/CloudImageEditor/src/lib/preloadImage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preloadImage.d.ts","sourceRoot":"","sources":["preloadImage.js"],"names":[],"mappings":"AAEA;;;;EAgBC;AAED;;;;EAiBC"}

package/blocks/CloudImageEditor/src/lib/preloadImage.js

@@ -0,0 +1,38 @@
+import { TRANSPARENT_PIXEL_SRC } from '../../../../utils/transparentPixelSrc.js';
+
+export function preloadImage(src) {
+  let image = new Image();
+
+  let promise = new Promise((resolve, reject) => {
+    image.src = src;
+    image.onload = resolve;
+    image.onerror = reject;
+  });
+
+  let cancel = () => {
+    if (image.naturalWidth === 0) {
+      image.src = TRANSPARENT_PIXEL_SRC;
+    }
+  };
+
+  return { promise, image, cancel };
+}
+
+export function batchPreloadImages(list) {
+  let preloaders = [];
+
+  for (let src of list) {
+    let preload = preloadImage(src);
+    preloaders.push(preload);
+  }
+
+  let images = preloaders.map((preload) => preload.image);
+  let promise = Promise.allSettled(preloaders.map((preload) => preload.promise));
+  let cancel = () => {
+    preloaders.forEach((preload) => {
+      preload.cancel();
+    });
+  };
+
+  return { promise, images, cancel };
+}

package/blocks/CloudImageEditor/src/lib/transformationUtils.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @param {import('../types').Transformations} transformations
+ * @returns {string}
+ */
+export function transformationsToOperations(transformations: import('../types').Transformations): string;
+/**
+ * @param {string[]} operations
+ * @returns {import('../types.js').Transformations}
+ */
+export function operationsToTransformations(operations: string[]): import('../types.js').Transformations;
+/** @type {Record<keyof import('../types').Transformations, unknown>} */
+export const OPERATIONS_DEFAULTS: Record<keyof import('../types').Transformations, unknown>;
+export const COMMON_OPERATIONS: string;
+//# sourceMappingURL=transformationUtils.d.ts.map

package/blocks/CloudImageEditor/src/lib/transformationUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transformationUtils.d.ts","sourceRoot":"","sources":["transformationUtils.js"],"names":[],"mappings":"AAsEA;;;GAGG;AACH,6DAHW,OAAO,UAAU,EAAE,eAAe,GAChC,MAAM,CAalB;AAoDD;;;GAGG;AACH,wDAHW,MAAM,EAAE,GACN,OAAO,aAAa,EAAE,eAAe,CA2BjD;AAlKD,wEAAwE;AACxE,kCADW,OAAO,MAAM,OAAO,UAAU,EAAE,eAAe,EAAE,OAAO,CAAC,CAejE;AAoEH,uCAAqF"}

package/blocks/CloudImageEditor/src/lib/transformationUtils.js

@@ -0,0 +1,167 @@
+// @ts-check
+import { joinCdnOperations } from '../../../../utils/cdn-utils.js';
+import { stringToArray } from '../../../../utils/stringToArray.js';
+
+/** @type {Record<keyof import('../types').Transformations, unknown>} */
+export const OPERATIONS_DEFAULTS = Object.freeze({
+  brightness: 0,
+  exposure: 0,
+  gamma: 100,
+  contrast: 0,
+  saturation: 0,
+  vibrance: 0,
+  warmth: 0,
+  enhance: 0,
+  filter: 0,
+  rotate: 0,
+  mirror: false,
+  flip: false,
+  crop: undefined,
+});
+
+/** @type {readonly (keyof import('../types').Transformations)[]} */
+const SUPPORTED_OPERATIONS_ORDERED = /** @type {const} */ ([
+  'enhance',
+  'brightness',
+  'exposure',
+  'gamma',
+  'contrast',
+  'saturation',
+  'vibrance',
+  'warmth',
+  'filter',
+  'mirror',
+  'flip',
+  'rotate',
+  'crop',
+]);
+
+/**
+ * @template {keyof import('../types').Transformations} T
+ * @param {T} operation
+ * @param {import('../types').Transformations[T]} options
+ */
+function transformationToStr(operation, options) {
+  if (typeof options === 'number') {
+    const value = options;
+    return OPERATIONS_DEFAULTS[operation] !== value ? `${operation}/${value}` : '';
+  }
+
+  if (typeof options === 'boolean') {
+    const value = options;
+    return OPERATIONS_DEFAULTS[operation] !== value ? `${operation}` : '';
+  }
+
+  if (operation === 'filter' && options) {
+    const { name, amount } = /** @type {NonNullable<import('../types').Transformations['filter']>} */ (options);
+    if (OPERATIONS_DEFAULTS.filter === amount) {
+      return '';
+    }
+    return `${operation}/${name}/${amount}`;
+  }
+
+  if (operation === 'crop' && options) {
+    let { dimensions, coords } = /** @type {NonNullable<import('../types').Transformations['crop']>} */ (options);
+    return `${operation}/${dimensions.join('x')}/${coords.join(',')}`;
+  }
+
+  return '';
+}
+
+/**
+ * @param {import('../types').Transformations} transformations
+ * @returns {string}
+ */
+export function transformationsToOperations(transformations) {
+  return joinCdnOperations(
+    ...SUPPORTED_OPERATIONS_ORDERED.filter(
+      (operation) => typeof transformations[operation] !== 'undefined' && transformations[operation] !== null,
+    )
+      .map((operation) => {
+        let options = transformations[operation];
+        return transformationToStr(operation, options);
+      })
+      .filter((str) => !!str),
+  );
+}
+
+export const COMMON_OPERATIONS = joinCdnOperations('format/auto', 'progressive/yes');
+
+/** @param {[unknown]} arg */
+const asNumber = ([value]) => (typeof value !== 'undefined' ? Number(value) : undefined);
+const asBoolean = () => true;
+/** @param {[string, unknown]} arg */
+const asFilter = ([name, amount]) => ({
+  name,
+  amount: typeof amount !== 'undefined' ? Number(amount) : 100,
+});
+
+/**
+ * Docs: https://uploadcare.com/docs/transformations/image/resize-crop/#operation-crop We don't support percentages and
+ * alignment presets, Because it's unclear how to handle them in the Editor UI TODO: add support for percentages and
+ * alignment presets
+ *
+ * @param {[string, string]} arg
+ */
+const asCrop = ([dimensions, alignment]) => {
+  if (!/\d+x\d+/.test(dimensions) || !/\d+,\d+/.test(alignment)) {
+    throw new Error('Crop by aspect ratio, percentage or alignment shortcuts is not supported.');
+  }
+
+  return /** @type {{ dimensions: [number, number]; coords: [number, number] }} */ ({
+    dimensions: stringToArray(dimensions, 'x').map(Number),
+    coords: stringToArray(alignment).map(Number),
+  });
+};
+
+/**
+ * @type {{
+ *   [K in keyof Required<import('../types').Transformations>]: (args: any) => import('../types').Transformations[K];
+ * }}
+ */
+const OPERATION_PROCESSORS = Object.freeze({
+  enhance: asNumber,
+  brightness: asNumber,
+  exposure: asNumber,
+  gamma: asNumber,
+  contrast: asNumber,
+  saturation: asNumber,
+  vibrance: asNumber,
+  warmth: asNumber,
+  filter: asFilter,
+  mirror: asBoolean,
+  flip: asBoolean,
+  rotate: asNumber,
+  crop: asCrop,
+});
+
+/**
+ * @param {string[]} operations
+ * @returns {import('../types.js').Transformations}
+ */
+export function operationsToTransformations(operations) {
+  /** @type {Record<string, unknown>} */
+  const transformations = {};
+  for (const operation of operations) {
+    const [name, ...args] = operation.split('/');
+    if (!SUPPORTED_OPERATIONS_ORDERED.includes(name)) {
+      continue;
+    }
+    const operationName = /** @type {(typeof SUPPORTED_OPERATIONS_ORDERED)[number]} */ (name);
+    const processor = OPERATION_PROCESSORS[operationName];
+    try {
+      const value = processor(args);
+      transformations[operationName] = value;
+    } catch (err) {
+      console.warn(
+        [
+          `Failed to parse URL operation "${operation}". It will be ignored.`,
+          err instanceof Error ? `Error message: "${err.message}"` : err,
+          'If you need this functionality, please feel free to open an issue at https://github.com/uploadcare/blocks/issues/new',
+        ].join('\n'),
+      );
+    }
+  }
+
+  return /** @type {import('../types.js').Transformations} */ (transformations);
+}