[Summary view] [Print] [Text view]

   1  /******/ (() => { // webpackBootstrap
   2  /******/     "use strict";
   3  /******/     // The require scope
   4  /******/     var __webpack_require__ = {};
   5  /******/     
   6  /************************************************************************/
   7  /******/     /* webpack/runtime/compat get default export */
   8  /******/     (() => {
   9  /******/         // getDefaultExport function for compatibility with non-harmony modules
  10  /******/         __webpack_require__.n = (module) => {
  11  /******/             var getter = module && module.__esModule ?
  12  /******/                 () => (module['default']) :
  13  /******/                 () => (module);
  14  /******/             __webpack_require__.d(getter, { a: getter });
  15  /******/             return getter;
  16  /******/         };
  17  /******/     })();
  18  /******/     
  19  /******/     /* webpack/runtime/define property getters */
  20  /******/     (() => {
  21  /******/         // define getter functions for harmony exports
  22  /******/         __webpack_require__.d = (exports, definition) => {
  23  /******/             for(var key in definition) {
  24  /******/                 if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
  25  /******/                     Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
  26  /******/                 }
  27  /******/             }
  28  /******/         };
  29  /******/     })();
  30  /******/     
  31  /******/     /* webpack/runtime/hasOwnProperty shorthand */
  32  /******/     (() => {
  33  /******/         __webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
  34  /******/     })();
  35  /******/     
  36  /******/     /* webpack/runtime/make namespace object */
  37  /******/     (() => {
  38  /******/         // define __esModule on exports
  39  /******/         __webpack_require__.r = (exports) => {
  40  /******/             if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
  41  /******/                 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
  42  /******/             }
  43  /******/             Object.defineProperty(exports, '__esModule', { value: true });
  44  /******/         };
  45  /******/     })();
  46  /******/     
  47  /************************************************************************/
  48  var __webpack_exports__ = {};
  49  // ESM COMPAT FLAG
  50  __webpack_require__.r(__webpack_exports__);
  51  
  52  // EXPORTS
  53  __webpack_require__.d(__webpack_exports__, {
  54    MediaUpload: () => (/* reexport */ media_upload_default),
  55    privateApis: () => (/* reexport */ privateApis),
  56    transformAttachment: () => (/* reexport */ transformAttachment),
  57    uploadMedia: () => (/* reexport */ uploadMedia),
  58    validateFileSize: () => (/* reexport */ validateFileSize),
  59    validateMimeType: () => (/* reexport */ validateMimeType),
  60    validateMimeTypeForUser: () => (/* reexport */ validateMimeTypeForUser)
  61  });
  62  
  63  ;// external ["wp","element"]
  64  const external_wp_element_namespaceObject = window["wp"]["element"];
  65  ;// external ["wp","i18n"]
  66  const external_wp_i18n_namespaceObject = window["wp"]["i18n"];
  67  ;// ./node_modules/@wordpress/media-utils/build-module/components/media-upload/index.js
  68  
  69  
  70  const DEFAULT_EMPTY_GALLERY = [];
  71  const getFeaturedImageMediaFrame = () => {
  72    const { wp } = window;
  73    return wp.media.view.MediaFrame.Select.extend({
  74      /**
  75       * Enables the Set Featured Image Button.
  76       *
  77       * @param {Object} toolbar toolbar for featured image state
  78       * @return {void}
  79       */
  80      featuredImageToolbar(toolbar) {
  81        this.createSelectToolbar(toolbar, {
  82          text: wp.media.view.l10n.setFeaturedImage,
  83          state: this.options.state
  84        });
  85      },
  86      /**
  87       * Handle the edit state requirements of selected media item.
  88       *
  89       * @return {void}
  90       */
  91      editState() {
  92        const selection = this.state("featured-image").get("selection");
  93        const view = new wp.media.view.EditImage({
  94          model: selection.single(),
  95          controller: this
  96        }).render();
  97        this.content.set(view);
  98        view.loadEditor();
  99      },
 100      /**
 101       * Create the default states.
 102       *
 103       * @return {void}
 104       */
 105      createStates: function createStates() {
 106        this.on(
 107          "toolbar:create:featured-image",
 108          this.featuredImageToolbar,
 109          this
 110        );
 111        this.on("content:render:edit-image", this.editState, this);
 112        this.states.add([
 113          new wp.media.controller.FeaturedImage(),
 114          new wp.media.controller.EditImage({
 115            model: this.options.editImage
 116          })
 117        ]);
 118      }
 119    });
 120  };
 121  const getSingleMediaFrame = () => {
 122    const { wp } = window;
 123    return wp.media.view.MediaFrame.Select.extend({
 124      /**
 125       * Create the default states on the frame.
 126       */
 127      createStates() {
 128        const options = this.options;
 129        if (this.options.states) {
 130          return;
 131        }
 132        this.states.add([
 133          // Main states.
 134          new wp.media.controller.Library({
 135            library: wp.media.query(options.library),
 136            multiple: options.multiple,
 137            title: options.title,
 138            priority: 20,
 139            filterable: "uploaded"
 140            // Allow filtering by uploaded images.
 141          }),
 142          new wp.media.controller.EditImage({
 143            model: options.editImage
 144          })
 145        ]);
 146      }
 147    });
 148  };
 149  const getGalleryDetailsMediaFrame = () => {
 150    const { wp } = window;
 151    return wp.media.view.MediaFrame.Post.extend({
 152      /**
 153       * Set up gallery toolbar.
 154       *
 155       * @return {void}
 156       */
 157      galleryToolbar() {
 158        const editing = this.state().get("editing");
 159        this.toolbar.set(
 160          new wp.media.view.Toolbar({
 161            controller: this,
 162            items: {
 163              insert: {
 164                style: "primary",
 165                text: editing ? wp.media.view.l10n.updateGallery : wp.media.view.l10n.insertGallery,
 166                priority: 80,
 167                requires: { library: true },
 168                /**
 169                 * @fires wp.media.controller.State#update
 170                 */
 171                click() {
 172                  const controller = this.controller, state = controller.state();
 173                  controller.close();
 174                  state.trigger(
 175                    "update",
 176                    state.get("library")
 177                  );
 178                  controller.setState(controller.options.state);
 179                  controller.reset();
 180                }
 181              }
 182            }
 183          })
 184        );
 185      },
 186      /**
 187       * Handle the edit state requirements of selected media item.
 188       *
 189       * @return {void}
 190       */
 191      editState() {
 192        const selection = this.state("gallery").get("selection");
 193        const view = new wp.media.view.EditImage({
 194          model: selection.single(),
 195          controller: this
 196        }).render();
 197        this.content.set(view);
 198        view.loadEditor();
 199      },
 200      /**
 201       * Create the default states.
 202       *
 203       * @return {void}
 204       */
 205      createStates: function createStates() {
 206        this.on("toolbar:create:main-gallery", this.galleryToolbar, this);
 207        this.on("content:render:edit-image", this.editState, this);
 208        this.states.add([
 209          new wp.media.controller.Library({
 210            id: "gallery",
 211            title: wp.media.view.l10n.createGalleryTitle,
 212            priority: 40,
 213            toolbar: "main-gallery",
 214            filterable: "uploaded",
 215            multiple: "add",
 216            editable: false,
 217            library: wp.media.query({
 218              type: "image",
 219              ...this.options.library
 220            })
 221          }),
 222          new wp.media.controller.EditImage({
 223            model: this.options.editImage
 224          }),
 225          new wp.media.controller.GalleryEdit({
 226            library: this.options.selection,
 227            editing: this.options.editing,
 228            menu: "gallery",
 229            displaySettings: false,
 230            multiple: true
 231          }),
 232          new wp.media.controller.GalleryAdd()
 233        ]);
 234      }
 235    });
 236  };
 237  const slimImageObject = (img) => {
 238    const attrSet = [
 239      "sizes",
 240      "mime",
 241      "type",
 242      "subtype",
 243      "id",
 244      "url",
 245      "alt",
 246      "link",
 247      "caption"
 248    ];
 249    return attrSet.reduce((result, key) => {
 250      if (img?.hasOwnProperty(key)) {
 251        result[key] = img[key];
 252      }
 253      return result;
 254    }, {});
 255  };
 256  const getAttachmentsCollection = (ids) => {
 257    const { wp } = window;
 258    return wp.media.query({
 259      order: "ASC",
 260      orderby: "post__in",
 261      post__in: ids,
 262      posts_per_page: -1,
 263      query: true,
 264      type: "image"
 265    });
 266  };
 267  class MediaUpload extends external_wp_element_namespaceObject.Component {
 268    constructor() {
 269      super(...arguments);
 270      this.openModal = this.openModal.bind(this);
 271      this.onOpen = this.onOpen.bind(this);
 272      this.onSelect = this.onSelect.bind(this);
 273      this.onUpdate = this.onUpdate.bind(this);
 274      this.onClose = this.onClose.bind(this);
 275    }
 276    initializeListeners() {
 277      this.frame.on("select", this.onSelect);
 278      this.frame.on("update", this.onUpdate);
 279      this.frame.on("open", this.onOpen);
 280      this.frame.on("close", this.onClose);
 281    }
 282    /**
 283     * Sets the Gallery frame and initializes listeners.
 284     *
 285     * @return {void}
 286     */
 287    buildAndSetGalleryFrame() {
 288      const {
 289        addToGallery = false,
 290        allowedTypes,
 291        multiple = false,
 292        value = DEFAULT_EMPTY_GALLERY
 293      } = this.props;
 294      if (value === this.lastGalleryValue) {
 295        return;
 296      }
 297      const { wp } = window;
 298      this.lastGalleryValue = value;
 299      if (this.frame) {
 300        this.frame.remove();
 301      }
 302      let currentState;
 303      if (addToGallery) {
 304        currentState = "gallery-library";
 305      } else {
 306        currentState = value && value.length ? "gallery-edit" : "gallery";
 307      }
 308      if (!this.GalleryDetailsMediaFrame) {
 309        this.GalleryDetailsMediaFrame = getGalleryDetailsMediaFrame();
 310      }
 311      const attachments = getAttachmentsCollection(value);
 312      const selection = new wp.media.model.Selection(attachments.models, {
 313        props: attachments.props.toJSON(),
 314        multiple
 315      });
 316      this.frame = new this.GalleryDetailsMediaFrame({
 317        mimeType: allowedTypes,
 318        state: currentState,
 319        multiple,
 320        selection,
 321        editing: !!value?.length
 322      });
 323      wp.media.frame = this.frame;
 324      this.initializeListeners();
 325    }
 326    /**
 327     * Initializes the Media Library requirements for the featured image flow.
 328     *
 329     * @return {void}
 330     */
 331    buildAndSetFeatureImageFrame() {
 332      const { wp } = window;
 333      const { value: featuredImageId, multiple, allowedTypes } = this.props;
 334      const featuredImageFrame = getFeaturedImageMediaFrame();
 335      const attachments = getAttachmentsCollection(featuredImageId);
 336      const selection = new wp.media.model.Selection(attachments.models, {
 337        props: attachments.props.toJSON()
 338      });
 339      this.frame = new featuredImageFrame({
 340        mimeType: allowedTypes,
 341        state: "featured-image",
 342        multiple,
 343        selection,
 344        editing: featuredImageId
 345      });
 346      wp.media.frame = this.frame;
 347      wp.media.view.settings.post = {
 348        ...wp.media.view.settings.post,
 349        featuredImageId: featuredImageId || -1
 350      };
 351    }
 352    /**
 353     * Initializes the Media Library requirements for the single image flow.
 354     *
 355     * @return {void}
 356     */
 357    buildAndSetSingleMediaFrame() {
 358      const { wp } = window;
 359      const {
 360        allowedTypes,
 361        multiple = false,
 362        title = (0,external_wp_i18n_namespaceObject.__)("Select or Upload Media"),
 363        value
 364      } = this.props;
 365      const frameConfig = {
 366        title,
 367        multiple
 368      };
 369      if (!!allowedTypes) {
 370        frameConfig.library = { type: allowedTypes };
 371      }
 372      if (this.frame) {
 373        this.frame.remove();
 374      }
 375      const singleImageFrame = getSingleMediaFrame();
 376      const attachments = getAttachmentsCollection(value);
 377      const selection = new wp.media.model.Selection(attachments.models, {
 378        props: attachments.props.toJSON()
 379      });
 380      this.frame = new singleImageFrame({
 381        mimeType: allowedTypes,
 382        multiple,
 383        selection,
 384        ...frameConfig
 385      });
 386      wp.media.frame = this.frame;
 387    }
 388    componentWillUnmount() {
 389      this.frame?.remove();
 390    }
 391    onUpdate(selections) {
 392      const { onSelect, multiple = false } = this.props;
 393      const state = this.frame.state();
 394      const selectedImages = selections || state.get("selection");
 395      if (!selectedImages || !selectedImages.models.length) {
 396        return;
 397      }
 398      if (multiple) {
 399        onSelect(
 400          selectedImages.models.map(
 401            (model) => slimImageObject(model.toJSON())
 402          )
 403        );
 404      } else {
 405        onSelect(slimImageObject(selectedImages.models[0].toJSON()));
 406      }
 407    }
 408    onSelect() {
 409      const { onSelect, multiple = false } = this.props;
 410      const attachment = this.frame.state().get("selection").toJSON();
 411      onSelect(multiple ? attachment : attachment[0]);
 412    }
 413    onOpen() {
 414      const { wp } = window;
 415      const { value } = this.props;
 416      this.updateCollection();
 417      if (this.props.mode) {
 418        this.frame.content.mode(this.props.mode);
 419      }
 420      const hasMedia = Array.isArray(value) ? !!value?.length : !!value;
 421      if (!hasMedia) {
 422        return;
 423      }
 424      const isGallery = this.props.gallery;
 425      const selection = this.frame.state().get("selection");
 426      const valueArray = Array.isArray(value) ? value : [value];
 427      if (!isGallery) {
 428        valueArray.forEach((id) => {
 429          selection.add(wp.media.attachment(id));
 430        });
 431      }
 432      const attachments = getAttachmentsCollection(valueArray);
 433      attachments.more().done(function() {
 434        if (isGallery && attachments?.models?.length) {
 435          selection.add(attachments.models);
 436        }
 437      });
 438    }
 439    onClose() {
 440      const { onClose } = this.props;
 441      if (onClose) {
 442        onClose();
 443      }
 444      this.frame.detach();
 445    }
 446    updateCollection() {
 447      const frameContent = this.frame.content.get();
 448      if (frameContent && frameContent.collection) {
 449        const collection = frameContent.collection;
 450        collection.toArray().forEach((model) => model.trigger("destroy", model));
 451        collection.mirroring._hasMore = true;
 452        collection.more();
 453      }
 454    }
 455    openModal() {
 456      const {
 457        gallery = false,
 458        unstableFeaturedImageFlow = false,
 459        modalClass
 460      } = this.props;
 461      if (gallery) {
 462        this.buildAndSetGalleryFrame();
 463      } else {
 464        this.buildAndSetSingleMediaFrame();
 465      }
 466      if (modalClass) {
 467        this.frame.$el.addClass(modalClass);
 468      }
 469      if (unstableFeaturedImageFlow) {
 470        this.buildAndSetFeatureImageFrame();
 471      }
 472      this.initializeListeners();
 473      this.frame.open();
 474    }
 475    render() {
 476      return this.props.render({ open: this.openModal });
 477    }
 478  }
 479  var media_upload_default = MediaUpload;
 480  
 481  
 482  ;// ./node_modules/@wordpress/media-utils/build-module/components/index.js
 483  
 484  
 485  
 486  ;// external ["wp","blob"]
 487  const external_wp_blob_namespaceObject = window["wp"]["blob"];
 488  ;// external ["wp","apiFetch"]
 489  const external_wp_apiFetch_namespaceObject = window["wp"]["apiFetch"];
 490  var external_wp_apiFetch_default = /*#__PURE__*/__webpack_require__.n(external_wp_apiFetch_namespaceObject);
 491  ;// ./node_modules/@wordpress/media-utils/build-module/utils/flatten-form-data.js
 492  function isPlainObject(data) {
 493    return data !== null && typeof data === "object" && Object.getPrototypeOf(data) === Object.prototype;
 494  }
 495  function flattenFormData(formData, key, data) {
 496    if (isPlainObject(data)) {
 497      for (const [name, value] of Object.entries(data)) {
 498        flattenFormData(formData, `$key}[$name}]`, value);
 499      }
 500    } else if (data !== void 0) {
 501      formData.append(key, String(data));
 502    }
 503  }
 504  
 505  
 506  ;// ./node_modules/@wordpress/media-utils/build-module/utils/transform-attachment.js
 507  function transformAttachment(attachment) {
 508    const { alt_text, source_url, ...savedMediaProps } = attachment;
 509    return {
 510      ...savedMediaProps,
 511      alt: attachment.alt_text,
 512      caption: attachment.caption?.raw ?? "",
 513      title: attachment.title.raw,
 514      url: attachment.source_url,
 515      poster: attachment._embedded?.["wp:featuredmedia"]?.[0]?.source_url || void 0
 516    };
 517  }
 518  
 519  
 520  ;// ./node_modules/@wordpress/media-utils/build-module/utils/upload-to-server.js
 521  
 522  
 523  
 524  async function uploadToServer(file, additionalData = {}, signal) {
 525    const data = new FormData();
 526    data.append("file", file, file.name || file.type.replace("/", "."));
 527    for (const [key, value] of Object.entries(additionalData)) {
 528      flattenFormData(
 529        data,
 530        key,
 531        value
 532      );
 533    }
 534    return transformAttachment(
 535      await external_wp_apiFetch_default()({
 536        // This allows the video block to directly get a video's poster image.
 537        path: "/wp/v2/media?_embed=wp:featuredmedia",
 538        body: data,
 539        method: "POST",
 540        signal
 541      })
 542    );
 543  }
 544  
 545  
 546  ;// ./node_modules/@wordpress/media-utils/build-module/utils/upload-error.js
 547  class UploadError extends Error {
 548    code;
 549    file;
 550    constructor({ code, message, file, cause }) {
 551      super(message, { cause });
 552      Object.setPrototypeOf(this, new.target.prototype);
 553      this.code = code;
 554      this.file = file;
 555    }
 556  }
 557  
 558  
 559  ;// ./node_modules/@wordpress/media-utils/build-module/utils/validate-mime-type.js
 560  
 561  
 562  function validateMimeType(file, allowedTypes) {
 563    if (!allowedTypes) {
 564      return;
 565    }
 566    const isAllowedType = allowedTypes.some((allowedType) => {
 567      if (allowedType.includes("/")) {
 568        return allowedType === file.type;
 569      }
 570      return file.type.startsWith(`$allowedType}/`);
 571    });
 572    if (file.type && !isAllowedType) {
 573      throw new UploadError({
 574        code: "MIME_TYPE_NOT_SUPPORTED",
 575        message: (0,external_wp_i18n_namespaceObject.sprintf)(
 576          // translators: %s: file name.
 577          (0,external_wp_i18n_namespaceObject.__)("%s: Sorry, this file type is not supported here."),
 578          file.name
 579        ),
 580        file
 581      });
 582    }
 583  }
 584  
 585  
 586  ;// ./node_modules/@wordpress/media-utils/build-module/utils/get-mime-types-array.js
 587  function getMimeTypesArray(wpMimeTypesObject) {
 588    if (!wpMimeTypesObject) {
 589      return null;
 590    }
 591    return Object.entries(wpMimeTypesObject).flatMap(
 592      ([extensionsString, mime]) => {
 593        const [type] = mime.split("/");
 594        const extensions = extensionsString.split("|");
 595        return [
 596          mime,
 597          ...extensions.map(
 598            (extension) => `$type}/$extension}`
 599          )
 600        ];
 601      }
 602    );
 603  }
 604  
 605  
 606  ;// ./node_modules/@wordpress/media-utils/build-module/utils/validate-mime-type-for-user.js
 607  
 608  
 609  
 610  function validateMimeTypeForUser(file, wpAllowedMimeTypes) {
 611    const allowedMimeTypesForUser = getMimeTypesArray(wpAllowedMimeTypes);
 612    if (!allowedMimeTypesForUser) {
 613      return;
 614    }
 615    const isAllowedMimeTypeForUser = allowedMimeTypesForUser.includes(
 616      file.type
 617    );
 618    if (file.type && !isAllowedMimeTypeForUser) {
 619      throw new UploadError({
 620        code: "MIME_TYPE_NOT_ALLOWED_FOR_USER",
 621        message: (0,external_wp_i18n_namespaceObject.sprintf)(
 622          // translators: %s: file name.
 623          (0,external_wp_i18n_namespaceObject.__)(
 624            "%s: Sorry, you are not allowed to upload this file type."
 625          ),
 626          file.name
 627        ),
 628        file
 629      });
 630    }
 631  }
 632  
 633  
 634  ;// ./node_modules/@wordpress/media-utils/build-module/utils/validate-file-size.js
 635  
 636  
 637  function validateFileSize(file, maxUploadFileSize) {
 638    if (file.size <= 0) {
 639      throw new UploadError({
 640        code: "EMPTY_FILE",
 641        message: (0,external_wp_i18n_namespaceObject.sprintf)(
 642          // translators: %s: file name.
 643          (0,external_wp_i18n_namespaceObject.__)("%s: This file is empty."),
 644          file.name
 645        ),
 646        file
 647      });
 648    }
 649    if (maxUploadFileSize && file.size > maxUploadFileSize) {
 650      throw new UploadError({
 651        code: "SIZE_ABOVE_LIMIT",
 652        message: (0,external_wp_i18n_namespaceObject.sprintf)(
 653          // translators: %s: file name.
 654          (0,external_wp_i18n_namespaceObject.__)(
 655            "%s: This file exceeds the maximum upload size for this site."
 656          ),
 657          file.name
 658        ),
 659        file
 660      });
 661    }
 662  }
 663  
 664  
 665  ;// ./node_modules/@wordpress/media-utils/build-module/utils/upload-media.js
 666  
 667  
 668  
 669  
 670  
 671  
 672  
 673  function uploadMedia({
 674    wpAllowedMimeTypes,
 675    allowedTypes,
 676    additionalData = {},
 677    filesList,
 678    maxUploadFileSize,
 679    onError,
 680    onFileChange,
 681    signal,
 682    multiple = true
 683  }) {
 684    if (!multiple && filesList.length > 1) {
 685      onError?.(new Error((0,external_wp_i18n_namespaceObject.__)("Only one file can be used here.")));
 686      return;
 687    }
 688    const validFiles = [];
 689    const filesSet = [];
 690    const setAndUpdateFiles = (index, value) => {
 691      if (!window.__experimentalMediaProcessing) {
 692        if (filesSet[index]?.url) {
 693          (0,external_wp_blob_namespaceObject.revokeBlobURL)(filesSet[index].url);
 694        }
 695      }
 696      filesSet[index] = value;
 697      onFileChange?.(
 698        filesSet.filter((attachment) => attachment !== null)
 699      );
 700    };
 701    for (const mediaFile of filesList) {
 702      try {
 703        validateMimeTypeForUser(mediaFile, wpAllowedMimeTypes);
 704      } catch (error) {
 705        onError?.(error);
 706        continue;
 707      }
 708      try {
 709        validateMimeType(mediaFile, allowedTypes);
 710      } catch (error) {
 711        onError?.(error);
 712        continue;
 713      }
 714      try {
 715        validateFileSize(mediaFile, maxUploadFileSize);
 716      } catch (error) {
 717        onError?.(error);
 718        continue;
 719      }
 720      validFiles.push(mediaFile);
 721      if (!window.__experimentalMediaProcessing) {
 722        filesSet.push({ url: (0,external_wp_blob_namespaceObject.createBlobURL)(mediaFile) });
 723        onFileChange?.(filesSet);
 724      }
 725    }
 726    validFiles.map(async (file, index) => {
 727      try {
 728        const attachment = await uploadToServer(
 729          file,
 730          additionalData,
 731          signal
 732        );
 733        setAndUpdateFiles(index, attachment);
 734      } catch (error) {
 735        setAndUpdateFiles(index, null);
 736        let message;
 737        if (typeof error === "object" && error !== null && "message" in error) {
 738          message = typeof error.message === "string" ? error.message : String(error.message);
 739        } else {
 740          message = (0,external_wp_i18n_namespaceObject.sprintf)(
 741            // translators: %s: file name
 742            (0,external_wp_i18n_namespaceObject.__)("Error while uploading file %s to the media library."),
 743            file.name
 744          );
 745        }
 746        onError?.(
 747          new UploadError({
 748            code: "GENERAL",
 749            message,
 750            file,
 751            cause: error instanceof Error ? error : void 0
 752          })
 753        );
 754      }
 755    });
 756  }
 757  
 758  
 759  ;// ./node_modules/@wordpress/media-utils/build-module/utils/sideload-to-server.js
 760  
 761  
 762  
 763  async function sideloadToServer(file, attachmentId, additionalData = {}, signal) {
 764    const data = new FormData();
 765    data.append("file", file, file.name || file.type.replace("/", "."));
 766    for (const [key, value] of Object.entries(additionalData)) {
 767      flattenFormData(
 768        data,
 769        key,
 770        value
 771      );
 772    }
 773    return transformAttachment(
 774      await external_wp_apiFetch_default()({
 775        path: `/wp/v2/media/$attachmentId}/sideload`,
 776        body: data,
 777        method: "POST",
 778        signal
 779      })
 780    );
 781  }
 782  
 783  
 784  ;// ./node_modules/@wordpress/media-utils/build-module/utils/sideload-media.js
 785  
 786  
 787  
 788  const noop = () => {
 789  };
 790  async function sideloadMedia({
 791    file,
 792    attachmentId,
 793    additionalData = {},
 794    signal,
 795    onFileChange,
 796    onError = noop
 797  }) {
 798    try {
 799      const attachment = await sideloadToServer(
 800        file,
 801        attachmentId,
 802        additionalData,
 803        signal
 804      );
 805      onFileChange?.([attachment]);
 806    } catch (error) {
 807      let message;
 808      if (error instanceof Error) {
 809        message = error.message;
 810      } else {
 811        message = (0,external_wp_i18n_namespaceObject.sprintf)(
 812          // translators: %s: file name
 813          (0,external_wp_i18n_namespaceObject.__)("Error while sideloading file %s to the server."),
 814          file.name
 815        );
 816      }
 817      onError(
 818        new UploadError({
 819          code: "GENERAL",
 820          message,
 821          file,
 822          cause: error instanceof Error ? error : void 0
 823        })
 824      );
 825    }
 826  }
 827  
 828  
 829  ;// external ["wp","privateApis"]
 830  const external_wp_privateApis_namespaceObject = window["wp"]["privateApis"];
 831  ;// ./node_modules/@wordpress/media-utils/build-module/lock-unlock.js
 832  
 833  const { lock, unlock } = (0,external_wp_privateApis_namespaceObject.__dangerousOptInToUnstableAPIsOnlyForCoreModules)(
 834    "I acknowledge private features are not for use in themes or plugins and doing so will break in the next version of WordPress.",
 835    "@wordpress/media-utils"
 836  );
 837  
 838  
 839  ;// ./node_modules/@wordpress/media-utils/build-module/private-apis.js
 840  
 841  
 842  const privateApis = {};
 843  lock(privateApis, {
 844    sideloadMedia: sideloadMedia
 845  });
 846  
 847  
 848  ;// ./node_modules/@wordpress/media-utils/build-module/index.js
 849  
 850  
 851  
 852  
 853  
 854  
 855  
 856  
 857  
 858  (window.wp = window.wp || {}).mediaUtils = __webpack_exports__;
 859  /******/ })()
 860  ;