[Summary view] [Print] [Text view]

   1  /******/ (() => { // webpackBootstrap
   2  /******/     var __webpack_modules__ = ({
   3  
   4  /***/ 197:
   5  /***/ (() => {
   6  
   7  /* (ignored) */
   8  
   9  /***/ }),
  10  
  11  /***/ 271:
  12  /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
  13  
  14  "use strict";
  15  
  16  
  17  let Container = __webpack_require__(683)
  18  
  19  let LazyResult, Processor
  20  
  21  class Document extends Container {
  22    constructor(defaults) {
  23      // type needs to be passed to super, otherwise child roots won't be normalized correctly
  24      super({ type: 'document', ...defaults })
  25  
  26      if (!this.nodes) {
  27        this.nodes = []
  28      }
  29    }
  30  
  31    toResult(opts = {}) {
  32      let lazy = new LazyResult(new Processor(), this, opts)
  33  
  34      return lazy.stringify()
  35    }
  36  }
  37  
  38  Document.registerLazyResult = dependant => {
  39    LazyResult = dependant
  40  }
  41  
  42  Document.registerProcessor = dependant => {
  43    Processor = dependant
  44  }
  45  
  46  module.exports = Document
  47  Document.default = Document
  48  
  49  
  50  /***/ }),
  51  
  52  /***/ 346:
  53  /***/ ((module) => {
  54  
  55  "use strict";
  56  
  57  
  58  const DEFAULT_RAW = {
  59    after: '\n',
  60    beforeClose: '\n',
  61    beforeComment: '\n',
  62    beforeDecl: '\n',
  63    beforeOpen: ' ',
  64    beforeRule: '\n',
  65    colon: ': ',
  66    commentLeft: ' ',
  67    commentRight: ' ',
  68    emptyBody: '',
  69    indent: '    ',
  70    semicolon: false
  71  }
  72  
  73  function capitalize(str) {
  74    return str[0].toUpperCase() + str.slice(1)
  75  }
  76  
  77  class Stringifier {
  78    constructor(builder) {
  79      this.builder = builder
  80    }
  81  
  82    atrule(node, semicolon) {
  83      let name = '@' + node.name
  84      let params = node.params ? this.rawValue(node, 'params') : ''
  85  
  86      if (typeof node.raws.afterName !== 'undefined') {
  87        name += node.raws.afterName
  88      } else if (params) {
  89        name += ' '
  90      }
  91  
  92      if (node.nodes) {
  93        this.block(node, name + params)
  94      } else {
  95        let end = (node.raws.between || '') + (semicolon ? ';' : '')
  96        this.builder(name + params + end, node)
  97      }
  98    }
  99  
 100    beforeAfter(node, detect) {
 101      let value
 102      if (node.type === 'decl') {
 103        value = this.raw(node, null, 'beforeDecl')
 104      } else if (node.type === 'comment') {
 105        value = this.raw(node, null, 'beforeComment')
 106      } else if (detect === 'before') {
 107        value = this.raw(node, null, 'beforeRule')
 108      } else {
 109        value = this.raw(node, null, 'beforeClose')
 110      }
 111  
 112      let buf = node.parent
 113      let depth = 0
 114      while (buf && buf.type !== 'root') {
 115        depth += 1
 116        buf = buf.parent
 117      }
 118  
 119      if (value.includes('\n')) {
 120        let indent = this.raw(node, null, 'indent')
 121        if (indent.length) {
 122          for (let step = 0; step < depth; step++) value += indent
 123        }
 124      }
 125  
 126      return value
 127    }
 128  
 129    block(node, start) {
 130      let between = this.raw(node, 'between', 'beforeOpen')
 131      this.builder(start + between + '{', node, 'start')
 132  
 133      let after
 134      if (node.nodes && node.nodes.length) {
 135        this.body(node)
 136        after = this.raw(node, 'after')
 137      } else {
 138        after = this.raw(node, 'after', 'emptyBody')
 139      }
 140  
 141      if (after) this.builder(after)
 142      this.builder('}', node, 'end')
 143    }
 144  
 145    body(node) {
 146      let last = node.nodes.length - 1
 147      while (last > 0) {
 148        if (node.nodes[last].type !== 'comment') break
 149        last -= 1
 150      }
 151  
 152      let semicolon = this.raw(node, 'semicolon')
 153      for (let i = 0; i < node.nodes.length; i++) {
 154        let child = node.nodes[i]
 155        let before = this.raw(child, 'before')
 156        if (before) this.builder(before)
 157        this.stringify(child, last !== i || semicolon)
 158      }
 159    }
 160  
 161    comment(node) {
 162      let left = this.raw(node, 'left', 'commentLeft')
 163      let right = this.raw(node, 'right', 'commentRight')
 164      this.builder('/*' + left + node.text + right + '*/', node)
 165    }
 166  
 167    decl(node, semicolon) {
 168      let between = this.raw(node, 'between', 'colon')
 169      let string = node.prop + between + this.rawValue(node, 'value')
 170  
 171      if (node.important) {
 172        string += node.raws.important || ' !important'
 173      }
 174  
 175      if (semicolon) string += ';'
 176      this.builder(string, node)
 177    }
 178  
 179    document(node) {
 180      this.body(node)
 181    }
 182  
 183    raw(node, own, detect) {
 184      let value
 185      if (!detect) detect = own
 186  
 187      // Already had
 188      if (own) {
 189        value = node.raws[own]
 190        if (typeof value !== 'undefined') return value
 191      }
 192  
 193      let parent = node.parent
 194  
 195      if (detect === 'before') {
 196        // Hack for first rule in CSS
 197        if (!parent || (parent.type === 'root' && parent.first === node)) {
 198          return ''
 199        }
 200  
 201        // `root` nodes in `document` should use only their own raws
 202        if (parent && parent.type === 'document') {
 203          return ''
 204        }
 205      }
 206  
 207      // Floating child without parent
 208      if (!parent) return DEFAULT_RAW[detect]
 209  
 210      // Detect style by other nodes
 211      let root = node.root()
 212      if (!root.rawCache) root.rawCache = {}
 213      if (typeof root.rawCache[detect] !== 'undefined') {
 214        return root.rawCache[detect]
 215      }
 216  
 217      if (detect === 'before' || detect === 'after') {
 218        return this.beforeAfter(node, detect)
 219      } else {
 220        let method = 'raw' + capitalize(detect)
 221        if (this[method]) {
 222          value = this[method](root, node)
 223        } else {
 224          root.walk(i => {
 225            value = i.raws[own]
 226            if (typeof value !== 'undefined') return false
 227          })
 228        }
 229      }
 230  
 231      if (typeof value === 'undefined') value = DEFAULT_RAW[detect]
 232  
 233      root.rawCache[detect] = value
 234      return value
 235    }
 236  
 237    rawBeforeClose(root) {
 238      let value
 239      root.walk(i => {
 240        if (i.nodes && i.nodes.length > 0) {
 241          if (typeof i.raws.after !== 'undefined') {
 242            value = i.raws.after
 243            if (value.includes('\n')) {
 244              value = value.replace(/[^\n]+$/, '')
 245            }
 246            return false
 247          }
 248        }
 249      })
 250      if (value) value = value.replace(/\S/g, '')
 251      return value
 252    }
 253  
 254    rawBeforeComment(root, node) {
 255      let value
 256      root.walkComments(i => {
 257        if (typeof i.raws.before !== 'undefined') {
 258          value = i.raws.before
 259          if (value.includes('\n')) {
 260            value = value.replace(/[^\n]+$/, '')
 261          }
 262          return false
 263        }
 264      })
 265      if (typeof value === 'undefined') {
 266        value = this.raw(node, null, 'beforeDecl')
 267      } else if (value) {
 268        value = value.replace(/\S/g, '')
 269      }
 270      return value
 271    }
 272  
 273    rawBeforeDecl(root, node) {
 274      let value
 275      root.walkDecls(i => {
 276        if (typeof i.raws.before !== 'undefined') {
 277          value = i.raws.before
 278          if (value.includes('\n')) {
 279            value = value.replace(/[^\n]+$/, '')
 280          }
 281          return false
 282        }
 283      })
 284      if (typeof value === 'undefined') {
 285        value = this.raw(node, null, 'beforeRule')
 286      } else if (value) {
 287        value = value.replace(/\S/g, '')
 288      }
 289      return value
 290    }
 291  
 292    rawBeforeOpen(root) {
 293      let value
 294      root.walk(i => {
 295        if (i.type !== 'decl') {
 296          value = i.raws.between
 297          if (typeof value !== 'undefined') return false
 298        }
 299      })
 300      return value
 301    }
 302  
 303    rawBeforeRule(root) {
 304      let value
 305      root.walk(i => {
 306        if (i.nodes && (i.parent !== root || root.first !== i)) {
 307          if (typeof i.raws.before !== 'undefined') {
 308            value = i.raws.before
 309            if (value.includes('\n')) {
 310              value = value.replace(/[^\n]+$/, '')
 311            }
 312            return false
 313          }
 314        }
 315      })
 316      if (value) value = value.replace(/\S/g, '')
 317      return value
 318    }
 319  
 320    rawColon(root) {
 321      let value
 322      root.walkDecls(i => {
 323        if (typeof i.raws.between !== 'undefined') {
 324          value = i.raws.between.replace(/[^\s:]/g, '')
 325          return false
 326        }
 327      })
 328      return value
 329    }
 330  
 331    rawEmptyBody(root) {
 332      let value
 333      root.walk(i => {
 334        if (i.nodes && i.nodes.length === 0) {
 335          value = i.raws.after
 336          if (typeof value !== 'undefined') return false
 337        }
 338      })
 339      return value
 340    }
 341  
 342    rawIndent(root) {
 343      if (root.raws.indent) return root.raws.indent
 344      let value
 345      root.walk(i => {
 346        let p = i.parent
 347        if (p && p !== root && p.parent && p.parent === root) {
 348          if (typeof i.raws.before !== 'undefined') {
 349            let parts = i.raws.before.split('\n')
 350            value = parts[parts.length - 1]
 351            value = value.replace(/\S/g, '')
 352            return false
 353          }
 354        }
 355      })
 356      return value
 357    }
 358  
 359    rawSemicolon(root) {
 360      let value
 361      root.walk(i => {
 362        if (i.nodes && i.nodes.length && i.last.type === 'decl') {
 363          value = i.raws.semicolon
 364          if (typeof value !== 'undefined') return false
 365        }
 366      })
 367      return value
 368    }
 369  
 370    rawValue(node, prop) {
 371      let value = node[prop]
 372      let raw = node.raws[prop]
 373      if (raw && raw.value === value) {
 374        return raw.raw
 375      }
 376  
 377      return value
 378    }
 379  
 380    root(node) {
 381      this.body(node)
 382      if (node.raws.after) this.builder(node.raws.after)
 383    }
 384  
 385    rule(node) {
 386      this.block(node, this.rawValue(node, 'selector'))
 387      if (node.raws.ownSemicolon) {
 388        this.builder(node.raws.ownSemicolon, node, 'end')
 389      }
 390    }
 391  
 392    stringify(node, semicolon) {
 393      /* c8 ignore start */
 394      if (!this[node.type]) {
 395        throw new Error(
 396          'Unknown AST node type ' +
 397            node.type +
 398            '. ' +
 399            'Maybe you need to change PostCSS stringifier.'
 400        )
 401      }
 402      /* c8 ignore stop */
 403      this[node.type](node, semicolon)
 404    }
 405  }
 406  
 407  module.exports = Stringifier
 408  Stringifier.default = Stringifier
 409  
 410  
 411  /***/ }),
 412  
 413  /***/ 356:
 414  /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 415  
 416  "use strict";
 417  
 418  
 419  let pico = __webpack_require__(2775)
 420  
 421  let terminalHighlight = __webpack_require__(9746)
 422  
 423  class CssSyntaxError extends Error {
 424    constructor(message, line, column, source, file, plugin) {
 425      super(message)
 426      this.name = 'CssSyntaxError'
 427      this.reason = message
 428  
 429      if (file) {
 430        this.file = file
 431      }
 432      if (source) {
 433        this.source = source
 434      }
 435      if (plugin) {
 436        this.plugin = plugin
 437      }
 438      if (typeof line !== 'undefined' && typeof column !== 'undefined') {
 439        if (typeof line === 'number') {
 440          this.line = line
 441          this.column = column
 442        } else {
 443          this.line = line.line
 444          this.column = line.column
 445          this.endLine = column.line
 446          this.endColumn = column.column
 447        }
 448      }
 449  
 450      this.setMessage()
 451  
 452      if (Error.captureStackTrace) {
 453        Error.captureStackTrace(this, CssSyntaxError)
 454      }
 455    }
 456  
 457    setMessage() {
 458      this.message = this.plugin ? this.plugin + ': ' : ''
 459      this.message += this.file ? this.file : '<css input>'
 460      if (typeof this.line !== 'undefined') {
 461        this.message += ':' + this.line + ':' + this.column
 462      }
 463      this.message += ': ' + this.reason
 464    }
 465  
 466    showSourceCode(color) {
 467      if (!this.source) return ''
 468  
 469      let css = this.source
 470      if (color == null) color = pico.isColorSupported
 471  
 472      let aside = text => text
 473      let mark = text => text
 474      let highlight = text => text
 475      if (color) {
 476        let { bold, gray, red } = pico.createColors(true)
 477        mark = text => bold(red(text))
 478        aside = text => gray(text)
 479        if (terminalHighlight) {
 480          highlight = text => terminalHighlight(text)
 481        }
 482      }
 483  
 484      let lines = css.split(/\r?\n/)
 485      let start = Math.max(this.line - 3, 0)
 486      let end = Math.min(this.line + 2, lines.length)
 487      let maxWidth = String(end).length
 488  
 489      return lines
 490        .slice(start, end)
 491        .map((line, index) => {
 492          let number = start + 1 + index
 493          let gutter = ' ' + (' ' + number).slice(-maxWidth) + ' | '
 494          if (number === this.line) {
 495            if (line.length > 160) {
 496              let padding = 20
 497              let subLineStart = Math.max(0, this.column - padding)
 498              let subLineEnd = Math.max(
 499                this.column + padding,
 500                this.endColumn + padding
 501              )
 502              let subLine = line.slice(subLineStart, subLineEnd)
 503  
 504              let spacing =
 505                aside(gutter.replace(/\d/g, ' ')) +
 506                line
 507                  .slice(0, Math.min(this.column - 1, padding - 1))
 508                  .replace(/[^\t]/g, ' ')
 509  
 510              return (
 511                mark('>') +
 512                aside(gutter) +
 513                highlight(subLine) +
 514                '\n ' +
 515                spacing +
 516                mark('^')
 517              )
 518            }
 519  
 520            let spacing =
 521              aside(gutter.replace(/\d/g, ' ')) +
 522              line.slice(0, this.column - 1).replace(/[^\t]/g, ' ')
 523  
 524            return (
 525              mark('>') +
 526              aside(gutter) +
 527              highlight(line) +
 528              '\n ' +
 529              spacing +
 530              mark('^')
 531            )
 532          }
 533  
 534          return ' ' + aside(gutter) + highlight(line)
 535        })
 536        .join('\n')
 537    }
 538  
 539    toString() {
 540      let code = this.showSourceCode()
 541      if (code) {
 542        code = '\n\n' + code + '\n'
 543      }
 544      return this.name + ': ' + this.message + code
 545    }
 546  }
 547  
 548  module.exports = CssSyntaxError
 549  CssSyntaxError.default = CssSyntaxError
 550  
 551  
 552  /***/ }),
 553  
 554  /***/ 448:
 555  /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 556  
 557  "use strict";
 558  
 559  
 560  let Container = __webpack_require__(683)
 561  let Document = __webpack_require__(271)
 562  let MapGenerator = __webpack_require__(1670)
 563  let parse = __webpack_require__(4295)
 564  let Result = __webpack_require__(9055)
 565  let Root = __webpack_require__(9434)
 566  let stringify = __webpack_require__(633)
 567  let { isClean, my } = __webpack_require__(1381)
 568  let warnOnce = __webpack_require__(3122)
 569  
 570  const TYPE_TO_CLASS_NAME = {
 571    atrule: 'AtRule',
 572    comment: 'Comment',
 573    decl: 'Declaration',
 574    document: 'Document',
 575    root: 'Root',
 576    rule: 'Rule'
 577  }
 578  
 579  const PLUGIN_PROPS = {
 580    AtRule: true,
 581    AtRuleExit: true,
 582    Comment: true,
 583    CommentExit: true,
 584    Declaration: true,
 585    DeclarationExit: true,
 586    Document: true,
 587    DocumentExit: true,
 588    Once: true,
 589    OnceExit: true,
 590    postcssPlugin: true,
 591    prepare: true,
 592    Root: true,
 593    RootExit: true,
 594    Rule: true,
 595    RuleExit: true
 596  }
 597  
 598  const NOT_VISITORS = {
 599    Once: true,
 600    postcssPlugin: true,
 601    prepare: true
 602  }
 603  
 604  const CHILDREN = 0
 605  
 606  function isPromise(obj) {
 607    return typeof obj === 'object' && typeof obj.then === 'function'
 608  }
 609  
 610  function getEvents(node) {
 611    let key = false
 612    let type = TYPE_TO_CLASS_NAME[node.type]
 613    if (node.type === 'decl') {
 614      key = node.prop.toLowerCase()
 615    } else if (node.type === 'atrule') {
 616      key = node.name.toLowerCase()
 617    }
 618  
 619    if (key && node.append) {
 620      return [
 621        type,
 622        type + '-' + key,
 623        CHILDREN,
 624        type + 'Exit',
 625        type + 'Exit-' + key
 626      ]
 627    } else if (key) {
 628      return [type, type + '-' + key, type + 'Exit', type + 'Exit-' + key]
 629    } else if (node.append) {
 630      return [type, CHILDREN, type + 'Exit']
 631    } else {
 632      return [type, type + 'Exit']
 633    }
 634  }
 635  
 636  function toStack(node) {
 637    let events
 638    if (node.type === 'document') {
 639      events = ['Document', CHILDREN, 'DocumentExit']
 640    } else if (node.type === 'root') {
 641      events = ['Root', CHILDREN, 'RootExit']
 642    } else {
 643      events = getEvents(node)
 644    }
 645  
 646    return {
 647      eventIndex: 0,
 648      events,
 649      iterator: 0,
 650      node,
 651      visitorIndex: 0,
 652      visitors: []
 653    }
 654  }
 655  
 656  function cleanMarks(node) {
 657    node[isClean] = false
 658    if (node.nodes) node.nodes.forEach(i => cleanMarks(i))
 659    return node
 660  }
 661  
 662  let postcss = {}
 663  
 664  class LazyResult {
 665    get content() {
 666      return this.stringify().content
 667    }
 668  
 669    get css() {
 670      return this.stringify().css
 671    }
 672  
 673    get map() {
 674      return this.stringify().map
 675    }
 676  
 677    get messages() {
 678      return this.sync().messages
 679    }
 680  
 681    get opts() {
 682      return this.result.opts
 683    }
 684  
 685    get processor() {
 686      return this.result.processor
 687    }
 688  
 689    get root() {
 690      return this.sync().root
 691    }
 692  
 693    get [Symbol.toStringTag]() {
 694      return 'LazyResult'
 695    }
 696  
 697    constructor(processor, css, opts) {
 698      this.stringified = false
 699      this.processed = false
 700  
 701      let root
 702      if (
 703        typeof css === 'object' &&
 704        css !== null &&
 705        (css.type === 'root' || css.type === 'document')
 706      ) {
 707        root = cleanMarks(css)
 708      } else if (css instanceof LazyResult || css instanceof Result) {
 709        root = cleanMarks(css.root)
 710        if (css.map) {
 711          if (typeof opts.map === 'undefined') opts.map = {}
 712          if (!opts.map.inline) opts.map.inline = false
 713          opts.map.prev = css.map
 714        }
 715      } else {
 716        let parser = parse
 717        if (opts.syntax) parser = opts.syntax.parse
 718        if (opts.parser) parser = opts.parser
 719        if (parser.parse) parser = parser.parse
 720  
 721        try {
 722          root = parser(css, opts)
 723        } catch (error) {
 724          this.processed = true
 725          this.error = error
 726        }
 727  
 728        if (root && !root[my]) {
 729          /* c8 ignore next 2 */
 730          Container.rebuild(root)
 731        }
 732      }
 733  
 734      this.result = new Result(processor, root, opts)
 735      this.helpers = { ...postcss, postcss, result: this.result }
 736      this.plugins = this.processor.plugins.map(plugin => {
 737        if (typeof plugin === 'object' && plugin.prepare) {
 738          return { ...plugin, ...plugin.prepare(this.result) }
 739        } else {
 740          return plugin
 741        }
 742      })
 743    }
 744  
 745    async() {
 746      if (this.error) return Promise.reject(this.error)
 747      if (this.processed) return Promise.resolve(this.result)
 748      if (!this.processing) {
 749        this.processing = this.runAsync()
 750      }
 751      return this.processing
 752    }
 753  
 754    catch(onRejected) {
 755      return this.async().catch(onRejected)
 756    }
 757  
 758    finally(onFinally) {
 759      return this.async().then(onFinally, onFinally)
 760    }
 761  
 762    getAsyncError() {
 763      throw new Error('Use process(css).then(cb) to work with async plugins')
 764    }
 765  
 766    handleError(error, node) {
 767      let plugin = this.result.lastPlugin
 768      try {
 769        if (node) node.addToError(error)
 770        this.error = error
 771        if (error.name === 'CssSyntaxError' && !error.plugin) {
 772          error.plugin = plugin.postcssPlugin
 773          error.setMessage()
 774        } else if (plugin.postcssVersion) {
 775          if (false) {}
 776        }
 777      } catch (err) {
 778        /* c8 ignore next 3 */
 779        // eslint-disable-next-line no-console
 780        if (console && console.error) console.error(err)
 781      }
 782      return error
 783    }
 784  
 785    prepareVisitors() {
 786      this.listeners = {}
 787      let add = (plugin, type, cb) => {
 788        if (!this.listeners[type]) this.listeners[type] = []
 789        this.listeners[type].push([plugin, cb])
 790      }
 791      for (let plugin of this.plugins) {
 792        if (typeof plugin === 'object') {
 793          for (let event in plugin) {
 794            if (!PLUGIN_PROPS[event] && /^[A-Z]/.test(event)) {
 795              throw new Error(
 796                `Unknown event $event} in $plugin.postcssPlugin}. ` +
 797                  `Try to update PostCSS ($this.processor.version} now).`
 798              )
 799            }
 800            if (!NOT_VISITORS[event]) {
 801              if (typeof plugin[event] === 'object') {
 802                for (let filter in plugin[event]) {
 803                  if (filter === '*') {
 804                    add(plugin, event, plugin[event][filter])
 805                  } else {
 806                    add(
 807                      plugin,
 808                      event + '-' + filter.toLowerCase(),
 809                      plugin[event][filter]
 810                    )
 811                  }
 812                }
 813              } else if (typeof plugin[event] === 'function') {
 814                add(plugin, event, plugin[event])
 815              }
 816            }
 817          }
 818        }
 819      }
 820      this.hasListener = Object.keys(this.listeners).length > 0
 821    }
 822  
 823    async runAsync() {
 824      this.plugin = 0
 825      for (let i = 0; i < this.plugins.length; i++) {
 826        let plugin = this.plugins[i]
 827        let promise = this.runOnRoot(plugin)
 828        if (isPromise(promise)) {
 829          try {
 830            await promise
 831          } catch (error) {
 832            throw this.handleError(error)
 833          }
 834        }
 835      }
 836  
 837      this.prepareVisitors()
 838      if (this.hasListener) {
 839        let root = this.result.root
 840        while (!root[isClean]) {
 841          root[isClean] = true
 842          let stack = [toStack(root)]
 843          while (stack.length > 0) {
 844            let promise = this.visitTick(stack)
 845            if (isPromise(promise)) {
 846              try {
 847                await promise
 848              } catch (e) {
 849                let node = stack[stack.length - 1].node
 850                throw this.handleError(e, node)
 851              }
 852            }
 853          }
 854        }
 855  
 856        if (this.listeners.OnceExit) {
 857          for (let [plugin, visitor] of this.listeners.OnceExit) {
 858            this.result.lastPlugin = plugin
 859            try {
 860              if (root.type === 'document') {
 861                let roots = root.nodes.map(subRoot =>
 862                  visitor(subRoot, this.helpers)
 863                )
 864  
 865                await Promise.all(roots)
 866              } else {
 867                await visitor(root, this.helpers)
 868              }
 869            } catch (e) {
 870              throw this.handleError(e)
 871            }
 872          }
 873        }
 874      }
 875  
 876      this.processed = true
 877      return this.stringify()
 878    }
 879  
 880    runOnRoot(plugin) {
 881      this.result.lastPlugin = plugin
 882      try {
 883        if (typeof plugin === 'object' && plugin.Once) {
 884          if (this.result.root.type === 'document') {
 885            let roots = this.result.root.nodes.map(root =>
 886              plugin.Once(root, this.helpers)
 887            )
 888  
 889            if (isPromise(roots[0])) {
 890              return Promise.all(roots)
 891            }
 892  
 893            return roots
 894          }
 895  
 896          return plugin.Once(this.result.root, this.helpers)
 897        } else if (typeof plugin === 'function') {
 898          return plugin(this.result.root, this.result)
 899        }
 900      } catch (error) {
 901        throw this.handleError(error)
 902      }
 903    }
 904  
 905    stringify() {
 906      if (this.error) throw this.error
 907      if (this.stringified) return this.result
 908      this.stringified = true
 909  
 910      this.sync()
 911  
 912      let opts = this.result.opts
 913      let str = stringify
 914      if (opts.syntax) str = opts.syntax.stringify
 915      if (opts.stringifier) str = opts.stringifier
 916      if (str.stringify) str = str.stringify
 917  
 918      let map = new MapGenerator(str, this.result.root, this.result.opts)
 919      let data = map.generate()
 920      this.result.css = data[0]
 921      this.result.map = data[1]
 922  
 923      return this.result
 924    }
 925  
 926    sync() {
 927      if (this.error) throw this.error
 928      if (this.processed) return this.result
 929      this.processed = true
 930  
 931      if (this.processing) {
 932        throw this.getAsyncError()
 933      }
 934  
 935      for (let plugin of this.plugins) {
 936        let promise = this.runOnRoot(plugin)
 937        if (isPromise(promise)) {
 938          throw this.getAsyncError()
 939        }
 940      }
 941  
 942      this.prepareVisitors()
 943      if (this.hasListener) {
 944        let root = this.result.root
 945        while (!root[isClean]) {
 946          root[isClean] = true
 947          this.walkSync(root)
 948        }
 949        if (this.listeners.OnceExit) {
 950          if (root.type === 'document') {
 951            for (let subRoot of root.nodes) {
 952              this.visitSync(this.listeners.OnceExit, subRoot)
 953            }
 954          } else {
 955            this.visitSync(this.listeners.OnceExit, root)
 956          }
 957        }
 958      }
 959  
 960      return this.result
 961    }
 962  
 963    then(onFulfilled, onRejected) {
 964      if (false) {}
 965      return this.async().then(onFulfilled, onRejected)
 966    }
 967  
 968    toString() {
 969      return this.css
 970    }
 971  
 972    visitSync(visitors, node) {
 973      for (let [plugin, visitor] of visitors) {
 974        this.result.lastPlugin = plugin
 975        let promise
 976        try {
 977          promise = visitor(node, this.helpers)
 978        } catch (e) {
 979          throw this.handleError(e, node.proxyOf)
 980        }
 981        if (node.type !== 'root' && node.type !== 'document' && !node.parent) {
 982          return true
 983        }
 984        if (isPromise(promise)) {
 985          throw this.getAsyncError()
 986        }
 987      }
 988    }
 989  
 990    visitTick(stack) {
 991      let visit = stack[stack.length - 1]
 992      let { node, visitors } = visit
 993  
 994      if (node.type !== 'root' && node.type !== 'document' && !node.parent) {
 995        stack.pop()
 996        return
 997      }
 998  
 999      if (visitors.length > 0 && visit.visitorIndex < visitors.length) {
1000        let [plugin, visitor] = visitors[visit.visitorIndex]
1001        visit.visitorIndex += 1
1002        if (visit.visitorIndex === visitors.length) {
1003          visit.visitors = []
1004          visit.visitorIndex = 0
1005        }
1006        this.result.lastPlugin = plugin
1007        try {
1008          return visitor(node.toProxy(), this.helpers)
1009        } catch (e) {
1010          throw this.handleError(e, node)
1011        }
1012      }
1013  
1014      if (visit.iterator !== 0) {
1015        let iterator = visit.iterator
1016        let child
1017        while ((child = node.nodes[node.indexes[iterator]])) {
1018          node.indexes[iterator] += 1
1019          if (!child[isClean]) {
1020            child[isClean] = true
1021            stack.push(toStack(child))
1022            return
1023          }
1024        }
1025        visit.iterator = 0
1026        delete node.indexes[iterator]
1027      }
1028  
1029      let events = visit.events
1030      while (visit.eventIndex < events.length) {
1031        let event = events[visit.eventIndex]
1032        visit.eventIndex += 1
1033        if (event === CHILDREN) {
1034          if (node.nodes && node.nodes.length) {
1035            node[isClean] = true
1036            visit.iterator = node.getIterator()
1037          }
1038          return
1039        } else if (this.listeners[event]) {
1040          visit.visitors = this.listeners[event]
1041          return
1042        }
1043      }
1044      stack.pop()
1045    }
1046  
1047    walkSync(node) {
1048      node[isClean] = true
1049      let events = getEvents(node)
1050      for (let event of events) {
1051        if (event === CHILDREN) {
1052          if (node.nodes) {
1053            node.each(child => {
1054              if (!child[isClean]) this.walkSync(child)
1055            })
1056          }
1057        } else {
1058          let visitors = this.listeners[event]
1059          if (visitors) {
1060            if (this.visitSync(visitors, node.toProxy())) return
1061          }
1062        }
1063      }
1064    }
1065  
1066    warnings() {
1067      return this.sync().warnings()
1068    }
1069  }
1070  
1071  LazyResult.registerPostcss = dependant => {
1072    postcss = dependant
1073  }
1074  
1075  module.exports = LazyResult
1076  LazyResult.default = LazyResult
1077  
1078  Root.registerLazyResult(LazyResult)
1079  Document.registerLazyResult(LazyResult)
1080  
1081  
1082  /***/ }),
1083  
1084  /***/ 461:
1085  /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
1086  
1087  // Load in dependencies
1088  var computedStyle = __webpack_require__(6109);
1089  
1090  /**
1091   * Calculate the `line-height` of a given node
1092   * @param {HTMLElement} node Element to calculate line height of. Must be in the DOM.
1093   * @returns {Number} `line-height` of the element in pixels
1094   */
1095  function lineHeight(node) {
1096    // Grab the line-height via style
1097    var lnHeightStr = computedStyle(node, 'line-height');
1098    var lnHeight = parseFloat(lnHeightStr, 10);
1099  
1100    // If the lineHeight did not contain a unit (i.e. it was numeric), convert it to ems (e.g. '2.3' === '2.3em')
1101    if (lnHeightStr === lnHeight + '') {
1102      // Save the old lineHeight style and update the em unit to the element
1103      var _lnHeightStyle = node.style.lineHeight;
1104      node.style.lineHeight = lnHeightStr + 'em';
1105  
1106      // Calculate the em based height
1107      lnHeightStr = computedStyle(node, 'line-height');
1108      lnHeight = parseFloat(lnHeightStr, 10);
1109  
1110      // Revert the lineHeight style
1111      if (_lnHeightStyle) {
1112        node.style.lineHeight = _lnHeightStyle;
1113      } else {
1114        delete node.style.lineHeight;
1115      }
1116    }
1117  
1118    // If the lineHeight is in `pt`, convert it to pixels (4px for 3pt)
1119    // DEV: `em` units are converted to `pt` in IE6
1120    // Conversion ratio from https://developer.mozilla.org/en-US/docs/Web/CSS/length
1121    if (lnHeightStr.indexOf('pt') !== -1) {
1122      lnHeight *= 4;
1123      lnHeight /= 3;
1124    // Otherwise, if the lineHeight is in `mm`, convert it to pixels (96px for 25.4mm)
1125    } else if (lnHeightStr.indexOf('mm') !== -1) {
1126      lnHeight *= 96;
1127      lnHeight /= 25.4;
1128    // Otherwise, if the lineHeight is in `cm`, convert it to pixels (96px for 2.54cm)
1129    } else if (lnHeightStr.indexOf('cm') !== -1) {
1130      lnHeight *= 96;
1131      lnHeight /= 2.54;
1132    // Otherwise, if the lineHeight is in `in`, convert it to pixels (96px for 1in)
1133    } else if (lnHeightStr.indexOf('in') !== -1) {
1134      lnHeight *= 96;
1135    // Otherwise, if the lineHeight is in `pc`, convert it to pixels (12pt for 1pc)
1136    } else if (lnHeightStr.indexOf('pc') !== -1) {
1137      lnHeight *= 16;
1138    }
1139  
1140    // Continue our computation
1141    lnHeight = Math.round(lnHeight);
1142  
1143    // If the line-height is "normal", calculate by font-size
1144    if (lnHeightStr === 'normal') {
1145      // Create a temporary node
1146      var nodeName = node.nodeName;
1147      var _node = document.createElement(nodeName);
1148      _node.innerHTML = '&nbsp;';
1149  
1150      // If we have a text area, reset it to only 1 row
1151      // https://github.com/twolfson/line-height/issues/4
1152      if (nodeName.toUpperCase() === 'TEXTAREA') {
1153        _node.setAttribute('rows', '1');
1154      }
1155  
1156      // Set the font-size of the element
1157      var fontSizeStr = computedStyle(node, 'font-size');
1158      _node.style.fontSize = fontSizeStr;
1159  
1160      // Remove default padding/border which can affect offset height
1161      // https://github.com/twolfson/line-height/issues/4
1162      // https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/offsetHeight
1163      _node.style.padding = '0px';
1164      _node.style.border = '0px';
1165  
1166      // Append it to the body
1167      var body = document.body;
1168      body.appendChild(_node);
1169  
1170      // Assume the line height of the element is the height
1171      var height = _node.offsetHeight;
1172      lnHeight = height;
1173  
1174      // Remove our child from the DOM
1175      body.removeChild(_node);
1176    }
1177  
1178    // Return the calculated height
1179    return lnHeight;
1180  }
1181  
1182  // Export lineHeight
1183  module.exports = lineHeight;
1184  
1185  
1186  /***/ }),
1187  
1188  /***/ 628:
1189  /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
1190  
1191  "use strict";
1192  /**
1193   * Copyright (c) 2013-present, Facebook, Inc.
1194   *
1195   * This source code is licensed under the MIT license found in the
1196   * LICENSE file in the root directory of this source tree.
1197   */
1198  
1199  
1200  
1201  var ReactPropTypesSecret = __webpack_require__(4067);
1202  
1203  function emptyFunction() {}
1204  function emptyFunctionWithReset() {}
1205  emptyFunctionWithReset.resetWarningCache = emptyFunction;
1206  
1207  module.exports = function() {
1208    function shim(props, propName, componentName, location, propFullName, secret) {
1209      if (secret === ReactPropTypesSecret) {
1210        // It is still safe when called from React.
1211        return;
1212      }
1213      var err = new Error(
1214        'Calling PropTypes validators directly is not supported by the `prop-types` package. ' +
1215        'Use PropTypes.checkPropTypes() to call them. ' +
1216        'Read more at http://fb.me/use-check-prop-types'
1217      );
1218      err.name = 'Invariant Violation';
1219      throw err;
1220    };
1221    shim.isRequired = shim;
1222    function getShim() {
1223      return shim;
1224    };
1225    // Important!
1226    // Keep this list in sync with production version in `./factoryWithTypeCheckers.js`.
1227    var ReactPropTypes = {
1228      array: shim,
1229      bigint: shim,
1230      bool: shim,
1231      func: shim,
1232      number: shim,
1233      object: shim,
1234      string: shim,
1235      symbol: shim,
1236  
1237      any: shim,
1238      arrayOf: getShim,
1239      element: shim,
1240      elementType: shim,
1241      instanceOf: getShim,
1242      node: shim,
1243      objectOf: getShim,
1244      oneOf: getShim,
1245      oneOfType: getShim,
1246      shape: getShim,
1247      exact: getShim,
1248  
1249      checkPropTypes: emptyFunctionWithReset,
1250      resetWarningCache: emptyFunction
1251    };
1252  
1253    ReactPropTypes.PropTypes = ReactPropTypes;
1254  
1255    return ReactPropTypes;
1256  };
1257  
1258  
1259  /***/ }),
1260  
1261  /***/ 633:
1262  /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
1263  
1264  "use strict";
1265  
1266  
1267  let Stringifier = __webpack_require__(346)
1268  
1269  function stringify(node, builder) {
1270    let str = new Stringifier(builder)
1271    str.stringify(node)
1272  }
1273  
1274  module.exports = stringify
1275  stringify.default = stringify
1276  
1277  
1278  /***/ }),
1279  
1280  /***/ 683:
1281  /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
1282  
1283  "use strict";
1284  
1285  
1286  let Comment = __webpack_require__(6589)
1287  let Declaration = __webpack_require__(1516)
1288  let Node = __webpack_require__(7490)
1289  let { isClean, my } = __webpack_require__(1381)
1290  
1291  let AtRule, parse, Root, Rule
1292  
1293  function cleanSource(nodes) {
1294    return nodes.map(i => {
1295      if (i.nodes) i.nodes = cleanSource(i.nodes)
1296      delete i.source
1297      return i
1298    })
1299  }
1300  
1301  function markTreeDirty(node) {
1302    node[isClean] = false
1303    if (node.proxyOf.nodes) {
1304      for (let i of node.proxyOf.nodes) {
1305        markTreeDirty(i)
1306      }
1307    }
1308  }
1309  
1310  class Container extends Node {
1311    get first() {
1312      if (!this.proxyOf.nodes) return undefined
1313      return this.proxyOf.nodes[0]
1314    }
1315  
1316    get last() {
1317      if (!this.proxyOf.nodes) return undefined
1318      return this.proxyOf.nodes[this.proxyOf.nodes.length - 1]
1319    }
1320  
1321    append(...children) {
1322      for (let child of children) {
1323        let nodes = this.normalize(child, this.last)
1324        for (let node of nodes) this.proxyOf.nodes.push(node)
1325      }
1326  
1327      this.markDirty()
1328  
1329      return this
1330    }
1331  
1332    cleanRaws(keepBetween) {
1333      super.cleanRaws(keepBetween)
1334      if (this.nodes) {
1335        for (let node of this.nodes) node.cleanRaws(keepBetween)
1336      }
1337    }
1338  
1339    each(callback) {
1340      if (!this.proxyOf.nodes) return undefined
1341      let iterator = this.getIterator()
1342  
1343      let index, result
1344      while (this.indexes[iterator] < this.proxyOf.nodes.length) {
1345        index = this.indexes[iterator]
1346        result = callback(this.proxyOf.nodes[index], index)
1347        if (result === false) break
1348  
1349        this.indexes[iterator] += 1
1350      }
1351  
1352      delete this.indexes[iterator]
1353      return result
1354    }
1355  
1356    every(condition) {
1357      return this.nodes.every(condition)
1358    }
1359  
1360    getIterator() {
1361      if (!this.lastEach) this.lastEach = 0
1362      if (!this.indexes) this.indexes = {}
1363  
1364      this.lastEach += 1
1365      let iterator = this.lastEach
1366      this.indexes[iterator] = 0
1367  
1368      return iterator
1369    }
1370  
1371    getProxyProcessor() {
1372      return {
1373        get(node, prop) {
1374          if (prop === 'proxyOf') {
1375            return node
1376          } else if (!node[prop]) {
1377            return node[prop]
1378          } else if (
1379            prop === 'each' ||
1380            (typeof prop === 'string' && prop.startsWith('walk'))
1381          ) {
1382            return (...args) => {
1383              return node[prop](
1384                ...args.map(i => {
1385                  if (typeof i === 'function') {
1386                    return (child, index) => i(child.toProxy(), index)
1387                  } else {
1388                    return i
1389                  }
1390                })
1391              )
1392            }
1393          } else if (prop === 'every' || prop === 'some') {
1394            return cb => {
1395              return node[prop]((child, ...other) =>
1396                cb(child.toProxy(), ...other)
1397              )
1398            }
1399          } else if (prop === 'root') {
1400            return () => node.root().toProxy()
1401          } else if (prop === 'nodes') {
1402            return node.nodes.map(i => i.toProxy())
1403          } else if (prop === 'first' || prop === 'last') {
1404            return node[prop].toProxy()
1405          } else {
1406            return node[prop]
1407          }
1408        },
1409  
1410        set(node, prop, value) {
1411          if (node[prop] === value) return true
1412          node[prop] = value
1413          if (prop === 'name' || prop === 'params' || prop === 'selector') {
1414            node.markDirty()
1415          }
1416          return true
1417        }
1418      }
1419    }
1420  
1421    index(child) {
1422      if (typeof child === 'number') return child
1423      if (child.proxyOf) child = child.proxyOf
1424      return this.proxyOf.nodes.indexOf(child)
1425    }
1426  
1427    insertAfter(exist, add) {
1428      let existIndex = this.index(exist)
1429      let nodes = this.normalize(add, this.proxyOf.nodes[existIndex]).reverse()
1430      existIndex = this.index(exist)
1431      for (let node of nodes) this.proxyOf.nodes.splice(existIndex + 1, 0, node)
1432  
1433      let index
1434      for (let id in this.indexes) {
1435        index = this.indexes[id]
1436        if (existIndex < index) {
1437          this.indexes[id] = index + nodes.length
1438        }
1439      }
1440  
1441      this.markDirty()
1442  
1443      return this
1444    }
1445  
1446    insertBefore(exist, add) {
1447      let existIndex = this.index(exist)
1448      let type = existIndex === 0 ? 'prepend' : false
1449      let nodes = this.normalize(
1450        add,
1451        this.proxyOf.nodes[existIndex],
1452        type
1453      ).reverse()
1454      existIndex = this.index(exist)
1455      for (let node of nodes) this.proxyOf.nodes.splice(existIndex, 0, node)
1456  
1457      let index
1458      for (let id in this.indexes) {
1459        index = this.indexes[id]
1460        if (existIndex <= index) {
1461          this.indexes[id] = index + nodes.length
1462        }
1463      }
1464  
1465      this.markDirty()
1466  
1467      return this
1468    }
1469  
1470    normalize(nodes, sample) {
1471      if (typeof nodes === 'string') {
1472        nodes = cleanSource(parse(nodes).nodes)
1473      } else if (typeof nodes === 'undefined') {
1474        nodes = []
1475      } else if (Array.isArray(nodes)) {
1476        nodes = nodes.slice(0)
1477        for (let i of nodes) {
1478          if (i.parent) i.parent.removeChild(i, 'ignore')
1479        }
1480      } else if (nodes.type === 'root' && this.type !== 'document') {
1481        nodes = nodes.nodes.slice(0)
1482        for (let i of nodes) {
1483          if (i.parent) i.parent.removeChild(i, 'ignore')
1484        }
1485      } else if (nodes.type) {
1486        nodes = [nodes]
1487      } else if (nodes.prop) {
1488        if (typeof nodes.value === 'undefined') {
1489          throw new Error('Value field is missed in node creation')
1490        } else if (typeof nodes.value !== 'string') {
1491          nodes.value = String(nodes.value)
1492        }
1493        nodes = [new Declaration(nodes)]
1494      } else if (nodes.selector || nodes.selectors) {
1495        nodes = [new Rule(nodes)]
1496      } else if (nodes.name) {
1497        nodes = [new AtRule(nodes)]
1498      } else if (nodes.text) {
1499        nodes = [new Comment(nodes)]
1500      } else {
1501        throw new Error('Unknown node type in node creation')
1502      }
1503  
1504      let processed = nodes.map(i => {
1505        /* c8 ignore next */
1506        if (!i[my]) Container.rebuild(i)
1507        i = i.proxyOf
1508        if (i.parent) i.parent.removeChild(i)
1509        if (i[isClean]) markTreeDirty(i)
1510  
1511        if (!i.raws) i.raws = {}
1512        if (typeof i.raws.before === 'undefined') {
1513          if (sample && typeof sample.raws.before !== 'undefined') {
1514            i.raws.before = sample.raws.before.replace(/\S/g, '')
1515          }
1516        }
1517        i.parent = this.proxyOf
1518        return i
1519      })
1520  
1521      return processed
1522    }
1523  
1524    prepend(...children) {
1525      children = children.reverse()
1526      for (let child of children) {
1527        let nodes = this.normalize(child, this.first, 'prepend').reverse()
1528        for (let node of nodes) this.proxyOf.nodes.unshift(node)
1529        for (let id in this.indexes) {
1530          this.indexes[id] = this.indexes[id] + nodes.length
1531        }
1532      }
1533  
1534      this.markDirty()
1535  
1536      return this
1537    }
1538  
1539    push(child) {
1540      child.parent = this
1541      this.proxyOf.nodes.push(child)
1542      return this
1543    }
1544  
1545    removeAll() {
1546      for (let node of this.proxyOf.nodes) node.parent = undefined
1547      this.proxyOf.nodes = []
1548  
1549      this.markDirty()
1550  
1551      return this
1552    }
1553  
1554    removeChild(child) {
1555      child = this.index(child)
1556      this.proxyOf.nodes[child].parent = undefined
1557      this.proxyOf.nodes.splice(child, 1)
1558  
1559      let index
1560      for (let id in this.indexes) {
1561        index = this.indexes[id]
1562        if (index >= child) {
1563          this.indexes[id] = index - 1
1564        }
1565      }
1566  
1567      this.markDirty()
1568  
1569      return this
1570    }
1571  
1572    replaceValues(pattern, opts, callback) {
1573      if (!callback) {
1574        callback = opts
1575        opts = {}
1576      }
1577  
1578      this.walkDecls(decl => {
1579        if (opts.props && !opts.props.includes(decl.prop)) return
1580        if (opts.fast && !decl.value.includes(opts.fast)) return
1581  
1582        decl.value = decl.value.replace(pattern, callback)
1583      })
1584  
1585      this.markDirty()
1586  
1587      return this
1588    }
1589  
1590    some(condition) {
1591      return this.nodes.some(condition)
1592    }
1593  
1594    walk(callback) {
1595      return this.each((child, i) => {
1596        let result
1597        try {
1598          result = callback(child, i)
1599        } catch (e) {
1600          throw child.addToError(e)
1601        }
1602        if (result !== false && child.walk) {
1603          result = child.walk(callback)
1604        }
1605  
1606        return result
1607      })
1608    }
1609  
1610    walkAtRules(name, callback) {
1611      if (!callback) {
1612        callback = name
1613        return this.walk((child, i) => {
1614          if (child.type === 'atrule') {
1615            return callback(child, i)
1616          }
1617        })
1618      }
1619      if (name instanceof RegExp) {
1620        return this.walk((child, i) => {
1621          if (child.type === 'atrule' && name.test(child.name)) {
1622            return callback(child, i)
1623          }
1624        })
1625      }
1626      return this.walk((child, i) => {
1627        if (child.type === 'atrule' && child.name === name) {
1628          return callback(child, i)
1629        }
1630      })
1631    }
1632  
1633    walkComments(callback) {
1634      return this.walk((child, i) => {
1635        if (child.type === 'comment') {
1636          return callback(child, i)
1637        }
1638      })
1639    }
1640  
1641    walkDecls(prop, callback) {
1642      if (!callback) {
1643        callback = prop
1644        return this.walk((child, i) => {
1645          if (child.type === 'decl') {
1646            return callback(child, i)
1647          }
1648        })
1649      }
1650      if (prop instanceof RegExp) {
1651        return this.walk((child, i) => {
1652          if (child.type === 'decl' && prop.test(child.prop)) {
1653            return callback(child, i)
1654          }
1655        })
1656      }
1657      return this.walk((child, i) => {
1658        if (child.type === 'decl' && child.prop === prop) {
1659          return callback(child, i)
1660        }
1661      })
1662    }
1663  
1664    walkRules(selector, callback) {
1665      if (!callback) {
1666        callback = selector
1667  
1668        return this.walk((child, i) => {
1669          if (child.type === 'rule') {
1670            return callback(child, i)
1671          }
1672        })
1673      }
1674      if (selector instanceof RegExp) {
1675        return this.walk((child, i) => {
1676          if (child.type === 'rule' && selector.test(child.selector)) {
1677            return callback(child, i)
1678          }
1679        })
1680      }
1681      return this.walk((child, i) => {
1682        if (child.type === 'rule' && child.selector === selector) {
1683          return callback(child, i)
1684        }
1685      })
1686    }
1687  }
1688  
1689  Container.registerParse = dependant => {
1690    parse = dependant
1691  }
1692  
1693  Container.registerRule = dependant => {
1694    Rule = dependant
1695  }
1696  
1697  Container.registerAtRule = dependant => {
1698    AtRule = dependant
1699  }
1700  
1701  Container.registerRoot = dependant => {
1702    Root = dependant
1703  }
1704  
1705  module.exports = Container
1706  Container.default = Container
1707  
1708  /* c8 ignore start */
1709  Container.rebuild = node => {
1710    if (node.type === 'atrule') {
1711      Object.setPrototypeOf(node, AtRule.prototype)
1712    } else if (node.type === 'rule') {
1713      Object.setPrototypeOf(node, Rule.prototype)
1714    } else if (node.type === 'decl') {
1715      Object.setPrototypeOf(node, Declaration.prototype)
1716    } else if (node.type === 'comment') {
1717      Object.setPrototypeOf(node, Comment.prototype)
1718    } else if (node.type === 'root') {
1719      Object.setPrototypeOf(node, Root.prototype)
1720    }
1721  
1722    node[my] = true
1723  
1724    if (node.nodes) {
1725      node.nodes.forEach(child => {
1726        Container.rebuild(child)
1727      })
1728    }
1729  }
1730  /* c8 ignore stop */
1731  
1732  
1733  /***/ }),
1734  
1735  /***/ 1087:
1736  /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
1737  
1738  "use strict";
1739  /**
1740   * Copyright 2013-2015, Facebook, Inc.
1741   * All rights reserved.
1742   *
1743   * This source code is licensed under the BSD-style license found in the
1744   * LICENSE file in the root directory of this source tree. An additional grant
1745   * of patent rights can be found in the PATENTS file in the same directory.
1746   *
1747   * @providesModule isEventSupported
1748   */
1749  
1750  
1751  
1752  var ExecutionEnvironment = __webpack_require__(8202);
1753  
1754  var useHasFeature;
1755  if (ExecutionEnvironment.canUseDOM) {
1756    useHasFeature =
1757      document.implementation &&
1758      document.implementation.hasFeature &&
1759      // always returns true in newer browsers as per the standard.
1760      // @see http://dom.spec.whatwg.org/#dom-domimplementation-hasfeature
1761      document.implementation.hasFeature('', '') !== true;
1762  }
1763  
1764  /**
1765   * Checks if an event is supported in the current execution environment.
1766   *
1767   * NOTE: This will not work correctly for non-generic events such as `change`,
1768   * `reset`, `load`, `error`, and `select`.
1769   *
1770   * Borrows from Modernizr.
1771   *
1772   * @param {string} eventNameSuffix Event name, e.g. "click".
1773   * @param {?boolean} capture Check if the capture phase is supported.
1774   * @return {boolean} True if the event is supported.
1775   * @internal
1776   * @license Modernizr 3.0.0pre (Custom Build) | MIT
1777   */
1778  function isEventSupported(eventNameSuffix, capture) {
1779    if (!ExecutionEnvironment.canUseDOM ||
1780        capture && !('addEventListener' in document)) {
1781      return false;
1782    }
1783  
1784    var eventName = 'on' + eventNameSuffix;
1785    var isSupported = eventName in document;
1786  
1787    if (!isSupported) {
1788      var element = document.createElement('div');
1789      element.setAttribute(eventName, 'return;');
1790      isSupported = typeof element[eventName] === 'function';
1791    }
1792  
1793    if (!isSupported && useHasFeature && eventNameSuffix === 'wheel') {
1794      // This is the only way to test support for the `wheel` event in IE9+.
1795      isSupported = document.implementation.hasFeature('Events.wheel', '3.0');
1796    }
1797  
1798    return isSupported;
1799  }
1800  
1801  module.exports = isEventSupported;
1802  
1803  
1804  /***/ }),
1805  
1806  /***/ 1326:
1807  /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
1808  
1809  "use strict";
1810  
1811  
1812  let Container = __webpack_require__(683)
1813  
1814  class AtRule extends Container {
1815    constructor(defaults) {
1816      super(defaults)
1817      this.type = 'atrule'
1818    }
1819  
1820    append(...children) {
1821      if (!this.proxyOf.nodes) this.nodes = []
1822      return super.append(...children)
1823    }
1824  
1825    prepend(...children) {
1826      if (!this.proxyOf.nodes) this.nodes = []
1827      return super.prepend(...children)
1828    }
1829  }
1830  
1831  module.exports = AtRule
1832  AtRule.default = AtRule
1833  
1834  Container.registerAtRule(AtRule)
1835  
1836  
1837  /***/ }),
1838  
1839  /***/ 1381:
1840  /***/ ((module) => {
1841  
1842  "use strict";
1843  
1844  
1845  module.exports.isClean = Symbol('isClean')
1846  
1847  module.exports.my = Symbol('my')
1848  
1849  
1850  /***/ }),
1851  
1852  /***/ 1443:
1853  /***/ ((module) => {
1854  
1855  module.exports = function postcssPrefixSelector(options) {
1856    const prefix = options.prefix;
1857    const prefixWithSpace = /\s+$/.test(prefix) ? prefix : `$prefix} `;
1858    const ignoreFiles = options.ignoreFiles ? [].concat(options.ignoreFiles) : [];
1859    const includeFiles = options.includeFiles
1860      ? [].concat(options.includeFiles)
1861      : [];
1862  
1863    return function (root) {
1864      if (
1865        ignoreFiles.length &&
1866        root.source.input.file &&
1867        isFileInArray(root.source.input.file, ignoreFiles)
1868      ) {
1869        return;
1870      }
1871      if (
1872        includeFiles.length &&
1873        root.source.input.file &&
1874        !isFileInArray(root.source.input.file, includeFiles)
1875      ) {
1876        return;
1877      }
1878  
1879      root.walkRules((rule) => {
1880        const keyframeRules = [
1881          'keyframes',
1882          '-webkit-keyframes',
1883          '-moz-keyframes',
1884          '-o-keyframes',
1885          '-ms-keyframes',
1886        ];
1887  
1888        if (rule.parent && keyframeRules.includes(rule.parent.name)) {
1889          return;
1890        }
1891  
1892        rule.selectors = rule.selectors.map((selector) => {
1893          if (options.exclude && excludeSelector(selector, options.exclude)) {
1894            return selector;
1895          }
1896  
1897          if (options.transform) {
1898            return options.transform(
1899              prefix,
1900              selector,
1901              prefixWithSpace + selector,
1902              root.source.input.file,
1903              rule
1904            );
1905          }
1906  
1907          return prefixWithSpace + selector;
1908        });
1909      });
1910    };
1911  };
1912  
1913  function isFileInArray(file, arr) {
1914    return arr.some((ruleOrString) => {
1915      if (ruleOrString instanceof RegExp) {
1916        return ruleOrString.test(file);
1917      }
1918  
1919      return file.includes(ruleOrString);
1920    });
1921  }
1922  
1923  function excludeSelector(selector, excludeArr) {
1924    return excludeArr.some((excludeRule) => {
1925      if (excludeRule instanceof RegExp) {
1926        return excludeRule.test(selector);
1927      }
1928  
1929      return selector === excludeRule;
1930    });
1931  }
1932  
1933  
1934  /***/ }),
1935  
1936  /***/ 1516:
1937  /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
1938  
1939  "use strict";
1940  
1941  
1942  let Node = __webpack_require__(7490)
1943  
1944  class Declaration extends Node {
1945    get variable() {
1946      return this.prop.startsWith('--') || this.prop[0] === '$'
1947    }
1948  
1949    constructor(defaults) {
1950      if (
1951        defaults &&
1952        typeof defaults.value !== 'undefined' &&
1953        typeof defaults.value !== 'string'
1954      ) {
1955        defaults = { ...defaults, value: String(defaults.value) }
1956      }
1957      super(defaults)
1958      this.type = 'decl'
1959    }
1960  }
1961  
1962  module.exports = Declaration
1963  Declaration.default = Declaration
1964  
1965  
1966  /***/ }),
1967  
1968  /***/ 1524:
1969  /***/ ((module) => {
1970  
1971  var minus = "-".charCodeAt(0);
1972  var plus = "+".charCodeAt(0);
1973  var dot = ".".charCodeAt(0);
1974  var exp = "e".charCodeAt(0);
1975  var EXP = "E".charCodeAt(0);
1976  
1977  // Check if three code points would start a number
1978  // https://www.w3.org/TR/css-syntax-3/#starts-with-a-number
1979  function likeNumber(value) {
1980    var code = value.charCodeAt(0);
1981    var nextCode;
1982  
1983    if (code === plus || code === minus) {
1984      nextCode = value.charCodeAt(1);
1985  
1986      if (nextCode >= 48 && nextCode <= 57) {
1987        return true;
1988      }
1989  
1990      var nextNextCode = value.charCodeAt(2);
1991  
1992      if (nextCode === dot && nextNextCode >= 48 && nextNextCode <= 57) {
1993        return true;
1994      }
1995  
1996      return false;
1997    }
1998  
1999    if (code === dot) {
2000      nextCode = value.charCodeAt(1);
2001  
2002      if (nextCode >= 48 && nextCode <= 57) {
2003        return true;
2004      }
2005  
2006      return false;
2007    }
2008  
2009    if (code >= 48 && code <= 57) {
2010      return true;
2011    }
2012  
2013    return false;
2014  }
2015  
2016  // Consume a number
2017  // https://www.w3.org/TR/css-syntax-3/#consume-number
2018  module.exports = function(value) {
2019    var pos = 0;
2020    var length = value.length;
2021    var code;
2022    var nextCode;
2023    var nextNextCode;
2024  
2025    if (length === 0 || !likeNumber(value)) {
2026      return false;
2027    }
2028  
2029    code = value.charCodeAt(pos);
2030  
2031    if (code === plus || code === minus) {
2032      pos++;
2033    }
2034  
2035    while (pos < length) {
2036      code = value.charCodeAt(pos);
2037  
2038      if (code < 48 || code > 57) {
2039        break;
2040      }
2041  
2042      pos += 1;
2043    }
2044  
2045    code = value.charCodeAt(pos);
2046    nextCode = value.charCodeAt(pos + 1);
2047  
2048    if (code === dot && nextCode >= 48 && nextCode <= 57) {
2049      pos += 2;
2050  
2051      while (pos < length) {
2052        code = value.charCodeAt(pos);
2053  
2054        if (code < 48 || code > 57) {
2055          break;
2056        }
2057  
2058        pos += 1;
2059      }
2060    }
2061  
2062    code = value.charCodeAt(pos);
2063    nextCode = value.charCodeAt(pos + 1);
2064    nextNextCode = value.charCodeAt(pos + 2);
2065  
2066    if (
2067      (code === exp || code === EXP) &&
2068      ((nextCode >= 48 && nextCode <= 57) ||
2069        ((nextCode === plus || nextCode === minus) &&
2070          nextNextCode >= 48 &&
2071          nextNextCode <= 57))
2072    ) {
2073      pos += nextCode === plus || nextCode === minus ? 3 : 2;
2074  
2075      while (pos < length) {
2076        code = value.charCodeAt(pos);
2077  
2078        if (code < 48 || code > 57) {
2079          break;
2080        }
2081  
2082        pos += 1;
2083      }
2084    }
2085  
2086    return {
2087      number: value.slice(0, pos),
2088      unit: value.slice(pos)
2089    };
2090  };
2091  
2092  
2093  /***/ }),
2094  
2095  /***/ 1544:
2096  /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
2097  
2098  var parse = __webpack_require__(8491);
2099  var walk = __webpack_require__(3815);
2100  var stringify = __webpack_require__(4725);
2101  
2102  function ValueParser(value) {
2103    if (this instanceof ValueParser) {
2104      this.nodes = parse(value);
2105      return this;
2106    }
2107    return new ValueParser(value);
2108  }
2109  
2110  ValueParser.prototype.toString = function() {
2111    return Array.isArray(this.nodes) ? stringify(this.nodes) : "";
2112  };
2113  
2114  ValueParser.prototype.walk = function(cb, bubble) {
2115    walk(this.nodes, cb, bubble);
2116    return this;
2117  };
2118  
2119  ValueParser.unit = __webpack_require__(1524);
2120  
2121  ValueParser.walk = walk;
2122  
2123  ValueParser.stringify = stringify;
2124  
2125  module.exports = ValueParser;
2126  
2127  
2128  /***/ }),
2129  
2130  /***/ 1609:
2131  /***/ ((module) => {
2132  
2133  "use strict";
2134  module.exports = window["React"];
2135  
2136  /***/ }),
2137  
2138  /***/ 1670:
2139  /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
2140  
2141  "use strict";
2142  
2143  
2144  let { dirname, relative, resolve, sep } = __webpack_require__(197)
2145  let { SourceMapConsumer, SourceMapGenerator } = __webpack_require__(1866)
2146  let { pathToFileURL } = __webpack_require__(2739)
2147  
2148  let Input = __webpack_require__(5380)
2149  
2150  let sourceMapAvailable = Boolean(SourceMapConsumer && SourceMapGenerator)
2151  let pathAvailable = Boolean(dirname && resolve && relative && sep)
2152  
2153  class MapGenerator {
2154    constructor(stringify, root, opts, cssString) {
2155      this.stringify = stringify
2156      this.mapOpts = opts.map || {}
2157      this.root = root
2158      this.opts = opts
2159      this.css = cssString
2160      this.originalCSS = cssString
2161      this.usesFileUrls = !this.mapOpts.from && this.mapOpts.absolute
2162  
2163      this.memoizedFileURLs = new Map()
2164      this.memoizedPaths = new Map()
2165      this.memoizedURLs = new Map()
2166    }
2167  
2168    addAnnotation() {
2169      let content
2170  
2171      if (this.isInline()) {
2172        content =
2173          'data:application/json;base64,' + this.toBase64(this.map.toString())
2174      } else if (typeof this.mapOpts.annotation === 'string') {
2175        content = this.mapOpts.annotation
2176      } else if (typeof this.mapOpts.annotation === 'function') {
2177        content = this.mapOpts.annotation(this.opts.to, this.root)
2178      } else {
2179        content = this.outputFile() + '.map'
2180      }
2181      let eol = '\n'
2182      if (this.css.includes('\r\n')) eol = '\r\n'
2183  
2184      this.css += eol + '/*# sourceMappingURL=' + content + ' */'
2185    }
2186  
2187    applyPrevMaps() {
2188      for (let prev of this.previous()) {
2189        let from = this.toUrl(this.path(prev.file))
2190        let root = prev.root || dirname(prev.file)
2191        let map
2192  
2193        if (this.mapOpts.sourcesContent === false) {
2194          map = new SourceMapConsumer(prev.text)
2195          if (map.sourcesContent) {
2196            map.sourcesContent = null
2197          }
2198        } else {
2199          map = prev.consumer()
2200        }
2201  
2202        this.map.applySourceMap(map, from, this.toUrl(this.path(root)))
2203      }
2204    }
2205  
2206    clearAnnotation() {
2207      if (this.mapOpts.annotation === false) return
2208  
2209      if (this.root) {
2210        let node
2211        for (let i = this.root.nodes.length - 1; i >= 0; i--) {
2212          node = this.root.nodes[i]
2213          if (node.type !== 'comment') continue
2214          if (node.text.startsWith('# sourceMappingURL=')) {
2215            this.root.removeChild(i)
2216          }
2217        }
2218      } else if (this.css) {
2219        this.css = this.css.replace(/\n*\/\*#[\S\s]*?\*\/$/gm, '')
2220      }
2221    }
2222  
2223    generate() {
2224      this.clearAnnotation()
2225      if (pathAvailable && sourceMapAvailable && this.isMap()) {
2226        return this.generateMap()
2227      } else {
2228        let result = ''
2229        this.stringify(this.root, i => {
2230          result += i
2231        })
2232        return [result]
2233      }
2234    }
2235  
2236    generateMap() {
2237      if (this.root) {
2238        this.generateString()
2239      } else if (this.previous().length === 1) {
2240        let prev = this.previous()[0].consumer()
2241        prev.file = this.outputFile()
2242        this.map = SourceMapGenerator.fromSourceMap(prev, {
2243          ignoreInvalidMapping: true
2244        })
2245      } else {
2246        this.map = new SourceMapGenerator({
2247          file: this.outputFile(),
2248          ignoreInvalidMapping: true
2249        })
2250        this.map.addMapping({
2251          generated: { column: 0, line: 1 },
2252          original: { column: 0, line: 1 },
2253          source: this.opts.from
2254            ? this.toUrl(this.path(this.opts.from))
2255            : '<no source>'
2256        })
2257      }
2258  
2259      if (this.isSourcesContent()) this.setSourcesContent()
2260      if (this.root && this.previous().length > 0) this.applyPrevMaps()
2261      if (this.isAnnotation()) this.addAnnotation()
2262  
2263      if (this.isInline()) {
2264        return [this.css]
2265      } else {
2266        return [this.css, this.map]
2267      }
2268    }
2269  
2270    generateString() {
2271      this.css = ''
2272      this.map = new SourceMapGenerator({
2273        file: this.outputFile(),
2274        ignoreInvalidMapping: true
2275      })
2276  
2277      let line = 1
2278      let column = 1
2279  
2280      let noSource = '<no source>'
2281      let mapping = {
2282        generated: { column: 0, line: 0 },
2283        original: { column: 0, line: 0 },
2284        source: ''
2285      }
2286  
2287      let last, lines
2288      this.stringify(this.root, (str, node, type) => {
2289        this.css += str
2290  
2291        if (node && type !== 'end') {
2292          mapping.generated.line = line
2293          mapping.generated.column = column - 1
2294          if (node.source && node.source.start) {
2295            mapping.source = this.sourcePath(node)
2296            mapping.original.line = node.source.start.line
2297            mapping.original.column = node.source.start.column - 1
2298            this.map.addMapping(mapping)
2299          } else {
2300            mapping.source = noSource
2301            mapping.original.line = 1
2302            mapping.original.column = 0
2303            this.map.addMapping(mapping)
2304          }
2305        }
2306  
2307        lines = str.match(/\n/g)
2308        if (lines) {
2309          line += lines.length
2310          last = str.lastIndexOf('\n')
2311          column = str.length - last
2312        } else {
2313          column += str.length
2314        }
2315  
2316        if (node && type !== 'start') {
2317          let p = node.parent || { raws: {} }
2318          let childless =
2319            node.type === 'decl' || (node.type === 'atrule' && !node.nodes)
2320          if (!childless || node !== p.last || p.raws.semicolon) {
2321            if (node.source && node.source.end) {
2322              mapping.source = this.sourcePath(node)
2323              mapping.original.line = node.source.end.line
2324              mapping.original.column = node.source.end.column - 1
2325              mapping.generated.line = line
2326              mapping.generated.column = column - 2
2327              this.map.addMapping(mapping)
2328            } else {
2329              mapping.source = noSource
2330              mapping.original.line = 1
2331              mapping.original.column = 0
2332              mapping.generated.line = line
2333              mapping.generated.column = column - 1
2334              this.map.addMapping(mapping)
2335            }
2336          }
2337        }
2338      })
2339    }
2340  
2341    isAnnotation() {
2342      if (this.isInline()) {
2343        return true
2344      }
2345      if (typeof this.mapOpts.annotation !== 'undefined') {
2346        return this.mapOpts.annotation
2347      }
2348      if (this.previous().length) {
2349        return this.previous().some(i => i.annotation)
2350      }
2351      return true
2352    }
2353  
2354    isInline() {
2355      if (typeof this.mapOpts.inline !== 'undefined') {
2356        return this.mapOpts.inline
2357      }
2358  
2359      let annotation = this.mapOpts.annotation
2360      if (typeof annotation !== 'undefined' && annotation !== true) {
2361        return false
2362      }
2363  
2364      if (this.previous().length) {
2365        return this.previous().some(i => i.inline)
2366      }
2367      return true
2368    }
2369  
2370    isMap() {
2371      if (typeof this.opts.map !== 'undefined') {
2372        return !!this.opts.map
2373      }
2374      return this.previous().length > 0
2375    }
2376  
2377    isSourcesContent() {
2378      if (typeof this.mapOpts.sourcesContent !== 'undefined') {
2379        return this.mapOpts.sourcesContent
2380      }
2381      if (this.previous().length) {
2382        return this.previous().some(i => i.withContent())
2383      }
2384      return true
2385    }
2386  
2387    outputFile() {
2388      if (this.opts.to) {
2389        return this.path(this.opts.to)
2390      } else if (this.opts.from) {
2391        return this.path(this.opts.from)
2392      } else {
2393        return 'to.css'
2394      }
2395    }
2396  
2397    path(file) {
2398      if (this.mapOpts.absolute) return file
2399      if (file.charCodeAt(0) === 60 /* `<` */) return file
2400      if (/^\w+:\/\//.test(file)) return file
2401      let cached = this.memoizedPaths.get(file)
2402      if (cached) return cached
2403  
2404      let from = this.opts.to ? dirname(this.opts.to) : '.'
2405  
2406      if (typeof this.mapOpts.annotation === 'string') {
2407        from = dirname(resolve(from, this.mapOpts.annotation))
2408      }
2409  
2410      let path = relative(from, file)
2411      this.memoizedPaths.set(file, path)
2412  
2413      return path
2414    }
2415  
2416    previous() {
2417      if (!this.previousMaps) {
2418        this.previousMaps = []
2419        if (this.root) {
2420          this.root.walk(node => {
2421            if (node.source && node.source.input.map) {
2422              let map = node.source.input.map
2423              if (!this.previousMaps.includes(map)) {
2424                this.previousMaps.push(map)
2425              }
2426            }
2427          })
2428        } else {
2429          let input = new Input(this.originalCSS, this.opts)
2430          if (input.map) this.previousMaps.push(input.map)
2431        }
2432      }
2433  
2434      return this.previousMaps
2435    }
2436  
2437    setSourcesContent() {
2438      let already = {}
2439      if (this.root) {
2440        this.root.walk(node => {
2441          if (node.source) {
2442            let from = node.source.input.from
2443            if (from && !already[from]) {
2444              already[from] = true
2445              let fromUrl = this.usesFileUrls
2446                ? this.toFileUrl(from)
2447                : this.toUrl(this.path(from))
2448              this.map.setSourceContent(fromUrl, node.source.input.css)
2449            }
2450          }
2451        })
2452      } else if (this.css) {
2453        let from = this.opts.from
2454          ? this.toUrl(this.path(this.opts.from))
2455          : '<no source>'
2456        this.map.setSourceContent(from, this.css)
2457      }
2458    }
2459  
2460    sourcePath(node) {
2461      if (this.mapOpts.from) {
2462        return this.toUrl(this.mapOpts.from)
2463      } else if (this.usesFileUrls) {
2464        return this.toFileUrl(node.source.input.from)
2465      } else {
2466        return this.toUrl(this.path(node.source.input.from))
2467      }
2468    }
2469  
2470    toBase64(str) {
2471      if (Buffer) {
2472        return Buffer.from(str).toString('base64')
2473      } else {
2474        return window.btoa(unescape(encodeURIComponent(str)))
2475      }
2476    }
2477  
2478    toFileUrl(path) {
2479      let cached = this.memoizedFileURLs.get(path)
2480      if (cached) return cached
2481  
2482      if (pathToFileURL) {
2483        let fileURL = pathToFileURL(path).toString()
2484        this.memoizedFileURLs.set(path, fileURL)
2485  
2486        return fileURL
2487      } else {
2488        throw new Error(
2489          '`map.absolute` option is not available in this PostCSS build'
2490        )
2491      }
2492    }
2493  
2494    toUrl(path) {
2495      let cached = this.memoizedURLs.get(path)
2496      if (cached) return cached
2497  
2498      if (sep === '\\') {
2499        path = path.replace(/\\/g, '/')
2500      }
2501  
2502      let url = encodeURI(path).replace(/[#?]/g, encodeURIComponent)
2503      this.memoizedURLs.set(path, url)
2504  
2505      return url
2506    }
2507  }
2508  
2509  module.exports = MapGenerator
2510  
2511  
2512  /***/ }),
2513  
2514  /***/ 1866:
2515  /***/ (() => {
2516  
2517  /* (ignored) */
2518  
2519  /***/ }),
2520  
2521  /***/ 2213:
2522  /***/ ((module) => {
2523  
2524  /**
2525   * Copyright 2004-present Facebook. All Rights Reserved.
2526   *
2527   * @providesModule UserAgent_DEPRECATED
2528   */
2529  
2530  /**
2531   *  Provides entirely client-side User Agent and OS detection. You should prefer
2532   *  the non-deprecated UserAgent module when possible, which exposes our
2533   *  authoritative server-side PHP-based detection to the client.
2534   *
2535   *  Usage is straightforward:
2536   *
2537   *    if (UserAgent_DEPRECATED.ie()) {
2538   *      //  IE
2539   *    }
2540   *
2541   *  You can also do version checks:
2542   *
2543   *    if (UserAgent_DEPRECATED.ie() >= 7) {
2544   *      //  IE7 or better
2545   *    }
2546   *
2547   *  The browser functions will return NaN if the browser does not match, so
2548   *  you can also do version compares the other way:
2549   *
2550   *    if (UserAgent_DEPRECATED.ie() < 7) {
2551   *      //  IE6 or worse
2552   *    }
2553   *
2554   *  Note that the version is a float and may include a minor version number,
2555   *  so you should always use range operators to perform comparisons, not
2556   *  strict equality.
2557   *
2558   *  **Note:** You should **strongly** prefer capability detection to browser
2559   *  version detection where it's reasonable:
2560   *
2561   *    http://www.quirksmode.org/js/support.html
2562   *
2563   *  Further, we have a large number of mature wrapper functions and classes
2564   *  which abstract away many browser irregularities. Check the documentation,
2565   *  grep for things, or ask on javascript@lists.facebook.com before writing yet
2566   *  another copy of "event || window.event".
2567   *
2568   */
2569  
2570  var _populated = false;
2571  
2572  // Browsers
2573  var _ie, _firefox, _opera, _webkit, _chrome;
2574  
2575  // Actual IE browser for compatibility mode
2576  var _ie_real_version;
2577  
2578  // Platforms
2579  var _osx, _windows, _linux, _android;
2580  
2581  // Architectures
2582  var _win64;
2583  
2584  // Devices
2585  var _iphone, _ipad, _native;
2586  
2587  var _mobile;
2588  
2589  function _populate() {
2590    if (_populated) {
2591      return;
2592    }
2593  
2594    _populated = true;
2595  
2596    // To work around buggy JS libraries that can't handle multi-digit
2597    // version numbers, Opera 10's user agent string claims it's Opera
2598    // 9, then later includes a Version/X.Y field:
2599    //
2600    // Opera/9.80 (foo) Presto/2.2.15 Version/10.10
2601    var uas = navigator.userAgent;
2602    var agent = /(?:MSIE.(\d+\.\d+))|(?:(?:Firefox|GranParadiso|Iceweasel).(\d+\.\d+))|(?:Opera(?:.+Version.|.)(\d+\.\d+))|(?:AppleWebKit.(\d+(?:\.\d+)?))|(?:Trident\/\d+\.\d+.*rv:(\d+\.\d+))/.exec(uas);
2603    var os    = /(Mac OS X)|(Windows)|(Linux)/.exec(uas);
2604  
2605    _iphone = /\b(iPhone|iP[ao]d)/.exec(uas);
2606    _ipad = /\b(iP[ao]d)/.exec(uas);
2607    _android = /Android/i.exec(uas);
2608    _native = /FBAN\/\w+;/i.exec(uas);
2609    _mobile = /Mobile/i.exec(uas);
2610  
2611    // Note that the IE team blog would have you believe you should be checking
2612    // for 'Win64; x64'.  But MSDN then reveals that you can actually be coming
2613    // from either x64 or ia64;  so ultimately, you should just check for Win64
2614    // as in indicator of whether you're in 64-bit IE.  32-bit IE on 64-bit
2615    // Windows will send 'WOW64' instead.
2616    _win64 = !!(/Win64/.exec(uas));
2617  
2618    if (agent) {
2619      _ie = agent[1] ? parseFloat(agent[1]) : (
2620            agent[5] ? parseFloat(agent[5]) : NaN);
2621      // IE compatibility mode
2622      if (_ie && document && document.documentMode) {
2623        _ie = document.documentMode;
2624      }
2625      // grab the "true" ie version from the trident token if available
2626      var trident = /(?:Trident\/(\d+.\d+))/.exec(uas);
2627      _ie_real_version = trident ? parseFloat(trident[1]) + 4 : _ie;
2628  
2629      _firefox = agent[2] ? parseFloat(agent[2]) : NaN;
2630      _opera   = agent[3] ? parseFloat(agent[3]) : NaN;
2631      _webkit  = agent[4] ? parseFloat(agent[4]) : NaN;
2632      if (_webkit) {
2633        // We do not add the regexp to the above test, because it will always
2634        // match 'safari' only since 'AppleWebKit' appears before 'Chrome' in
2635        // the userAgent string.
2636        agent = /(?:Chrome\/(\d+\.\d+))/.exec(uas);
2637        _chrome = agent && agent[1] ? parseFloat(agent[1]) : NaN;
2638      } else {
2639        _chrome = NaN;
2640      }
2641    } else {
2642      _ie = _firefox = _opera = _chrome = _webkit = NaN;
2643    }
2644  
2645    if (os) {
2646      if (os[1]) {
2647        // Detect OS X version.  If no version number matches, set _osx to true.
2648        // Version examples:  10, 10_6_1, 10.7
2649        // Parses version number as a float, taking only first two sets of
2650        // digits.  If only one set of digits is found, returns just the major
2651        // version number.
2652        var ver = /(?:Mac OS X (\d+(?:[._]\d+)?))/.exec(uas);
2653  
2654        _osx = ver ? parseFloat(ver[1].replace('_', '.')) : true;
2655      } else {
2656        _osx = false;
2657      }
2658      _windows = !!os[2];
2659      _linux   = !!os[3];
2660    } else {
2661      _osx = _windows = _linux = false;
2662    }
2663  }
2664  
2665  var UserAgent_DEPRECATED = {
2666  
2667    /**
2668     *  Check if the UA is Internet Explorer.
2669     *
2670     *
2671     *  @return float|NaN Version number (if match) or NaN.
2672     */
2673    ie: function() {
2674      return _populate() || _ie;
2675    },
2676  
2677    /**
2678     * Check if we're in Internet Explorer compatibility mode.
2679     *
2680     * @return bool true if in compatibility mode, false if
2681     * not compatibility mode or not ie
2682     */
2683    ieCompatibilityMode: function() {
2684      return _populate() || (_ie_real_version > _ie);
2685    },
2686  
2687  
2688    /**
2689     * Whether the browser is 64-bit IE.  Really, this is kind of weak sauce;  we
2690     * only need this because Skype can't handle 64-bit IE yet.  We need to remove
2691     * this when we don't need it -- tracked by #601957.
2692     */
2693    ie64: function() {
2694      return UserAgent_DEPRECATED.ie() && _win64;
2695    },
2696  
2697    /**
2698     *  Check if the UA is Firefox.
2699     *
2700     *
2701     *  @return float|NaN Version number (if match) or NaN.
2702     */
2703    firefox: function() {
2704      return _populate() || _firefox;
2705    },
2706  
2707  
2708    /**
2709     *  Check if the UA is Opera.
2710     *
2711     *
2712     *  @return float|NaN Version number (if match) or NaN.
2713     */
2714    opera: function() {
2715      return _populate() || _opera;
2716    },
2717  
2718  
2719    /**
2720     *  Check if the UA is WebKit.
2721     *
2722     *
2723     *  @return float|NaN Version number (if match) or NaN.
2724     */
2725    webkit: function() {
2726      return _populate() || _webkit;
2727    },
2728  
2729    /**
2730     *  For Push
2731     *  WILL BE REMOVED VERY SOON. Use UserAgent_DEPRECATED.webkit
2732     */
2733    safari: function() {
2734      return UserAgent_DEPRECATED.webkit();
2735    },
2736  
2737    /**
2738     *  Check if the UA is a Chrome browser.
2739     *
2740     *
2741     *  @return float|NaN Version number (if match) or NaN.
2742     */
2743    chrome : function() {
2744      return _populate() || _chrome;
2745    },
2746  
2747  
2748    /**
2749     *  Check if the user is running Windows.
2750     *
2751     *  @return bool `true' if the user's OS is Windows.
2752     */
2753    windows: function() {
2754      return _populate() || _windows;
2755    },
2756  
2757  
2758    /**
2759     *  Check if the user is running Mac OS X.
2760     *
2761     *  @return float|bool   Returns a float if a version number is detected,
2762     *                       otherwise true/false.
2763     */
2764    osx: function() {
2765      return _populate() || _osx;
2766    },
2767  
2768    /**
2769     * Check if the user is running Linux.
2770     *
2771     * @return bool `true' if the user's OS is some flavor of Linux.
2772     */
2773    linux: function() {
2774      return _populate() || _linux;
2775    },
2776  
2777    /**
2778     * Check if the user is running on an iPhone or iPod platform.
2779     *
2780     * @return bool `true' if the user is running some flavor of the
2781     *    iPhone OS.
2782     */
2783    iphone: function() {
2784      return _populate() || _iphone;
2785    },
2786  
2787    mobile: function() {
2788      return _populate() || (_iphone || _ipad || _android || _mobile);
2789    },
2790  
2791    nativeApp: function() {
2792      // webviews inside of the native apps
2793      return _populate() || _native;
2794    },
2795  
2796    android: function() {
2797      return _populate() || _android;
2798    },
2799  
2800    ipad: function() {
2801      return _populate() || _ipad;
2802    }
2803  };
2804  
2805  module.exports = UserAgent_DEPRECATED;
2806  
2807  
2808  /***/ }),
2809  
2810  /***/ 2327:
2811  /***/ ((module) => {
2812  
2813  "use strict";
2814  
2815  
2816  const SINGLE_QUOTE = "'".charCodeAt(0)
2817  const DOUBLE_QUOTE = '"'.charCodeAt(0)
2818  const BACKSLASH = '\\'.charCodeAt(0)
2819  const SLASH = '/'.charCodeAt(0)
2820  const NEWLINE = '\n'.charCodeAt(0)
2821  const SPACE = ' '.charCodeAt(0)
2822  const FEED = '\f'.charCodeAt(0)
2823  const TAB = '\t'.charCodeAt(0)
2824  const CR = '\r'.charCodeAt(0)
2825  const OPEN_SQUARE = '['.charCodeAt(0)
2826  const CLOSE_SQUARE = ']'.charCodeAt(0)
2827  const OPEN_PARENTHESES = '('.charCodeAt(0)
2828  const CLOSE_PARENTHESES = ')'.charCodeAt(0)
2829  const OPEN_CURLY = '{'.charCodeAt(0)
2830  const CLOSE_CURLY = '}'.charCodeAt(0)
2831  const SEMICOLON = ';'.charCodeAt(0)
2832  const ASTERISK = '*'.charCodeAt(0)
2833  const COLON = ':'.charCodeAt(0)
2834  const AT = '@'.charCodeAt(0)
2835  
2836  const RE_AT_END = /[\t\n\f\r "#'()/;[\\\]{}]/g
2837  const RE_WORD_END = /[\t\n\f\r !"#'():;@[\\\]{}]|\/(?=\*)/g
2838  const RE_BAD_BRACKET = /.[\r\n"'(/\\]/
2839  const RE_HEX_ESCAPE = /[\da-f]/i
2840  
2841  module.exports = function tokenizer(input, options = {}) {
2842    let css = input.css.valueOf()
2843    let ignore = options.ignoreErrors
2844  
2845    let code, content, escape, next, quote
2846    let currentToken, escaped, escapePos, n, prev
2847  
2848    let length = css.length
2849    let pos = 0
2850    let buffer = []
2851    let returned = []
2852  
2853    function position() {
2854      return pos
2855    }
2856  
2857    function unclosed(what) {
2858      throw input.error('Unclosed ' + what, pos)
2859    }
2860  
2861    function endOfFile() {
2862      return returned.length === 0 && pos >= length
2863    }
2864  
2865    function nextToken(opts) {
2866      if (returned.length) return returned.pop()
2867      if (pos >= length) return
2868  
2869      let ignoreUnclosed = opts ? opts.ignoreUnclosed : false
2870  
2871      code = css.charCodeAt(pos)
2872  
2873      switch (code) {
2874        case NEWLINE:
2875        case SPACE:
2876        case TAB:
2877        case CR:
2878        case FEED: {
2879          next = pos
2880          do {
2881            next += 1
2882            code = css.charCodeAt(next)
2883          } while (
2884            code === SPACE ||
2885            code === NEWLINE ||
2886            code === TAB ||
2887            code === CR ||
2888            code === FEED
2889          )
2890  
2891          currentToken = ['space', css.slice(pos, next)]
2892          pos = next - 1
2893          break
2894        }
2895  
2896        case OPEN_SQUARE:
2897        case CLOSE_SQUARE:
2898        case OPEN_CURLY:
2899        case CLOSE_CURLY:
2900        case COLON:
2901        case SEMICOLON:
2902        case CLOSE_PARENTHESES: {
2903          let controlChar = String.fromCharCode(code)
2904          currentToken = [controlChar, controlChar, pos]
2905          break
2906        }
2907  
2908        case OPEN_PARENTHESES: {
2909          prev = buffer.length ? buffer.pop()[1] : ''
2910          n = css.charCodeAt(pos + 1)
2911          if (
2912            prev === 'url' &&
2913            n !== SINGLE_QUOTE &&
2914            n !== DOUBLE_QUOTE &&
2915            n !== SPACE &&
2916            n !== NEWLINE &&
2917            n !== TAB &&
2918            n !== FEED &&
2919            n !== CR
2920          ) {
2921            next = pos
2922            do {
2923              escaped = false
2924              next = css.indexOf(')', next + 1)
2925              if (next === -1) {
2926                if (ignore || ignoreUnclosed) {
2927                  next = pos
2928                  break
2929                } else {
2930                  unclosed('bracket')
2931                }
2932              }
2933              escapePos = next
2934              while (css.charCodeAt(escapePos - 1) === BACKSLASH) {
2935                escapePos -= 1
2936                escaped = !escaped
2937              }
2938            } while (escaped)
2939  
2940            currentToken = ['brackets', css.slice(pos, next + 1), pos, next]
2941  
2942            pos = next
2943          } else {
2944            next = css.indexOf(')', pos + 1)
2945            content = css.slice(pos, next + 1)
2946  
2947            if (next === -1 || RE_BAD_BRACKET.test(content)) {
2948              currentToken = ['(', '(', pos]
2949            } else {
2950              currentToken = ['brackets', content, pos, next]
2951              pos = next
2952            }
2953          }
2954  
2955          break
2956        }
2957  
2958        case SINGLE_QUOTE:
2959        case DOUBLE_QUOTE: {
2960          quote = code === SINGLE_QUOTE ? "'" : '"'
2961          next = pos
2962          do {
2963            escaped = false
2964            next = css.indexOf(quote, next + 1)
2965            if (next === -1) {
2966              if (ignore || ignoreUnclosed) {
2967                next = pos + 1
2968                break
2969              } else {
2970                unclosed('string')
2971              }
2972            }
2973            escapePos = next
2974            while (css.charCodeAt(escapePos - 1) === BACKSLASH) {
2975              escapePos -= 1
2976              escaped = !escaped
2977            }
2978          } while (escaped)
2979  
2980          currentToken = ['string', css.slice(pos, next + 1), pos, next]
2981          pos = next
2982          break
2983        }
2984  
2985        case AT: {
2986          RE_AT_END.lastIndex = pos + 1
2987          RE_AT_END.test(css)
2988          if (RE_AT_END.lastIndex === 0) {
2989            next = css.length - 1
2990          } else {
2991            next = RE_AT_END.lastIndex - 2
2992          }
2993  
2994          currentToken = ['at-word', css.slice(pos, next + 1), pos, next]
2995  
2996          pos = next
2997          break
2998        }
2999  
3000        case BACKSLASH: {
3001          next = pos
3002          escape = true
3003          while (css.charCodeAt(next + 1) === BACKSLASH) {
3004            next += 1
3005            escape = !escape
3006          }
3007          code = css.charCodeAt(next + 1)
3008          if (
3009            escape &&
3010            code !== SLASH &&
3011            code !== SPACE &&
3012            code !== NEWLINE &&
3013            code !== TAB &&
3014            code !== CR &&
3015            code !== FEED
3016          ) {
3017            next += 1
3018            if (RE_HEX_ESCAPE.test(css.charAt(next))) {
3019              while (RE_HEX_ESCAPE.test(css.charAt(next + 1))) {
3020                next += 1
3021              }
3022              if (css.charCodeAt(next + 1) === SPACE) {
3023                next += 1
3024              }
3025            }
3026          }
3027  
3028          currentToken = ['word', css.slice(pos, next + 1), pos, next]
3029  
3030          pos = next
3031          break
3032        }
3033  
3034        default: {
3035          if (code === SLASH && css.charCodeAt(pos + 1) === ASTERISK) {
3036            next = css.indexOf('*/', pos + 2) + 1
3037            if (next === 0) {
3038              if (ignore || ignoreUnclosed) {
3039                next = css.length
3040              } else {
3041                unclosed('comment')
3042              }
3043            }
3044  
3045            currentToken = ['comment', css.slice(pos, next + 1), pos, next]
3046            pos = next
3047          } else {
3048            RE_WORD_END.lastIndex = pos + 1
3049            RE_WORD_END.test(css)
3050            if (RE_WORD_END.lastIndex === 0) {
3051              next = css.length - 1
3052            } else {
3053              next = RE_WORD_END.lastIndex - 2
3054            }
3055  
3056            currentToken = ['word', css.slice(pos, next + 1), pos, next]
3057            buffer.push(currentToken)
3058            pos = next
3059          }
3060  
3061          break
3062        }
3063      }
3064  
3065      pos++
3066      return currentToken
3067    }
3068  
3069    function back(token) {
3070      returned.push(token)
3071    }
3072  
3073    return {
3074      back,
3075      endOfFile,
3076      nextToken,
3077      position
3078    }
3079  }
3080  
3081  
3082  /***/ }),
3083  
3084  /***/ 2739:
3085  /***/ (() => {
3086  
3087  /* (ignored) */
3088  
3089  /***/ }),
3090  
3091  /***/ 2775:
3092  /***/ ((module) => {
3093  
3094  var x=String;
3095  var create=function() {return {isColorSupported:false,reset:x,bold:x,dim:x,italic:x,underline:x,inverse:x,hidden:x,strikethrough:x,black:x,red:x,green:x,yellow:x,blue:x,magenta:x,cyan:x,white:x,gray:x,bgBlack:x,bgRed:x,bgGreen:x,bgYellow:x,bgBlue:x,bgMagenta:x,bgCyan:x,bgWhite:x,blackBright:x,redBright:x,greenBright:x,yellowBright:x,blueBright:x,magentaBright:x,cyanBright:x,whiteBright:x,bgBlackBright:x,bgRedBright:x,bgGreenBright:x,bgYellowBright:x,bgBlueBright:x,bgMagentaBright:x,bgCyanBright:x,bgWhiteBright:x}};
3096  module.exports=create();
3097  module.exports.createColors = create;
3098  
3099  
3100  /***/ }),
3101  
3102  /***/ 3122:
3103  /***/ ((module) => {
3104  
3105  "use strict";
3106  /* eslint-disable no-console */
3107  
3108  
3109  let printed = {}
3110  
3111  module.exports = function warnOnce(message) {
3112    if (printed[message]) return
3113    printed[message] = true
3114  
3115    if (typeof console !== 'undefined' && console.warn) {
3116      console.warn(message)
3117    }
3118  }
3119  
3120  
3121  /***/ }),
3122  
3123  /***/ 3815:
3124  /***/ ((module) => {
3125  
3126  module.exports = function walk(nodes, cb, bubble) {
3127    var i, max, node, result;
3128  
3129    for (i = 0, max = nodes.length; i < max; i += 1) {
3130      node = nodes[i];
3131      if (!bubble) {
3132        result = cb(node, i, nodes);
3133      }
3134  
3135      if (
3136        result !== false &&
3137        node.type === "function" &&
3138        Array.isArray(node.nodes)
3139      ) {
3140        walk(node.nodes, cb, bubble);
3141      }
3142  
3143      if (bubble) {
3144        cb(node, i, nodes);
3145      }
3146    }
3147  };
3148  
3149  
3150  /***/ }),
3151  
3152  /***/ 3937:
3153  /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
3154  
3155  "use strict";
3156  
3157  
3158  let AtRule = __webpack_require__(1326)
3159  let Comment = __webpack_require__(6589)
3160  let Declaration = __webpack_require__(1516)
3161  let Root = __webpack_require__(9434)
3162  let Rule = __webpack_require__(4092)
3163  let tokenizer = __webpack_require__(2327)
3164  
3165  const SAFE_COMMENT_NEIGHBOR = {
3166    empty: true,
3167    space: true
3168  }
3169  
3170  function findLastWithPosition(tokens) {
3171    for (let i = tokens.length - 1; i >= 0; i--) {
3172      let token = tokens[i]
3173      let pos = token[3] || token[2]
3174      if (pos) return pos
3175    }
3176  }
3177  
3178  class Parser {
3179    constructor(input) {
3180      this.input = input
3181  
3182      this.root = new Root()
3183      this.current = this.root
3184      this.spaces = ''
3185      this.semicolon = false
3186  
3187      this.createTokenizer()
3188      this.root.source = { input, start: { column: 1, line: 1, offset: 0 } }
3189    }
3190  
3191    atrule(token) {
3192      let node = new AtRule()
3193      node.name = token[1].slice(1)
3194      if (node.name === '') {
3195        this.unnamedAtrule(node, token)
3196      }
3197      this.init(node, token[2])
3198  
3199      let type
3200      let prev
3201      let shift
3202      let last = false
3203      let open = false
3204      let params = []
3205      let brackets = []
3206  
3207      while (!this.tokenizer.endOfFile()) {
3208        token = this.tokenizer.nextToken()
3209        type = token[0]
3210  
3211        if (type === '(' || type === '[') {
3212          brackets.push(type === '(' ? ')' : ']')
3213        } else if (type === '{' && brackets.length > 0) {
3214          brackets.push('}')
3215        } else if (type === brackets[brackets.length - 1]) {
3216          brackets.pop()
3217        }
3218  
3219        if (brackets.length === 0) {
3220          if (type === ';') {
3221            node.source.end = this.getPosition(token[2])
3222            node.source.end.offset++
3223            this.semicolon = true
3224            break
3225          } else if (type === '{') {
3226            open = true
3227            break
3228          } else if (type === '}') {
3229            if (params.length > 0) {
3230              shift = params.length - 1
3231              prev = params[shift]
3232              while (prev && prev[0] === 'space') {
3233                prev = params[--shift]
3234              }
3235              if (prev) {
3236                node.source.end = this.getPosition(prev[3] || prev[2])
3237                node.source.end.offset++
3238              }
3239            }
3240            this.end(token)
3241            break
3242          } else {
3243            params.push(token)
3244          }
3245        } else {
3246          params.push(token)
3247        }
3248  
3249        if (this.tokenizer.endOfFile()) {
3250          last = true
3251          break
3252        }
3253      }
3254  
3255      node.raws.between = this.spacesAndCommentsFromEnd(params)
3256      if (params.length) {
3257        node.raws.afterName = this.spacesAndCommentsFromStart(params)
3258        this.raw(node, 'params', params)
3259        if (last) {
3260          token = params[params.length - 1]
3261          node.source.end = this.getPosition(token[3] || token[2])
3262          node.source.end.offset++
3263          this.spaces = node.raws.between
3264          node.raws.between = ''
3265        }
3266      } else {
3267        node.raws.afterName = ''
3268        node.params = ''
3269      }
3270  
3271      if (open) {
3272        node.nodes = []
3273        this.current = node
3274      }
3275    }
3276  
3277    checkMissedSemicolon(tokens) {
3278      let colon = this.colon(tokens)
3279      if (colon === false) return
3280  
3281      let founded = 0
3282      let token
3283      for (let j = colon - 1; j >= 0; j--) {
3284        token = tokens[j]
3285        if (token[0] !== 'space') {
3286          founded += 1
3287          if (founded === 2) break
3288        }
3289      }
3290      // If the token is a word, e.g. `!important`, `red` or any other valid property's value.
3291      // Then we need to return the colon after that word token. [3] is the "end" colon of that word.
3292      // And because we need it after that one we do +1 to get the next one.
3293      throw this.input.error(
3294        'Missed semicolon',
3295        token[0] === 'word' ? token[3] + 1 : token[2]
3296      )
3297    }
3298  
3299    colon(tokens) {
3300      let brackets = 0
3301      let prev, token, type
3302      for (let [i, element] of tokens.entries()) {
3303        token = element
3304        type = token[0]
3305  
3306        if (type === '(') {
3307          brackets += 1
3308        }
3309        if (type === ')') {
3310          brackets -= 1
3311        }
3312        if (brackets === 0 && type === ':') {
3313          if (!prev) {
3314            this.doubleColon(token)
3315          } else if (prev[0] === 'word' && prev[1] === 'progid') {
3316            continue
3317          } else {
3318            return i
3319          }
3320        }
3321  
3322        prev = token
3323      }
3324      return false
3325    }
3326  
3327    comment(token) {
3328      let node = new Comment()
3329      this.init(node, token[2])
3330      node.source.end = this.getPosition(token[3] || token[2])
3331      node.source.end.offset++
3332  
3333      let text = token[1].slice(2, -2)
3334      if (/^\s*$/.test(text)) {
3335        node.text = ''
3336        node.raws.left = text
3337        node.raws.right = ''
3338      } else {
3339        let match = text.match(/^(\s*)([^]*\S)(\s*)$/)
3340        node.text = match[2]
3341        node.raws.left = match[1]
3342        node.raws.right = match[3]
3343      }
3344    }
3345  
3346    createTokenizer() {
3347      this.tokenizer = tokenizer(this.input)
3348    }
3349  
3350    decl(tokens, customProperty) {
3351      let node = new Declaration()
3352      this.init(node, tokens[0][2])
3353  
3354      let last = tokens[tokens.length - 1]
3355      if (last[0] === ';') {
3356        this.semicolon = true
3357        tokens.pop()
3358      }
3359  
3360      node.source.end = this.getPosition(
3361        last[3] || last[2] || findLastWithPosition(tokens)
3362      )
3363      node.source.end.offset++
3364  
3365      while (tokens[0][0] !== 'word') {
3366        if (tokens.length === 1) this.unknownWord(tokens)
3367        node.raws.before += tokens.shift()[1]
3368      }
3369      node.source.start = this.getPosition(tokens[0][2])
3370  
3371      node.prop = ''
3372      while (tokens.length) {
3373        let type = tokens[0][0]
3374        if (type === ':' || type === 'space' || type === 'comment') {
3375          break
3376        }
3377        node.prop += tokens.shift()[1]
3378      }
3379  
3380      node.raws.between = ''
3381  
3382      let token
3383      while (tokens.length) {
3384        token = tokens.shift()
3385  
3386        if (token[0] === ':') {
3387          node.raws.between += token[1]
3388          break
3389        } else {
3390          if (token[0] === 'word' && /\w/.test(token[1])) {
3391            this.unknownWord([token])
3392          }
3393          node.raws.between += token[1]
3394        }
3395      }
3396  
3397      if (node.prop[0] === '_' || node.prop[0] === '*') {
3398        node.raws.before += node.prop[0]
3399        node.prop = node.prop.slice(1)
3400      }
3401  
3402      let firstSpaces = []
3403      let next
3404      while (tokens.length) {
3405        next = tokens[0][0]
3406        if (next !== 'space' && next !== 'comment') break
3407        firstSpaces.push(tokens.shift())
3408      }
3409  
3410      this.precheckMissedSemicolon(tokens)
3411  
3412      for (let i = tokens.length - 1; i >= 0; i--) {
3413        token = tokens[i]
3414        if (token[1].toLowerCase() === '!important') {
3415          node.important = true
3416          let string = this.stringFrom(tokens, i)
3417          string = this.spacesFromEnd(tokens) + string
3418          if (string !== ' !important') node.raws.important = string
3419          break
3420        } else if (token[1].toLowerCase() === 'important') {
3421          let cache = tokens.slice(0)
3422          let str = ''
3423          for (let j = i; j > 0; j--) {
3424            let type = cache[j][0]
3425            if (str.trim().startsWith('!') && type !== 'space') {
3426              break
3427            }
3428            str = cache.pop()[1] + str
3429          }
3430          if (str.trim().startsWith('!')) {
3431            node.important = true
3432            node.raws.important = str
3433            tokens = cache
3434          }
3435        }
3436  
3437        if (token[0] !== 'space' && token[0] !== 'comment') {
3438          break
3439        }
3440      }
3441  
3442      let hasWord = tokens.some(i => i[0] !== 'space' && i[0] !== 'comment')
3443  
3444      if (hasWord) {
3445        node.raws.between += firstSpaces.map(i => i[1]).join('')
3446        firstSpaces = []
3447      }
3448      this.raw(node, 'value', firstSpaces.concat(tokens), customProperty)
3449  
3450      if (node.value.includes(':') && !customProperty) {
3451        this.checkMissedSemicolon(tokens)
3452      }
3453    }
3454  
3455    doubleColon(token) {
3456      throw this.input.error(
3457        'Double colon',
3458        { offset: token[2] },
3459        { offset: token[2] + token[1].length }
3460      )
3461    }
3462  
3463    emptyRule(token) {
3464      let node = new Rule()
3465      this.init(node, token[2])
3466      node.selector = ''
3467      node.raws.between = ''
3468      this.current = node
3469    }
3470  
3471    end(token) {
3472      if (this.current.nodes && this.current.nodes.length) {
3473        this.current.raws.semicolon = this.semicolon
3474      }
3475      this.semicolon = false
3476  
3477      this.current.raws.after = (this.current.raws.after || '') + this.spaces
3478      this.spaces = ''
3479  
3480      if (this.current.parent) {
3481        this.current.source.end = this.getPosition(token[2])
3482        this.current.source.end.offset++
3483        this.current = this.current.parent
3484      } else {
3485        this.unexpectedClose(token)
3486      }
3487    }
3488  
3489    endFile() {
3490      if (this.current.parent) this.unclosedBlock()
3491      if (this.current.nodes && this.current.nodes.length) {
3492        this.current.raws.semicolon = this.semicolon
3493      }
3494      this.current.raws.after = (this.current.raws.after || '') + this.spaces
3495      this.root.source.end = this.getPosition(this.tokenizer.position())
3496    }
3497  
3498    freeSemicolon(token) {
3499      this.spaces += token[1]
3500      if (this.current.nodes) {
3501        let prev = this.current.nodes[this.current.nodes.length - 1]
3502        if (prev && prev.type === 'rule' && !prev.raws.ownSemicolon) {
3503          prev.raws.ownSemicolon = this.spaces
3504          this.spaces = ''
3505          prev.source.end = this.getPosition(token[2])
3506          prev.source.end.offset += prev.raws.ownSemicolon.length
3507        }
3508      }
3509    }
3510  
3511    // Helpers
3512  
3513    getPosition(offset) {
3514      let pos = this.input.fromOffset(offset)
3515      return {
3516        column: pos.col,
3517        line: pos.line,
3518        offset
3519      }
3520    }
3521  
3522    init(node, offset) {
3523      this.current.push(node)
3524      node.source = {
3525        input: this.input,
3526        start: this.getPosition(offset)
3527      }
3528      node.raws.before = this.spaces
3529      this.spaces = ''
3530      if (node.type !== 'comment') this.semicolon = false
3531    }
3532  
3533    other(start) {
3534      let end = false
3535      let type = null
3536      let colon = false
3537      let bracket = null
3538      let brackets = []
3539      let customProperty = start[1].startsWith('--')
3540  
3541      let tokens = []
3542      let token = start
3543      while (token) {
3544        type = token[0]
3545        tokens.push(token)
3546  
3547        if (type === '(' || type === '[') {
3548          if (!bracket) bracket = token
3549          brackets.push(type === '(' ? ')' : ']')
3550        } else if (customProperty && colon && type === '{') {
3551          if (!bracket) bracket = token
3552          brackets.push('}')
3553        } else if (brackets.length === 0) {
3554          if (type === ';') {
3555            if (colon) {
3556              this.decl(tokens, customProperty)
3557              return
3558            } else {
3559              break
3560            }
3561          } else if (type === '{') {
3562            this.rule(tokens)
3563            return
3564          } else if (type === '}') {
3565            this.tokenizer.back(tokens.pop())
3566            end = true
3567            break
3568          } else if (type === ':') {
3569            colon = true
3570          }
3571        } else if (type === brackets[brackets.length - 1]) {
3572          brackets.pop()
3573          if (brackets.length === 0) bracket = null
3574        }
3575  
3576        token = this.tokenizer.nextToken()
3577      }
3578  
3579      if (this.tokenizer.endOfFile()) end = true
3580      if (brackets.length > 0) this.unclosedBracket(bracket)
3581  
3582      if (end && colon) {
3583        if (!customProperty) {
3584          while (tokens.length) {
3585            token = tokens[tokens.length - 1][0]
3586            if (token !== 'space' && token !== 'comment') break
3587            this.tokenizer.back(tokens.pop())
3588          }
3589        }
3590        this.decl(tokens, customProperty)
3591      } else {
3592        this.unknownWord(tokens)
3593      }
3594    }
3595  
3596    parse() {
3597      let token
3598      while (!this.tokenizer.endOfFile()) {
3599        token = this.tokenizer.nextToken()
3600  
3601        switch (token[0]) {
3602          case 'space':
3603            this.spaces += token[1]
3604            break
3605  
3606          case ';':
3607            this.freeSemicolon(token)
3608            break
3609  
3610          case '}':
3611            this.end(token)
3612            break
3613  
3614          case 'comment':
3615            this.comment(token)
3616            break
3617  
3618          case 'at-word':
3619            this.atrule(token)
3620            break
3621  
3622          case '{':
3623            this.emptyRule(token)
3624            break
3625  
3626          default:
3627            this.other(token)
3628            break
3629        }
3630      }
3631      this.endFile()
3632    }
3633  
3634    precheckMissedSemicolon(/* tokens */) {
3635      // Hook for Safe Parser
3636    }
3637  
3638    raw(node, prop, tokens, customProperty) {
3639      let token, type
3640      let length = tokens.length
3641      let value = ''
3642      let clean = true
3643      let next, prev
3644  
3645      for (let i = 0; i < length; i += 1) {
3646        token = tokens[i]
3647        type = token[0]
3648        if (type === 'space' && i === length - 1 && !customProperty) {
3649          clean = false
3650        } else if (type === 'comment') {
3651          prev = tokens[i - 1] ? tokens[i - 1][0] : 'empty'
3652          next = tokens[i + 1] ? tokens[i + 1][0] : 'empty'
3653          if (!SAFE_COMMENT_NEIGHBOR[prev] && !SAFE_COMMENT_NEIGHBOR[next]) {
3654            if (value.slice(-1) === ',') {
3655              clean = false
3656            } else {
3657              value += token[1]
3658            }
3659          } else {
3660            clean = false
3661          }
3662        } else {
3663          value += token[1]
3664        }
3665      }
3666      if (!clean) {
3667        let raw = tokens.reduce((all, i) => all + i[1], '')
3668        node.raws[prop] = { raw, value }
3669      }
3670      node[prop] = value
3671    }
3672  
3673    rule(tokens) {
3674      tokens.pop()
3675  
3676      let node = new Rule()
3677      this.init(node, tokens[0][2])
3678  
3679      node.raws.between = this.spacesAndCommentsFromEnd(tokens)
3680      this.raw(node, 'selector', tokens)
3681      this.current = node
3682    }
3683  
3684    spacesAndCommentsFromEnd(tokens) {
3685      let lastTokenType
3686      let spaces = ''
3687      while (tokens.length) {
3688        lastTokenType = tokens[tokens.length - 1][0]
3689        if (lastTokenType !== 'space' && lastTokenType !== 'comment') break
3690        spaces = tokens.pop()[1] + spaces
3691      }
3692      return spaces
3693    }
3694  
3695    // Errors
3696  
3697    spacesAndCommentsFromStart(tokens) {
3698      let next
3699      let spaces = ''
3700      while (tokens.length) {
3701        next = tokens[0][0]
3702        if (next !== 'space' && next !== 'comment') break
3703        spaces += tokens.shift()[1]
3704      }
3705      return spaces
3706    }
3707  
3708    spacesFromEnd(tokens) {
3709      let lastTokenType
3710      let spaces = ''
3711      while (tokens.length) {
3712        lastTokenType = tokens[tokens.length - 1][0]
3713        if (lastTokenType !== 'space') break
3714        spaces = tokens.pop()[1] + spaces
3715      }
3716      return spaces
3717    }
3718  
3719    stringFrom(tokens, from) {
3720      let result = ''
3721      for (let i = from; i < tokens.length; i++) {
3722        result += tokens[i][1]
3723      }
3724      tokens.splice(from, tokens.length - from)
3725      return result
3726    }
3727  
3728    unclosedBlock() {
3729      let pos = this.current.source.start
3730      throw this.input.error('Unclosed block', pos.line, pos.column)
3731    }
3732  
3733    unclosedBracket(bracket) {
3734      throw this.input.error(
3735        'Unclosed bracket',
3736        { offset: bracket[2] },
3737        { offset: bracket[2] + 1 }
3738      )
3739    }
3740  
3741    unexpectedClose(token) {
3742      throw this.input.error(
3743        'Unexpected }',
3744        { offset: token[2] },
3745        { offset: token[2] + 1 }
3746      )
3747    }
3748  
3749    unknownWord(tokens) {
3750      throw this.input.error(
3751        'Unknown word ' + tokens[0][1],
3752        { offset: tokens[0][2] },
3753        { offset: tokens[0][2] + tokens[0][1].length }
3754      )
3755    }
3756  
3757    unnamedAtrule(node, token) {
3758      throw this.input.error(
3759        'At-rule without name',
3760        { offset: token[2] },
3761        { offset: token[2] + token[1].length }
3762      )
3763    }
3764  }
3765  
3766  module.exports = Parser
3767  
3768  
3769  /***/ }),
3770  
3771  /***/ 4067:
3772  /***/ ((module) => {
3773  
3774  "use strict";
3775  /**
3776   * Copyright (c) 2013-present, Facebook, Inc.
3777   *
3778   * This source code is licensed under the MIT license found in the
3779   * LICENSE file in the root directory of this source tree.
3780   */
3781  
3782  
3783  
3784  var ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';
3785  
3786  module.exports = ReactPropTypesSecret;
3787  
3788  
3789  /***/ }),
3790  
3791  /***/ 4092:
3792  /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
3793  
3794  "use strict";
3795  
3796  
3797  let Container = __webpack_require__(683)
3798  let list = __webpack_require__(7374)
3799  
3800  class Rule extends Container {
3801    get selectors() {
3802      return list.comma(this.selector)
3803    }
3804  
3805    set selectors(values) {
3806      let match = this.selector ? this.selector.match(/,\s*/) : null
3807      let sep = match ? match[0] : ',' + this.raw('between', 'beforeOpen')
3808      this.selector = values.join(sep)
3809    }
3810  
3811    constructor(defaults) {
3812      super(defaults)
3813      this.type = 'rule'
3814      if (!this.nodes) this.nodes = []
3815    }
3816  }
3817  
3818  module.exports = Rule
3819  Rule.default = Rule
3820  
3821  Container.registerRule(Rule)
3822  
3823  
3824  /***/ }),
3825  
3826  /***/ 4132:
3827  /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
3828  
3829  "use strict";
3830  var __webpack_unused_export__;
3831  
3832  __webpack_unused_export__ = true;
3833  var TextareaAutosize_1 = __webpack_require__(4462);
3834  exports.A = TextareaAutosize_1.TextareaAutosize;
3835  
3836  
3837  /***/ }),
3838  
3839  /***/ 4295:
3840  /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
3841  
3842  "use strict";
3843  
3844  
3845  let Container = __webpack_require__(683)
3846  let Input = __webpack_require__(5380)
3847  let Parser = __webpack_require__(3937)
3848  
3849  function parse(css, opts) {
3850    let input = new Input(css, opts)
3851    let parser = new Parser(input)
3852    try {
3853      parser.parse()
3854    } catch (e) {
3855      if (false) {}
3856      throw e
3857    }
3858  
3859    return parser.root
3860  }
3861  
3862  module.exports = parse
3863  parse.default = parse
3864  
3865  Container.registerParse(parse)
3866  
3867  
3868  /***/ }),
3869  
3870  /***/ 4306:
3871  /***/ (function(module, exports) {
3872  
3873  var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*!
3874      autosize 4.0.4
3875      license: MIT
3876      http://www.jacklmoore.com/autosize
3877  */
3878  (function (global, factory) {
3879      if (true) {
3880          !(__WEBPACK_AMD_DEFINE_ARRAY__ = [module, exports], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory),
3881          __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ?
3882          (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__),
3883          __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
3884      } else { var mod; }
3885  })(this, function (module, exports) {
3886      'use strict';
3887  
3888      var map = typeof Map === "function" ? new Map() : function () {
3889          var keys = [];
3890          var values = [];
3891  
3892          return {
3893              has: function has(key) {
3894                  return keys.indexOf(key) > -1;
3895              },
3896              get: function get(key) {
3897                  return values[keys.indexOf(key)];
3898              },
3899              set: function set(key, value) {
3900                  if (keys.indexOf(key) === -1) {
3901                      keys.push(key);
3902                      values.push(value);
3903                  }
3904              },
3905              delete: function _delete(key) {
3906                  var index = keys.indexOf(key);
3907                  if (index > -1) {
3908                      keys.splice(index, 1);
3909                      values.splice(index, 1);
3910                  }
3911              }
3912          };
3913      }();
3914  
3915      var createEvent = function createEvent(name) {
3916          return new Event(name, { bubbles: true });
3917      };
3918      try {
3919          new Event('test');
3920      } catch (e) {
3921          // IE does not support `new Event()`
3922          createEvent = function createEvent(name) {
3923              var evt = document.createEvent('Event');
3924              evt.initEvent(name, true, false);
3925              return evt;
3926          };
3927      }
3928  
3929  	function assign(ta) {
3930          if (!ta || !ta.nodeName || ta.nodeName !== 'TEXTAREA' || map.has(ta)) return;
3931  
3932          var heightOffset = null;
3933          var clientWidth = null;
3934          var cachedHeight = null;
3935  
3936  		function init() {
3937              var style = window.getComputedStyle(ta, null);
3938  
3939              if (style.resize === 'vertical') {
3940                  ta.style.resize = 'none';
3941              } else if (style.resize === 'both') {
3942                  ta.style.resize = 'horizontal';
3943              }
3944  
3945              if (style.boxSizing === 'content-box') {
3946                  heightOffset = -(parseFloat(style.paddingTop) + parseFloat(style.paddingBottom));
3947              } else {
3948                  heightOffset = parseFloat(style.borderTopWidth) + parseFloat(style.borderBottomWidth);
3949              }
3950              // Fix when a textarea is not on document body and heightOffset is Not a Number
3951              if (isNaN(heightOffset)) {
3952                  heightOffset = 0;
3953              }
3954  
3955              update();
3956          }
3957  
3958  		function changeOverflow(value) {
3959              {
3960                  // Chrome/Safari-specific fix:
3961                  // When the textarea y-overflow is hidden, Chrome/Safari do not reflow the text to account for the space
3962                  // made available by removing the scrollbar. The following forces the necessary text reflow.
3963                  var width = ta.style.width;
3964                  ta.style.width = '0px';
3965                  // Force reflow:
3966                  /* jshint ignore:start */
3967                  ta.offsetWidth;
3968                  /* jshint ignore:end */
3969                  ta.style.width = width;
3970              }
3971  
3972              ta.style.overflowY = value;
3973          }
3974  
3975  		function getParentOverflows(el) {
3976              var arr = [];
3977  
3978              while (el && el.parentNode && el.parentNode instanceof Element) {
3979                  if (el.parentNode.scrollTop) {
3980                      arr.push({
3981                          node: el.parentNode,
3982                          scrollTop: el.parentNode.scrollTop
3983                      });
3984                  }
3985                  el = el.parentNode;
3986              }
3987  
3988              return arr;
3989          }
3990  
3991  		function resize() {
3992              if (ta.scrollHeight === 0) {
3993                  // If the scrollHeight is 0, then the element probably has display:none or is detached from the DOM.
3994                  return;
3995              }
3996  
3997              var overflows = getParentOverflows(ta);
3998              var docTop = document.documentElement && document.documentElement.scrollTop; // Needed for Mobile IE (ticket #240)
3999  
4000              ta.style.height = '';
4001              ta.style.height = ta.scrollHeight + heightOffset + 'px';
4002  
4003              // used to check if an update is actually necessary on window.resize
4004              clientWidth = ta.clientWidth;
4005  
4006              // prevents scroll-position jumping
4007              overflows.forEach(function (el) {
4008                  el.node.scrollTop = el.scrollTop;
4009              });
4010  
4011              if (docTop) {
4012                  document.documentElement.scrollTop = docTop;
4013              }
4014          }
4015  
4016  		function update() {
4017              resize();
4018  
4019              var styleHeight = Math.round(parseFloat(ta.style.height));
4020              var computed = window.getComputedStyle(ta, null);
4021  
4022              // Using offsetHeight as a replacement for computed.height in IE, because IE does not account use of border-box
4023              var actualHeight = computed.boxSizing === 'content-box' ? Math.round(parseFloat(computed.height)) : ta.offsetHeight;
4024  
4025              // The actual height not matching the style height (set via the resize method) indicates that 
4026              // the max-height has been exceeded, in which case the overflow should be allowed.
4027              if (actualHeight < styleHeight) {
4028                  if (computed.overflowY === 'hidden') {
4029                      changeOverflow('scroll');
4030                      resize();
4031                      actualHeight = computed.boxSizing === 'content-box' ? Math.round(parseFloat(window.getComputedStyle(ta, null).height)) : ta.offsetHeight;
4032                  }
4033              } else {
4034                  // Normally keep overflow set to hidden, to avoid flash of scrollbar as the textarea expands.
4035                  if (computed.overflowY !== 'hidden') {
4036                      changeOverflow('hidden');
4037                      resize();
4038                      actualHeight = computed.boxSizing === 'content-box' ? Math.round(parseFloat(window.getComputedStyle(ta, null).height)) : ta.offsetHeight;
4039                  }
4040              }
4041  
4042              if (cachedHeight !== actualHeight) {
4043                  cachedHeight = actualHeight;
4044                  var evt = createEvent('autosize:resized');
4045                  try {
4046                      ta.dispatchEvent(evt);
4047                  } catch (err) {
4048                      // Firefox will throw an error on dispatchEvent for a detached element
4049                      // https://bugzilla.mozilla.org/show_bug.cgi?id=889376
4050                  }
4051              }
4052          }
4053  
4054          var pageResize = function pageResize() {
4055              if (ta.clientWidth !== clientWidth) {
4056                  update();
4057              }
4058          };
4059  
4060          var destroy = function (style) {
4061              window.removeEventListener('resize', pageResize, false);
4062              ta.removeEventListener('input', update, false);
4063              ta.removeEventListener('keyup', update, false);
4064              ta.removeEventListener('autosize:destroy', destroy, false);
4065              ta.removeEventListener('autosize:update', update, false);
4066  
4067              Object.keys(style).forEach(function (key) {
4068                  ta.style[key] = style[key];
4069              });
4070  
4071              map.delete(ta);
4072          }.bind(ta, {
4073              height: ta.style.height,
4074              resize: ta.style.resize,
4075              overflowY: ta.style.overflowY,
4076              overflowX: ta.style.overflowX,
4077              wordWrap: ta.style.wordWrap
4078          });
4079  
4080          ta.addEventListener('autosize:destroy', destroy, false);
4081  
4082          // IE9 does not fire onpropertychange or oninput for deletions,
4083          // so binding to onkeyup to catch most of those events.
4084          // There is no way that I know of to detect something like 'cut' in IE9.
4085          if ('onpropertychange' in ta && 'oninput' in ta) {
4086              ta.addEventListener('keyup', update, false);
4087          }
4088  
4089          window.addEventListener('resize', pageResize, false);
4090          ta.addEventListener('input', update, false);
4091          ta.addEventListener('autosize:update', update, false);
4092          ta.style.overflowX = 'hidden';
4093          ta.style.wordWrap = 'break-word';
4094  
4095          map.set(ta, {
4096              destroy: destroy,
4097              update: update
4098          });
4099  
4100          init();
4101      }
4102  
4103  	function destroy(ta) {
4104          var methods = map.get(ta);
4105          if (methods) {
4106              methods.destroy();
4107          }
4108      }
4109  
4110  	function update(ta) {
4111          var methods = map.get(ta);
4112          if (methods) {
4113              methods.update();
4114          }
4115      }
4116  
4117      var autosize = null;
4118  
4119      // Do nothing in Node.js environment and IE8 (or lower)
4120      if (typeof window === 'undefined' || typeof window.getComputedStyle !== 'function') {
4121          autosize = function autosize(el) {
4122              return el;
4123          };
4124          autosize.destroy = function (el) {
4125              return el;
4126          };
4127          autosize.update = function (el) {
4128              return el;
4129          };
4130      } else {
4131          autosize = function autosize(el, options) {
4132              if (el) {
4133                  Array.prototype.forEach.call(el.length ? el : [el], function (x) {
4134                      return assign(x, options);
4135                  });
4136              }
4137              return el;
4138          };
4139          autosize.destroy = function (el) {
4140              if (el) {
4141                  Array.prototype.forEach.call(el.length ? el : [el], destroy);
4142              }
4143              return el;
4144          };
4145          autosize.update = function (el) {
4146              if (el) {
4147                  Array.prototype.forEach.call(el.length ? el : [el], update);
4148              }
4149              return el;
4150          };
4151      }
4152  
4153      exports.default = autosize;
4154      module.exports = exports['default'];
4155  });
4156  
4157  /***/ }),
4158  
4159  /***/ 4462:
4160  /***/ (function(__unused_webpack_module, exports, __webpack_require__) {
4161  
4162  "use strict";
4163  
4164  var __extends = (this && this.__extends) || (function () {
4165      var extendStatics = Object.setPrototypeOf ||
4166          ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
4167          function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
4168      return function (d, b) {
4169          extendStatics(d, b);
4170          function __() { this.constructor = d; }
4171          d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
4172      };
4173  })();
4174  var __assign = (this && this.__assign) || Object.assign || function(t) {
4175      for (var s, i = 1, n = arguments.length; i < n; i++) {
4176          s = arguments[i];
4177          for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
4178              t[p] = s[p];
4179      }
4180      return t;
4181  };
4182  var __rest = (this && this.__rest) || function (s, e) {
4183      var t = {};
4184      for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
4185          t[p] = s[p];
4186      if (s != null && typeof Object.getOwnPropertySymbols === "function")
4187          for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) if (e.indexOf(p[i]) < 0)
4188              t[p[i]] = s[p[i]];
4189      return t;
4190  };
4191  exports.__esModule = true;
4192  var React = __webpack_require__(1609);
4193  var PropTypes = __webpack_require__(5826);
4194  var autosize = __webpack_require__(4306);
4195  var _getLineHeight = __webpack_require__(461);
4196  var getLineHeight = _getLineHeight;
4197  var RESIZED = "autosize:resized";
4198  /**
4199   * A light replacement for built-in textarea component
4200   * which automaticaly adjusts its height to match the content
4201   */
4202  var TextareaAutosizeClass = /** @class */ (function (_super) {
4203      __extends(TextareaAutosizeClass, _super);
4204      function TextareaAutosizeClass() {
4205          var _this = _super !== null && _super.apply(this, arguments) || this;
4206          _this.state = {
4207              lineHeight: null
4208          };
4209          _this.textarea = null;
4210          _this.onResize = function (e) {
4211              if (_this.props.onResize) {
4212                  _this.props.onResize(e);
4213              }
4214          };
4215          _this.updateLineHeight = function () {
4216              if (_this.textarea) {
4217                  _this.setState({
4218                      lineHeight: getLineHeight(_this.textarea)
4219                  });
4220              }
4221          };
4222          _this.onChange = function (e) {
4223              var onChange = _this.props.onChange;
4224              _this.currentValue = e.currentTarget.value;
4225              onChange && onChange(e);
4226          };
4227          return _this;
4228      }
4229      TextareaAutosizeClass.prototype.componentDidMount = function () {
4230          var _this = this;
4231          var _a = this.props, maxRows = _a.maxRows, async = _a.async;
4232          if (typeof maxRows === "number") {
4233              this.updateLineHeight();
4234          }
4235          if (typeof maxRows === "number" || async) {
4236              /*
4237                the defer is needed to:
4238                  - force "autosize" to activate the scrollbar when this.props.maxRows is passed
4239                  - support StyledComponents (see #71)
4240              */
4241              setTimeout(function () { return _this.textarea && autosize(_this.textarea); });
4242          }
4243          else {
4244              this.textarea && autosize(this.textarea);
4245          }
4246          if (this.textarea) {
4247              this.textarea.addEventListener(RESIZED, this.onResize);
4248          }
4249      };
4250      TextareaAutosizeClass.prototype.componentWillUnmount = function () {
4251          if (this.textarea) {
4252              this.textarea.removeEventListener(RESIZED, this.onResize);
4253              autosize.destroy(this.textarea);
4254          }
4255      };
4256      TextareaAutosizeClass.prototype.render = function () {
4257          var _this = this;
4258          var _a = this, _b = _a.props, onResize = _b.onResize, maxRows = _b.maxRows, onChange = _b.onChange, style = _b.style, innerRef = _b.innerRef, children = _b.children, props = __rest(_b, ["onResize", "maxRows", "onChange", "style", "innerRef", "children"]), lineHeight = _a.state.lineHeight;
4259          var maxHeight = maxRows && lineHeight ? lineHeight * maxRows : null;
4260          return (React.createElement("textarea", __assign({}, props, { onChange: this.onChange, style: maxHeight ? __assign({}, style, { maxHeight: maxHeight }) : style, ref: function (element) {
4261                  _this.textarea = element;
4262                  if (typeof _this.props.innerRef === 'function') {
4263                      _this.props.innerRef(element);
4264                  }
4265                  else if (_this.props.innerRef) {
4266                      _this.props.innerRef.current = element;
4267                  }
4268              } }), children));
4269      };
4270      TextareaAutosizeClass.prototype.componentDidUpdate = function () {
4271          this.textarea && autosize.update(this.textarea);
4272      };
4273      TextareaAutosizeClass.defaultProps = {
4274          rows: 1,
4275          async: false
4276      };
4277      TextareaAutosizeClass.propTypes = {
4278          rows: PropTypes.number,
4279          maxRows: PropTypes.number,
4280          onResize: PropTypes.func,
4281          innerRef: PropTypes.any,
4282          async: PropTypes.bool
4283      };
4284      return TextareaAutosizeClass;
4285  }(React.Component));
4286  exports.TextareaAutosize = React.forwardRef(function (props, ref) {
4287      return React.createElement(TextareaAutosizeClass, __assign({}, props, { innerRef: ref }));
4288  });
4289  
4290  
4291  /***/ }),
4292  
4293  /***/ 4725:
4294  /***/ ((module) => {
4295  
4296  function stringifyNode(node, custom) {
4297    var type = node.type;
4298    var value = node.value;
4299    var buf;
4300    var customResult;
4301  
4302    if (custom && (customResult = custom(node)) !== undefined) {
4303      return customResult;
4304    } else if (type === "word" || type === "space") {
4305      return value;
4306    } else if (type === "string") {
4307      buf = node.quote || "";
4308      return buf + value + (node.unclosed ? "" : buf);
4309    } else if (type === "comment") {
4310      return "/*" + value + (node.unclosed ? "" : "*/");
4311    } else if (type === "div") {
4312      return (node.before || "") + value + (node.after || "");
4313    } else if (Array.isArray(node.nodes)) {
4314      buf = stringify(node.nodes, custom);
4315      if (type !== "function") {
4316        return buf;
4317      }
4318      return (
4319        value +
4320        "(" +
4321        (node.before || "") +
4322        buf +
4323        (node.after || "") +
4324        (node.unclosed ? "" : ")")
4325      );
4326    }
4327    return value;
4328  }
4329  
4330  function stringify(nodes, custom) {
4331    var result, i;
4332  
4333    if (Array.isArray(nodes)) {
4334      result = "";
4335      for (i = nodes.length - 1; ~i; i -= 1) {
4336        result = stringifyNode(nodes[i], custom) + result;
4337      }
4338      return result;
4339    }
4340    return stringifyNode(nodes, custom);
4341  }
4342  
4343  module.exports = stringify;
4344  
4345  
4346  /***/ }),
4347  
4348  /***/ 5042:
4349  /***/ ((module) => {
4350  
4351  // This alphabet uses `A-Za-z0-9_-` symbols.
4352  // The order of characters is optimized for better gzip and brotli compression.
4353  // References to the same file (works both for gzip and brotli):
4354  // `'use`, `andom`, and `rict'`
4355  // References to the brotli default dictionary:
4356  // `-26T`, `1983`, `40px`, `75px`, `bush`, `jack`, `mind`, `very`, and `wolf`
4357  let urlAlphabet =
4358    'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict'
4359  
4360  let customAlphabet = (alphabet, defaultSize = 21) => {
4361    return (size = defaultSize) => {
4362      let id = ''
4363      // A compact alternative for `for (var i = 0; i < step; i++)`.
4364      let i = size | 0
4365      while (i--) {
4366        // `| 0` is more compact and faster than `Math.floor()`.
4367        id += alphabet[(Math.random() * alphabet.length) | 0]
4368      }
4369      return id
4370    }
4371  }
4372  
4373  let nanoid = (size = 21) => {
4374    let id = ''
4375    // A compact alternative for `for (var i = 0; i < step; i++)`.
4376    let i = size | 0
4377    while (i--) {
4378      // `| 0` is more compact and faster than `Math.floor()`.
4379      id += urlAlphabet[(Math.random() * 64) | 0]
4380    }
4381    return id
4382  }
4383  
4384  module.exports = { nanoid, customAlphabet }
4385  
4386  
4387  /***/ }),
4388  
4389  /***/ 5215:
4390  /***/ ((module) => {
4391  
4392  "use strict";
4393  
4394  
4395  // do not edit .js files directly - edit src/index.jst
4396  
4397  
4398  
4399  module.exports = function equal(a, b) {
4400    if (a === b) return true;
4401  
4402    if (a && b && typeof a == 'object' && typeof b == 'object') {
4403      if (a.constructor !== b.constructor) return false;
4404  
4405      var length, i, keys;
4406      if (Array.isArray(a)) {
4407        length = a.length;
4408        if (length != b.length) return false;
4409        for (i = length; i-- !== 0;)
4410          if (!equal(a[i], b[i])) return false;
4411        return true;
4412      }
4413  
4414  
4415  
4416      if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;
4417      if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf();
4418      if (a.toString !== Object.prototype.toString) return a.toString() === b.toString();
4419  
4420      keys = Object.keys(a);
4421      length = keys.length;
4422      if (length !== Object.keys(b).length) return false;
4423  
4424      for (i = length; i-- !== 0;)
4425        if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;
4426  
4427      for (i = length; i-- !== 0;) {
4428        var key = keys[i];
4429  
4430        if (!equal(a[key], b[key])) return false;
4431      }
4432  
4433      return true;
4434    }
4435  
4436    // true if both NaN, false otherwise
4437    return a!==a && b!==b;
4438  };
4439  
4440  
4441  /***/ }),
4442  
4443  /***/ 5380:
4444  /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
4445  
4446  "use strict";
4447  
4448  
4449  let { nanoid } = __webpack_require__(5042)
4450  let { isAbsolute, resolve } = __webpack_require__(197)
4451  let { SourceMapConsumer, SourceMapGenerator } = __webpack_require__(1866)
4452  let { fileURLToPath, pathToFileURL } = __webpack_require__(2739)
4453  
4454  let CssSyntaxError = __webpack_require__(356)
4455  let PreviousMap = __webpack_require__(5696)
4456  let terminalHighlight = __webpack_require__(9746)
4457  
4458  let fromOffsetCache = Symbol('fromOffsetCache')
4459  
4460  let sourceMapAvailable = Boolean(SourceMapConsumer && SourceMapGenerator)
4461  let pathAvailable = Boolean(resolve && isAbsolute)
4462  
4463  class Input {
4464    get from() {
4465      return this.file || this.id
4466    }
4467  
4468    constructor(css, opts = {}) {
4469      if (
4470        css === null ||
4471        typeof css === 'undefined' ||
4472        (typeof css === 'object' && !css.toString)
4473      ) {
4474        throw new Error(`PostCSS received $css} instead of CSS string`)
4475      }
4476  
4477      this.css = css.toString()
4478  
4479      if (this.css[0] === '\uFEFF' || this.css[0] === '\uFFFE') {
4480        this.hasBOM = true
4481        this.css = this.css.slice(1)
4482      } else {
4483        this.hasBOM = false
4484      }
4485  
4486      this.document = this.css
4487      if (opts.document) this.document = opts.document.toString()
4488  
4489      if (opts.from) {
4490        if (
4491          !pathAvailable ||
4492          /^\w+:\/\//.test(opts.from) ||
4493          isAbsolute(opts.from)
4494        ) {
4495          this.file = opts.from
4496        } else {
4497          this.file = resolve(opts.from)
4498        }
4499      }
4500  
4501      if (pathAvailable && sourceMapAvailable) {
4502        let map = new PreviousMap(this.css, opts)
4503        if (map.text) {
4504          this.map = map
4505          let file = map.consumer().file
4506          if (!this.file && file) this.file = this.mapResolve(file)
4507        }
4508      }
4509  
4510      if (!this.file) {
4511        this.id = '<input css ' + nanoid(6) + '>'
4512      }
4513      if (this.map) this.map.file = this.from
4514    }
4515  
4516    error(message, line, column, opts = {}) {
4517      let endColumn, endLine, result
4518  
4519      if (line && typeof line === 'object') {
4520        let start = line
4521        let end = column
4522        if (typeof start.offset === 'number') {
4523          let pos = this.fromOffset(start.offset)
4524          line = pos.line
4525          column = pos.col
4526        } else {
4527          line = start.line
4528          column = start.column
4529        }
4530        if (typeof end.offset === 'number') {
4531          let pos = this.fromOffset(end.offset)
4532          endLine = pos.line
4533          endColumn = pos.col
4534        } else {
4535          endLine = end.line
4536          endColumn = end.column
4537        }
4538      } else if (!column) {
4539        let pos = this.fromOffset(line)
4540        line = pos.line
4541        column = pos.col
4542      }
4543  
4544      let origin = this.origin(line, column, endLine, endColumn)
4545      if (origin) {
4546        result = new CssSyntaxError(
4547          message,
4548          origin.endLine === undefined
4549            ? origin.line
4550            : { column: origin.column, line: origin.line },
4551          origin.endLine === undefined
4552            ? origin.column
4553            : { column: origin.endColumn, line: origin.endLine },
4554          origin.source,
4555          origin.file,
4556          opts.plugin
4557        )
4558      } else {
4559        result = new CssSyntaxError(
4560          message,
4561          endLine === undefined ? line : { column, line },
4562          endLine === undefined ? column : { column: endColumn, line: endLine },
4563          this.css,
4564          this.file,
4565          opts.plugin
4566        )
4567      }
4568  
4569      result.input = { column, endColumn, endLine, line, source: this.css }
4570      if (this.file) {
4571        if (pathToFileURL) {
4572          result.input.url = pathToFileURL(this.file).toString()
4573        }
4574        result.input.file = this.file
4575      }
4576  
4577      return result
4578    }
4579  
4580    fromOffset(offset) {
4581      let lastLine, lineToIndex
4582      if (!this[fromOffsetCache]) {
4583        let lines = this.css.split('\n')
4584        lineToIndex = new Array(lines.length)
4585        let prevIndex = 0
4586  
4587        for (let i = 0, l = lines.length; i < l; i++) {
4588          lineToIndex[i] = prevIndex
4589          prevIndex += lines[i].length + 1
4590        }
4591  
4592        this[fromOffsetCache] = lineToIndex
4593      } else {
4594        lineToIndex = this[fromOffsetCache]
4595      }
4596      lastLine = lineToIndex[lineToIndex.length - 1]
4597  
4598      let min = 0
4599      if (offset >= lastLine) {
4600        min = lineToIndex.length - 1
4601      } else {
4602        let max = lineToIndex.length - 2
4603        let mid
4604        while (min < max) {
4605          mid = min + ((max - min) >> 1)
4606          if (offset < lineToIndex[mid]) {
4607            max = mid - 1
4608          } else if (offset >= lineToIndex[mid + 1]) {
4609            min = mid + 1
4610          } else {
4611            min = mid
4612            break
4613          }
4614        }
4615      }
4616      return {
4617        col: offset - lineToIndex[min] + 1,
4618        line: min + 1
4619      }
4620    }
4621  
4622    mapResolve(file) {
4623      if (/^\w+:\/\//.test(file)) {
4624        return file
4625      }
4626      return resolve(this.map.consumer().sourceRoot || this.map.root || '.', file)
4627    }
4628  
4629    origin(line, column, endLine, endColumn) {
4630      if (!this.map) return false
4631      let consumer = this.map.consumer()
4632  
4633      let from = consumer.originalPositionFor({ column, line })
4634      if (!from.source) return false
4635  
4636      let to
4637      if (typeof endLine === 'number') {
4638        to = consumer.originalPositionFor({ column: endColumn, line: endLine })
4639      }
4640  
4641      let fromUrl
4642  
4643      if (isAbsolute(from.source)) {
4644        fromUrl = pathToFileURL(from.source)
4645      } else {
4646        fromUrl = new URL(
4647          from.source,
4648          this.map.consumer().sourceRoot || pathToFileURL(this.map.mapFile)
4649        )
4650      }
4651  
4652      let result = {
4653        column: from.column,
4654        endColumn: to && to.column,
4655        endLine: to && to.line,
4656        line: from.line,
4657        url: fromUrl.toString()
4658      }
4659  
4660      if (fromUrl.protocol === 'file:') {
4661        if (fileURLToPath) {
4662          result.file = fileURLToPath(fromUrl)
4663        } else {
4664          /* c8 ignore next 2 */
4665          throw new Error(`file: protocol is not available in this PostCSS build`)
4666        }
4667      }
4668  
4669      let source = consumer.sourceContentFor(from.source)
4670      if (source) result.source = source
4671  
4672      return result
4673    }
4674  
4675    toJSON() {
4676      let json = {}
4677      for (let name of ['hasBOM', 'css', 'file', 'id']) {
4678        if (this[name] != null) {
4679          json[name] = this[name]
4680        }
4681      }
4682      if (this.map) {
4683        json.map = { ...this.map }
4684        if (json.map.consumerCache) {
4685          json.map.consumerCache = undefined
4686        }
4687      }
4688      return json
4689    }
4690  }
4691  
4692  module.exports = Input
4693  Input.default = Input
4694  
4695  if (terminalHighlight && terminalHighlight.registerInput) {
4696    terminalHighlight.registerInput(Input)
4697  }
4698  
4699  
4700  /***/ }),
4701  
4702  /***/ 5404:
4703  /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
4704  
4705  const CSSValueParser = __webpack_require__(1544)
4706  
4707  /**
4708   * @type {import('postcss').PluginCreator}
4709   */
4710  module.exports = (opts) => {
4711  
4712    const DEFAULTS = {
4713      skipHostRelativeUrls: true,
4714    }
4715    const config = Object.assign(DEFAULTS, opts)
4716  
4717    return {
4718      postcssPlugin: 'rebaseUrl',
4719  
4720      Declaration(decl) {
4721        // The faster way to find Declaration node
4722        const parsedValue = CSSValueParser(decl.value)
4723  
4724        let valueChanged = false
4725        parsedValue.walk(node => {
4726          if (node.type !== 'function' || node.value !== 'url') {
4727            return
4728          }
4729  
4730          const urlVal = node.nodes[0].value
4731  
4732          // bases relative URLs with rootUrl
4733          const basedUrl = new URL(urlVal, opts.rootUrl)
4734  
4735          // skip host-relative, already normalized URLs (e.g. `/images/image.jpg`, without `..`s)
4736          if ((basedUrl.pathname === urlVal) && config.skipHostRelativeUrls) {
4737            return false // skip this value
4738          }
4739  
4740          node.nodes[0].value = basedUrl.toString()
4741          valueChanged = true
4742  
4743          return false // do not walk deeper
4744        })
4745  
4746        if (valueChanged) {
4747          decl.value = CSSValueParser.stringify(parsedValue)
4748        }
4749  
4750      }
4751    }
4752  }
4753  
4754  module.exports.postcss = true
4755  
4756  
4757  /***/ }),
4758  
4759  /***/ 5417:
4760  /***/ ((__unused_webpack_module, exports) => {
4761  
4762  "use strict";
4763  /*istanbul ignore start*/
4764  
4765  
4766  Object.defineProperty(exports, "__esModule", ({
4767    value: true
4768  }));
4769  exports["default"] = Diff;
4770  
4771  /*istanbul ignore end*/
4772  function Diff() {}
4773  
4774  Diff.prototype = {
4775    /*istanbul ignore start*/
4776  
4777    /*istanbul ignore end*/
4778    diff: function diff(oldString, newString) {
4779      /*istanbul ignore start*/
4780      var
4781      /*istanbul ignore end*/
4782      options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
4783      var callback = options.callback;
4784  
4785      if (typeof options === 'function') {
4786        callback = options;
4787        options = {};
4788      }
4789  
4790      this.options = options;
4791      var self = this;
4792  
4793      function done(value) {
4794        if (callback) {
4795          setTimeout(function () {
4796            callback(undefined, value);
4797          }, 0);
4798          return true;
4799        } else {
4800          return value;
4801        }
4802      } // Allow subclasses to massage the input prior to running
4803  
4804  
4805      oldString = this.castInput(oldString);
4806      newString = this.castInput(newString);
4807      oldString = this.removeEmpty(this.tokenize(oldString));
4808      newString = this.removeEmpty(this.tokenize(newString));
4809      var newLen = newString.length,
4810          oldLen = oldString.length;
4811      var editLength = 1;
4812      var maxEditLength = newLen + oldLen;
4813      var bestPath = [{
4814        newPos: -1,
4815        components: []
4816      }]; // Seed editLength = 0, i.e. the content starts with the same values
4817  
4818      var oldPos = this.extractCommon(bestPath[0], newString, oldString, 0);
4819  
4820      if (bestPath[0].newPos + 1 >= newLen && oldPos + 1 >= oldLen) {
4821        // Identity per the equality and tokenizer
4822        return done([{
4823          value: this.join(newString),
4824          count: newString.length
4825        }]);
4826      } // Main worker method. checks all permutations of a given edit length for acceptance.
4827  
4828  
4829      function execEditLength() {
4830        for (var diagonalPath = -1 * editLength; diagonalPath <= editLength; diagonalPath += 2) {
4831          var basePath =
4832          /*istanbul ignore start*/
4833          void 0
4834          /*istanbul ignore end*/
4835          ;
4836  
4837          var addPath = bestPath[diagonalPath - 1],
4838              removePath = bestPath[diagonalPath + 1],
4839              _oldPos = (removePath ? removePath.newPos : 0) - diagonalPath;
4840  
4841          if (addPath) {
4842            // No one else is going to attempt to use this value, clear it
4843            bestPath[diagonalPath - 1] = undefined;
4844          }
4845  
4846          var canAdd = addPath && addPath.newPos + 1 < newLen,
4847              canRemove = removePath && 0 <= _oldPos && _oldPos < oldLen;
4848  
4849          if (!canAdd && !canRemove) {
4850            // If this path is a terminal then prune
4851            bestPath[diagonalPath] = undefined;
4852            continue;
4853          } // Select the diagonal that we want to branch from. We select the prior
4854          // path whose position in the new string is the farthest from the origin
4855          // and does not pass the bounds of the diff graph
4856  
4857  
4858          if (!canAdd || canRemove && addPath.newPos < removePath.newPos) {
4859            basePath = clonePath(removePath);
4860            self.pushComponent(basePath.components, undefined, true);
4861          } else {
4862            basePath = addPath; // No need to clone, we've pulled it from the list
4863  
4864            basePath.newPos++;
4865            self.pushComponent(basePath.components, true, undefined);
4866          }
4867  
4868          _oldPos = self.extractCommon(basePath, newString, oldString, diagonalPath); // If we have hit the end of both strings, then we are done
4869  
4870          if (basePath.newPos + 1 >= newLen && _oldPos + 1 >= oldLen) {
4871            return done(buildValues(self, basePath.components, newString, oldString, self.useLongestToken));
4872          } else {
4873            // Otherwise track this path as a potential candidate and continue.
4874            bestPath[diagonalPath] = basePath;
4875          }
4876        }
4877  
4878        editLength++;
4879      } // Performs the length of edit iteration. Is a bit fugly as this has to support the
4880      // sync and async mode which is never fun. Loops over execEditLength until a value
4881      // is produced.
4882  
4883  
4884      if (callback) {
4885        (function exec() {
4886          setTimeout(function () {
4887            // This should not happen, but we want to be safe.
4888  
4889            /* istanbul ignore next */
4890            if (editLength > maxEditLength) {
4891              return callback();
4892            }
4893  
4894            if (!execEditLength()) {
4895              exec();
4896            }
4897          }, 0);
4898        })();
4899      } else {
4900        while (editLength <= maxEditLength) {
4901          var ret = execEditLength();
4902  
4903          if (ret) {
4904            return ret;
4905          }
4906        }
4907      }
4908    },
4909  
4910    /*istanbul ignore start*/
4911  
4912    /*istanbul ignore end*/
4913    pushComponent: function pushComponent(components, added, removed) {
4914      var last = components[components.length - 1];
4915  
4916      if (last && last.added === added && last.removed === removed) {
4917        // We need to clone here as the component clone operation is just
4918        // as shallow array clone
4919        components[components.length - 1] = {
4920          count: last.count + 1,
4921          added: added,
4922          removed: removed
4923        };
4924      } else {
4925        components.push({
4926          count: 1,
4927          added: added,
4928          removed: removed
4929        });
4930      }
4931    },
4932  
4933    /*istanbul ignore start*/
4934  
4935    /*istanbul ignore end*/
4936    extractCommon: function extractCommon(basePath, newString, oldString, diagonalPath) {
4937      var newLen = newString.length,
4938          oldLen = oldString.length,
4939          newPos = basePath.newPos,
4940          oldPos = newPos - diagonalPath,
4941          commonCount = 0;
4942  
4943      while (newPos + 1 < newLen && oldPos + 1 < oldLen && this.equals(newString[newPos + 1], oldString[oldPos + 1])) {
4944        newPos++;
4945        oldPos++;
4946        commonCount++;
4947      }
4948  
4949      if (commonCount) {
4950        basePath.components.push({
4951          count: commonCount
4952        });
4953      }
4954  
4955      basePath.newPos = newPos;
4956      return oldPos;
4957    },
4958  
4959    /*istanbul ignore start*/
4960  
4961    /*istanbul ignore end*/
4962    equals: function equals(left, right) {
4963      if (this.options.comparator) {
4964        return this.options.comparator(left, right);
4965      } else {
4966        return left === right || this.options.ignoreCase && left.toLowerCase() === right.toLowerCase();
4967      }
4968    },
4969  
4970    /*istanbul ignore start*/
4971  
4972    /*istanbul ignore end*/
4973    removeEmpty: function removeEmpty(array) {
4974      var ret = [];
4975  
4976      for (var i = 0; i < array.length; i++) {
4977        if (array[i]) {
4978          ret.push(array[i]);
4979        }
4980      }
4981  
4982      return ret;
4983    },
4984  
4985    /*istanbul ignore start*/
4986  
4987    /*istanbul ignore end*/
4988    castInput: function castInput(value) {
4989      return value;
4990    },
4991  
4992    /*istanbul ignore start*/
4993  
4994    /*istanbul ignore end*/
4995    tokenize: function tokenize(value) {
4996      return value.split('');
4997    },
4998  
4999    /*istanbul ignore start*/
5000  
5001    /*istanbul ignore end*/
5002    join: function join(chars) {
5003      return chars.join('');
5004    }
5005  };
5006  
5007  function buildValues(diff, components, newString, oldString, useLongestToken) {
5008    var componentPos = 0,
5009        componentLen = components.length,
5010        newPos = 0,
5011        oldPos = 0;
5012  
5013    for (; componentPos < componentLen; componentPos++) {
5014      var component = components[componentPos];
5015  
5016      if (!component.removed) {
5017        if (!component.added && useLongestToken) {
5018          var value = newString.slice(newPos, newPos + component.count);
5019          value = value.map(function (value, i) {
5020            var oldValue = oldString[oldPos + i];
5021            return oldValue.length > value.length ? oldValue : value;
5022          });
5023          component.value = diff.join(value);
5024        } else {
5025          component.value = diff.join(newString.slice(newPos, newPos + component.count));
5026        }
5027  
5028        newPos += component.count; // Common case
5029  
5030        if (!component.added) {
5031          oldPos += component.count;
5032        }
5033      } else {
5034        component.value = diff.join(oldString.slice(oldPos, oldPos + component.count));
5035        oldPos += component.count; // Reverse add and remove so removes are output first to match common convention
5036        // The diffing algorithm is tied to add then remove output and this is the simplest
5037        // route to get the desired output with minimal overhead.
5038  
5039        if (componentPos && components[componentPos - 1].added) {
5040          var tmp = components[componentPos - 1];
5041          components[componentPos - 1] = components[componentPos];
5042          components[componentPos] = tmp;
5043        }
5044      }
5045    } // Special case handle for when one terminal is ignored (i.e. whitespace).
5046    // For this case we merge the terminal into the prior string and drop the change.
5047    // This is only available for string mode.
5048  
5049  
5050    var lastComponent = components[componentLen - 1];
5051  
5052    if (componentLen > 1 && typeof lastComponent.value === 'string' && (lastComponent.added || lastComponent.removed) && diff.equals('', lastComponent.value)) {
5053      components[componentLen - 2].value += lastComponent.value;
5054      components.pop();
5055    }
5056  
5057    return components;
5058  }
5059  
5060  function clonePath(path) {
5061    return {
5062      newPos: path.newPos,
5063      components: path.components.slice(0)
5064    };
5065  }
5066  
5067  
5068  /***/ }),
5069  
5070  /***/ 5696:
5071  /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
5072  
5073  "use strict";
5074  
5075  
5076  let { existsSync, readFileSync } = __webpack_require__(9977)
5077  let { dirname, join } = __webpack_require__(197)
5078  let { SourceMapConsumer, SourceMapGenerator } = __webpack_require__(1866)
5079  
5080  function fromBase64(str) {
5081    if (Buffer) {
5082      return Buffer.from(str, 'base64').toString()
5083    } else {
5084      /* c8 ignore next 2 */
5085      return window.atob(str)
5086    }
5087  }
5088  
5089  class PreviousMap {
5090    constructor(css, opts) {
5091      if (opts.map === false) return
5092      this.loadAnnotation(css)
5093      this.inline = this.startWith(this.annotation, 'data:')
5094  
5095      let prev = opts.map ? opts.map.prev : undefined
5096      let text = this.loadMap(opts.from, prev)
5097      if (!this.mapFile && opts.from) {
5098        this.mapFile = opts.from
5099      }
5100      if (this.mapFile) this.root = dirname(this.mapFile)
5101      if (text) this.text = text
5102    }
5103  
5104    consumer() {
5105      if (!this.consumerCache) {
5106        this.consumerCache = new SourceMapConsumer(this.text)
5107      }
5108      return this.consumerCache
5109    }
5110  
5111    decodeInline(text) {
5112      let baseCharsetUri = /^data:application\/json;charset=utf-?8;base64,/
5113      let baseUri = /^data:application\/json;base64,/
5114      let charsetUri = /^data:application\/json;charset=utf-?8,/
5115      let uri = /^data:application\/json,/
5116  
5117      let uriMatch = text.match(charsetUri) || text.match(uri)
5118      if (uriMatch) {
5119        return decodeURIComponent(text.substr(uriMatch[0].length))
5120      }
5121  
5122      let baseUriMatch = text.match(baseCharsetUri) || text.match(baseUri)
5123      if (baseUriMatch) {
5124        return fromBase64(text.substr(baseUriMatch[0].length))
5125      }
5126  
5127      let encoding = text.match(/data:application\/json;([^,]+),/)[1]
5128      throw new Error('Unsupported source map encoding ' + encoding)
5129    }
5130  
5131    getAnnotationURL(sourceMapString) {
5132      return sourceMapString.replace(/^\/\*\s*# sourceMappingURL=/, '').trim()
5133    }
5134  
5135    isMap(map) {
5136      if (typeof map !== 'object') return false
5137      return (
5138        typeof map.mappings === 'string' ||
5139        typeof map._mappings === 'string' ||
5140        Array.isArray(map.sections)
5141      )
5142    }
5143  
5144    loadAnnotation(css) {
5145      let comments = css.match(/\/\*\s*# sourceMappingURL=/g)
5146      if (!comments) return
5147  
5148      // sourceMappingURLs from comments, strings, etc.
5149      let start = css.lastIndexOf(comments.pop())
5150      let end = css.indexOf('*/', start)
5151  
5152      if (start > -1 && end > -1) {
5153        // Locate the last sourceMappingURL to avoid pickin
5154        this.annotation = this.getAnnotationURL(css.substring(start, end))
5155      }
5156    }
5157  
5158    loadFile(path) {
5159      this.root = dirname(path)
5160      if (existsSync(path)) {
5161        this.mapFile = path
5162        return readFileSync(path, 'utf-8').toString().trim()
5163      }
5164    }
5165  
5166    loadMap(file, prev) {
5167      if (prev === false) return false
5168  
5169      if (prev) {
5170        if (typeof prev === 'string') {
5171          return prev
5172        } else if (typeof prev === 'function') {
5173          let prevPath = prev(file)
5174          if (prevPath) {
5175            let map = this.loadFile(prevPath)
5176            if (!map) {
5177              throw new Error(
5178                'Unable to load previous source map: ' + prevPath.toString()
5179              )
5180            }
5181            return map
5182          }
5183        } else if (prev instanceof SourceMapConsumer) {
5184          return SourceMapGenerator.fromSourceMap(prev).toString()
5185        } else if (prev instanceof SourceMapGenerator) {
5186          return prev.toString()
5187        } else if (this.isMap(prev)) {
5188          return JSON.stringify(prev)
5189        } else {
5190          throw new Error(
5191            'Unsupported previous source map format: ' + prev.toString()
5192          )
5193        }
5194      } else if (this.inline) {
5195        return this.decodeInline(this.annotation)
5196      } else if (this.annotation) {
5197        let map = this.annotation
5198        if (file) map = join(dirname(file), map)
5199        return this.loadFile(map)
5200      }
5201    }
5202  
5203    startWith(string, start) {
5204      if (!string) return false
5205      return string.substr(0, start.length) === start
5206    }
5207  
5208    withContent() {
5209      return !!(
5210        this.consumer().sourcesContent &&
5211        this.consumer().sourcesContent.length > 0
5212      )
5213    }
5214  }
5215  
5216  module.exports = PreviousMap
5217  PreviousMap.default = PreviousMap
5218  
5219  
5220  /***/ }),
5221  
5222  /***/ 5776:
5223  /***/ ((module) => {
5224  
5225  "use strict";
5226  
5227  
5228  class Warning {
5229    constructor(text, opts = {}) {
5230      this.type = 'warning'
5231      this.text = text
5232  
5233      if (opts.node && opts.node.source) {
5234        let range = opts.node.rangeBy(opts)
5235        this.line = range.start.line
5236        this.column = range.start.column
5237        this.endLine = range.end.line
5238        this.endColumn = range.end.column
5239      }
5240  
5241      for (let opt in opts) this[opt] = opts[opt]
5242    }
5243  
5244    toString() {
5245      if (this.node) {
5246        return this.node.error(this.text, {
5247          index: this.index,
5248          plugin: this.plugin,
5249          word: this.word
5250        }).message
5251      }
5252  
5253      if (this.plugin) {
5254        return this.plugin + ': ' + this.text
5255      }
5256  
5257      return this.text
5258    }
5259  }
5260  
5261  module.exports = Warning
5262  Warning.default = Warning
5263  
5264  
5265  /***/ }),
5266  
5267  /***/ 5826:
5268  /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
5269  
5270  /**
5271   * Copyright (c) 2013-present, Facebook, Inc.
5272   *
5273   * This source code is licensed under the MIT license found in the
5274   * LICENSE file in the root directory of this source tree.
5275   */
5276  
5277  if (false) { var throwOnDirectAccess, ReactIs; } else {
5278    // By explicitly using `prop-types` you are opting into new production behavior.
5279    // http://fb.me/prop-types-in-prod
5280    module.exports = __webpack_require__(628)();
5281  }
5282  
5283  
5284  /***/ }),
5285  
5286  /***/ 6109:
5287  /***/ ((module) => {
5288  
5289  // This code has been refactored for 140 bytes
5290  // You can see the original here: https://github.com/twolfson/computedStyle/blob/04cd1da2e30fa45844f95f5cb1ac898e9b9ef050/lib/computedStyle.js
5291  var computedStyle = function (el, prop, getComputedStyle) {
5292    getComputedStyle = window.getComputedStyle;
5293  
5294    // In one fell swoop
5295    return (
5296      // If we have getComputedStyle
5297      getComputedStyle ?
5298        // Query it
5299        // TODO: From CSS-Query notes, we might need (node, null) for FF
5300        getComputedStyle(el) :
5301  
5302      // Otherwise, we are in IE and use currentStyle
5303        el.currentStyle
5304    )[
5305      // Switch to camelCase for CSSOM
5306      // DEV: Grabbed from jQuery
5307      // https://github.com/jquery/jquery/blob/1.9-stable/src/css.js#L191-L194
5308      // https://github.com/jquery/jquery/blob/1.9-stable/src/core.js#L593-L597
5309      prop.replace(/-(\w)/gi, function (word, letter) {
5310        return letter.toUpperCase();
5311      })
5312    ];
5313  };
5314  
5315  module.exports = computedStyle;
5316  
5317  
5318  /***/ }),
5319  
5320  /***/ 6589:
5321  /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
5322  
5323  "use strict";
5324  
5325  
5326  let Node = __webpack_require__(7490)
5327  
5328  class Comment extends Node {
5329    constructor(defaults) {
5330      super(defaults)
5331      this.type = 'comment'
5332    }
5333  }
5334  
5335  module.exports = Comment
5336  Comment.default = Comment
5337  
5338  
5339  /***/ }),
5340  
5341  /***/ 7191:
5342  /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
5343  
5344  "use strict";
5345  /**
5346   * Copyright (c) 2015, Facebook, Inc.
5347   * All rights reserved.
5348   *
5349   * This source code is licensed under the BSD-style license found in the
5350   * LICENSE file in the root directory of this source tree. An additional grant
5351   * of patent rights can be found in the PATENTS file in the same directory.
5352   *
5353   * @providesModule normalizeWheel
5354   * @typechecks
5355   */
5356  
5357  
5358  
5359  var UserAgent_DEPRECATED = __webpack_require__(2213);
5360  
5361  var isEventSupported = __webpack_require__(1087);
5362  
5363  
5364  // Reasonable defaults
5365  var PIXEL_STEP  = 10;
5366  var LINE_HEIGHT = 40;
5367  var PAGE_HEIGHT = 800;
5368  
5369  /**
5370   * Mouse wheel (and 2-finger trackpad) support on the web sucks.  It is
5371   * complicated, thus this doc is long and (hopefully) detailed enough to answer
5372   * your questions.
5373   *
5374   * If you need to react to the mouse wheel in a predictable way, this code is
5375   * like your bestest friend. * hugs *
5376   *
5377   * As of today, there are 4 DOM event types you can listen to:
5378   *
5379   *   'wheel'                -- Chrome(31+), FF(17+), IE(9+)
5380   *   'mousewheel'           -- Chrome, IE(6+), Opera, Safari
5381   *   'MozMousePixelScroll'  -- FF(3.5 only!) (2010-2013) -- don't bother!
5382   *   'DOMMouseScroll'       -- FF(0.9.7+) since 2003
5383   *
5384   * So what to do?  The is the best:
5385   *
5386   *   normalizeWheel.getEventType();
5387   *
5388   * In your event callback, use this code to get sane interpretation of the
5389   * deltas.  This code will return an object with properties:
5390   *
5391   *   spinX   -- normalized spin speed (use for zoom) - x plane
5392   *   spinY   -- " - y plane
5393   *   pixelX  -- normalized distance (to pixels) - x plane
5394   *   pixelY  -- " - y plane
5395   *
5396   * Wheel values are provided by the browser assuming you are using the wheel to
5397   * scroll a web page by a number of lines or pixels (or pages).  Values can vary
5398   * significantly on different platforms and browsers, forgetting that you can
5399   * scroll at different speeds.  Some devices (like trackpads) emit more events
5400   * at smaller increments with fine granularity, and some emit massive jumps with
5401   * linear speed or acceleration.
5402   *
5403   * This code does its best to normalize the deltas for you:
5404   *
5405   *   - spin is trying to normalize how far the wheel was spun (or trackpad
5406   *     dragged).  This is super useful for zoom support where you want to
5407   *     throw away the chunky scroll steps on the PC and make those equal to
5408   *     the slow and smooth tiny steps on the Mac. Key data: This code tries to
5409   *     resolve a single slow step on a wheel to 1.
5410   *
5411   *   - pixel is normalizing the desired scroll delta in pixel units.  You'll
5412   *     get the crazy differences between browsers, but at least it'll be in
5413   *     pixels!
5414   *
5415   *   - positive value indicates scrolling DOWN/RIGHT, negative UP/LEFT.  This
5416   *     should translate to positive value zooming IN, negative zooming OUT.
5417   *     This matches the newer 'wheel' event.
5418   *
5419   * Why are there spinX, spinY (or pixels)?
5420   *
5421   *   - spinX is a 2-finger side drag on the trackpad, and a shift + wheel turn
5422   *     with a mouse.  It results in side-scrolling in the browser by default.
5423   *
5424   *   - spinY is what you expect -- it's the classic axis of a mouse wheel.
5425   *
5426   *   - I dropped spinZ/pixelZ.  It is supported by the DOM 3 'wheel' event and
5427   *     probably is by browsers in conjunction with fancy 3D controllers .. but
5428   *     you know.
5429   *
5430   * Implementation info:
5431   *
5432   * Examples of 'wheel' event if you scroll slowly (down) by one step with an
5433   * average mouse:
5434   *
5435   *   OS X + Chrome  (mouse)     -    4   pixel delta  (wheelDelta -120)
5436   *   OS X + Safari  (mouse)     -  N/A   pixel delta  (wheelDelta  -12)
5437   *   OS X + Firefox (mouse)     -    0.1 line  delta  (wheelDelta  N/A)
5438   *   Win8 + Chrome  (mouse)     -  100   pixel delta  (wheelDelta -120)
5439   *   Win8 + Firefox (mouse)     -    3   line  delta  (wheelDelta -120)
5440   *
5441   * On the trackpad:
5442   *
5443   *   OS X + Chrome  (trackpad)  -    2   pixel delta  (wheelDelta   -6)
5444   *   OS X + Firefox (trackpad)  -    1   pixel delta  (wheelDelta  N/A)
5445   *
5446   * On other/older browsers.. it's more complicated as there can be multiple and
5447   * also missing delta values.
5448   *
5449   * The 'wheel' event is more standard:
5450   *
5451   * http://www.w3.org/TR/DOM-Level-3-Events/#events-wheelevents
5452   *
5453   * The basics is that it includes a unit, deltaMode (pixels, lines, pages), and
5454   * deltaX, deltaY and deltaZ.  Some browsers provide other values to maintain
5455   * backward compatibility with older events.  Those other values help us
5456   * better normalize spin speed.  Example of what the browsers provide:
5457   *
5458   *                          | event.wheelDelta | event.detail
5459   *        ------------------+------------------+--------------
5460   *          Safari v5/OS X  |       -120       |       0
5461   *          Safari v5/Win7  |       -120       |       0
5462   *         Chrome v17/OS X  |       -120       |       0
5463   *         Chrome v17/Win7  |       -120       |       0
5464   *                IE9/Win7  |       -120       |   undefined
5465   *         Firefox v4/OS X  |     undefined    |       1
5466   *         Firefox v4/Win7  |     undefined    |       3
5467   *
5468   */
5469  function normalizeWheel(/*object*/ event) /*object*/ {
5470    var sX = 0, sY = 0,       // spinX, spinY
5471        pX = 0, pY = 0;       // pixelX, pixelY
5472  
5473    // Legacy
5474    if ('detail'      in event) { sY = event.detail; }
5475    if ('wheelDelta'  in event) { sY = -event.wheelDelta / 120; }
5476    if ('wheelDeltaY' in event) { sY = -event.wheelDeltaY / 120; }
5477    if ('wheelDeltaX' in event) { sX = -event.wheelDeltaX / 120; }
5478  
5479    // side scrolling on FF with DOMMouseScroll
5480    if ( 'axis' in event && event.axis === event.HORIZONTAL_AXIS ) {
5481      sX = sY;
5482      sY = 0;
5483    }
5484  
5485    pX = sX * PIXEL_STEP;
5486    pY = sY * PIXEL_STEP;
5487  
5488    if ('deltaY' in event) { pY = event.deltaY; }
5489    if ('deltaX' in event) { pX = event.deltaX; }
5490  
5491    if ((pX || pY) && event.deltaMode) {
5492      if (event.deltaMode == 1) {          // delta in LINE units
5493        pX *= LINE_HEIGHT;
5494        pY *= LINE_HEIGHT;
5495      } else {                             // delta in PAGE units
5496        pX *= PAGE_HEIGHT;
5497        pY *= PAGE_HEIGHT;
5498      }
5499    }
5500  
5501    // Fall-back if spin cannot be determined
5502    if (pX && !sX) { sX = (pX < 1) ? -1 : 1; }
5503    if (pY && !sY) { sY = (pY < 1) ? -1 : 1; }
5504  
5505    return { spinX  : sX,
5506             spinY  : sY,
5507             pixelX : pX,
5508             pixelY : pY };
5509  }
5510  
5511  
5512  /**
5513   * The best combination if you prefer spinX + spinY normalization.  It favors
5514   * the older DOMMouseScroll for Firefox, as FF does not include wheelDelta with
5515   * 'wheel' event, making spin speed determination impossible.
5516   */
5517  normalizeWheel.getEventType = function() /*string*/ {
5518    return (UserAgent_DEPRECATED.firefox())
5519             ? 'DOMMouseScroll'
5520             : (isEventSupported('wheel'))
5521                 ? 'wheel'
5522                 : 'mousewheel';
5523  };
5524  
5525  module.exports = normalizeWheel;
5526  
5527  
5528  /***/ }),
5529  
5530  /***/ 7374:
5531  /***/ ((module) => {
5532  
5533  "use strict";
5534  
5535  
5536  let list = {
5537    comma(string) {
5538      return list.split(string, [','], true)
5539    },
5540  
5541    space(string) {
5542      let spaces = [' ', '\n', '\t']
5543      return list.split(string, spaces)
5544    },
5545  
5546    split(string, separators, last) {
5547      let array = []
5548      let current = ''
5549      let split = false
5550  
5551      let func = 0
5552      let inQuote = false
5553      let prevQuote = ''
5554      let escape = false
5555  
5556      for (let letter of string) {
5557        if (escape) {
5558          escape = false
5559        } else if (letter === '\\') {
5560          escape = true
5561        } else if (inQuote) {
5562          if (letter === prevQuote) {
5563            inQuote = false
5564          }
5565        } else if (letter === '"' || letter === "'") {
5566          inQuote = true
5567          prevQuote = letter
5568        } else if (letter === '(') {
5569          func += 1
5570        } else if (letter === ')') {
5571          if (func > 0) func -= 1
5572        } else if (func === 0) {
5573          if (separators.includes(letter)) split = true
5574        }
5575  
5576        if (split) {
5577          if (current !== '') array.push(current.trim())
5578          current = ''
5579          split = false
5580        } else {
5581          current += letter
5582        }
5583      }
5584  
5585      if (last || current !== '') array.push(current.trim())
5586      return array
5587    }
5588  }
5589  
5590  module.exports = list
5591  list.default = list
5592  
5593  
5594  /***/ }),
5595  
5596  /***/ 7490:
5597  /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
5598  
5599  "use strict";
5600  
5601  
5602  let CssSyntaxError = __webpack_require__(356)
5603  let Stringifier = __webpack_require__(346)
5604  let stringify = __webpack_require__(633)
5605  let { isClean, my } = __webpack_require__(1381)
5606  
5607  function cloneNode(obj, parent) {
5608    let cloned = new obj.constructor()
5609  
5610    for (let i in obj) {
5611      if (!Object.prototype.hasOwnProperty.call(obj, i)) {
5612        /* c8 ignore next 2 */
5613        continue
5614      }
5615      if (i === 'proxyCache') continue
5616      let value = obj[i]
5617      let type = typeof value
5618  
5619      if (i === 'parent' && type === 'object') {
5620        if (parent) cloned[i] = parent
5621      } else if (i === 'source') {
5622        cloned[i] = value
5623      } else if (Array.isArray(value)) {
5624        cloned[i] = value.map(j => cloneNode(j, cloned))
5625      } else {
5626        if (type === 'object' && value !== null) value = cloneNode(value)
5627        cloned[i] = value
5628      }
5629    }
5630  
5631    return cloned
5632  }
5633  
5634  function sourceOffset(inputCSS, position) {
5635    // Not all custom syntaxes support `offset` in `source.start` and `source.end`
5636    if (
5637      position &&
5638      typeof position.offset !== 'undefined'
5639    ) {
5640      return position.offset;
5641    }
5642  
5643    let column = 1
5644    let line = 1
5645    let offset = 0
5646  
5647    for (let i = 0; i < inputCSS.length; i++) {
5648      if (line === position.line && column === position.column) {
5649        offset = i
5650        break
5651      }
5652  
5653      if (inputCSS[i] === '\n') {
5654        column = 1
5655        line += 1
5656      } else {
5657        column += 1
5658      }
5659    }
5660  
5661    return offset
5662  }
5663  
5664  class Node {
5665    get proxyOf() {
5666      return this
5667    }
5668  
5669    constructor(defaults = {}) {
5670      this.raws = {}
5671      this[isClean] = false
5672      this[my] = true
5673  
5674      for (let name in defaults) {
5675        if (name === 'nodes') {
5676          this.nodes = []
5677          for (let node of defaults[name]) {
5678            if (typeof node.clone === 'function') {
5679              this.append(node.clone())
5680            } else {
5681              this.append(node)
5682            }
5683          }
5684        } else {
5685          this[name] = defaults[name]
5686        }
5687      }
5688    }
5689  
5690    addToError(error) {
5691      error.postcssNode = this
5692      if (error.stack && this.source && /\n\s{4}at /.test(error.stack)) {
5693        let s = this.source
5694        error.stack = error.stack.replace(
5695          /\n\s{4}at /,
5696          `$&$s.input.from}:$s.start.line}:$s.start.column}$&`
5697        )
5698      }
5699      return error
5700    }
5701  
5702    after(add) {
5703      this.parent.insertAfter(this, add)
5704      return this
5705    }
5706  
5707    assign(overrides = {}) {
5708      for (let name in overrides) {
5709        this[name] = overrides[name]
5710      }
5711      return this
5712    }
5713  
5714    before(add) {
5715      this.parent.insertBefore(this, add)
5716      return this
5717    }
5718  
5719    cleanRaws(keepBetween) {
5720      delete this.raws.before
5721      delete this.raws.after
5722      if (!keepBetween) delete this.raws.between
5723    }
5724  
5725    clone(overrides = {}) {
5726      let cloned = cloneNode(this)
5727      for (let name in overrides) {
5728        cloned[name] = overrides[name]
5729      }
5730      return cloned
5731    }
5732  
5733    cloneAfter(overrides = {}) {
5734      let cloned = this.clone(overrides)
5735      this.parent.insertAfter(this, cloned)
5736      return cloned
5737    }
5738  
5739    cloneBefore(overrides = {}) {
5740      let cloned = this.clone(overrides)
5741      this.parent.insertBefore(this, cloned)
5742      return cloned
5743    }
5744  
5745    error(message, opts = {}) {
5746      if (this.source) {
5747        let { end, start } = this.rangeBy(opts)
5748        return this.source.input.error(
5749          message,
5750          { column: start.column, line: start.line },
5751          { column: end.column, line: end.line },
5752          opts
5753        )
5754      }
5755      return new CssSyntaxError(message)
5756    }
5757  
5758    getProxyProcessor() {
5759      return {
5760        get(node, prop) {
5761          if (prop === 'proxyOf') {
5762            return node
5763          } else if (prop === 'root') {
5764            return () => node.root().toProxy()
5765          } else {
5766            return node[prop]
5767          }
5768        },
5769  
5770        set(node, prop, value) {
5771          if (node[prop] === value) return true
5772          node[prop] = value
5773          if (
5774            prop === 'prop' ||
5775            prop === 'value' ||
5776            prop === 'name' ||
5777            prop === 'params' ||
5778            prop === 'important' ||
5779            /* c8 ignore next */
5780            prop === 'text'
5781          ) {
5782            node.markDirty()
5783          }
5784          return true
5785        }
5786      }
5787    }
5788  
5789    /* c8 ignore next 3 */
5790    markClean() {
5791      this[isClean] = true
5792    }
5793  
5794    markDirty() {
5795      if (this[isClean]) {
5796        this[isClean] = false
5797        let next = this
5798        while ((next = next.parent)) {
5799          next[isClean] = false
5800        }
5801      }
5802    }
5803  
5804    next() {
5805      if (!this.parent) return undefined
5806      let index = this.parent.index(this)
5807      return this.parent.nodes[index + 1]
5808    }
5809  
5810    positionBy(opts) {
5811      let pos = this.source.start
5812      if (opts.index) {
5813        pos = this.positionInside(opts.index)
5814      } else if (opts.word) {
5815        let inputString = ('document' in this.source.input)
5816          ? this.source.input.document
5817          : this.source.input.css
5818        let stringRepresentation = inputString.slice(
5819          sourceOffset(inputString, this.source.start),
5820          sourceOffset(inputString, this.source.end)
5821        )
5822        let index = stringRepresentation.indexOf(opts.word)
5823        if (index !== -1) pos = this.positionInside(index)
5824      }
5825      return pos
5826    }
5827  
5828    positionInside(index) {
5829      let column = this.source.start.column
5830      let line = this.source.start.line
5831      let inputString = ('document' in this.source.input)
5832        ? this.source.input.document
5833        : this.source.input.css
5834      let offset = sourceOffset(inputString, this.source.start)
5835      let end = offset + index
5836  
5837      for (let i = offset; i < end; i++) {
5838        if (inputString[i] === '\n') {
5839          column = 1
5840          line += 1
5841        } else {
5842          column += 1
5843        }
5844      }
5845  
5846      return { column, line }
5847    }
5848  
5849    prev() {
5850      if (!this.parent) return undefined
5851      let index = this.parent.index(this)
5852      return this.parent.nodes[index - 1]
5853    }
5854  
5855    rangeBy(opts) {
5856      let start = {
5857        column: this.source.start.column,
5858        line: this.source.start.line
5859      }
5860      let end = this.source.end
5861        ? {
5862            column: this.source.end.column + 1,
5863            line: this.source.end.line
5864          }
5865        : {
5866            column: start.column + 1,
5867            line: start.line
5868          }
5869  
5870      if (opts.word) {
5871        let inputString = ('document' in this.source.input)
5872          ? this.source.input.document
5873          : this.source.input.css
5874        let stringRepresentation = inputString.slice(
5875          sourceOffset(inputString, this.source.start),
5876          sourceOffset(inputString, this.source.end)
5877        )
5878        let index = stringRepresentation.indexOf(opts.word)
5879        if (index !== -1) {
5880          start = this.positionInside(index)
5881          end = this.positionInside(
5882            index + opts.word.length,
5883          )
5884        }
5885      } else {
5886        if (opts.start) {
5887          start = {
5888            column: opts.start.column,
5889            line: opts.start.line
5890          }
5891        } else if (opts.index) {
5892          start = this.positionInside(opts.index)
5893        }
5894  
5895        if (opts.end) {
5896          end = {
5897            column: opts.end.column,
5898            line: opts.end.line
5899          }
5900        } else if (typeof opts.endIndex === 'number') {
5901          end = this.positionInside(opts.endIndex)
5902        } else if (opts.index) {
5903          end = this.positionInside(opts.index + 1)
5904        }
5905      }
5906  
5907      if (
5908        end.line < start.line ||
5909        (end.line === start.line && end.column <= start.column)
5910      ) {
5911        end = { column: start.column + 1, line: start.line }
5912      }
5913  
5914      return { end, start }
5915    }
5916  
5917    raw(prop, defaultType) {
5918      let str = new Stringifier()
5919      return str.raw(this, prop, defaultType)
5920    }
5921  
5922    remove() {
5923      if (this.parent) {
5924        this.parent.removeChild(this)
5925      }
5926      this.parent = undefined
5927      return this
5928    }
5929  
5930    replaceWith(...nodes) {
5931      if (this.parent) {
5932        let bookmark = this
5933        let foundSelf = false
5934        for (let node of nodes) {
5935          if (node === this) {
5936            foundSelf = true
5937          } else if (foundSelf) {
5938            this.parent.insertAfter(bookmark, node)
5939            bookmark = node
5940          } else {
5941            this.parent.insertBefore(bookmark, node)
5942          }
5943        }
5944  
5945        if (!foundSelf) {
5946          this.remove()
5947        }
5948      }
5949  
5950      return this
5951    }
5952  
5953    root() {
5954      let result = this
5955      while (result.parent && result.parent.type !== 'document') {
5956        result = result.parent
5957      }
5958      return result
5959    }
5960  
5961    toJSON(_, inputs) {
5962      let fixed = {}
5963      let emitInputs = inputs == null
5964      inputs = inputs || new Map()
5965      let inputsNextIndex = 0
5966  
5967      for (let name in this) {
5968        if (!Object.prototype.hasOwnProperty.call(this, name)) {
5969          /* c8 ignore next 2 */
5970          continue
5971        }
5972        if (name === 'parent' || name === 'proxyCache') continue
5973        let value = this[name]
5974  
5975        if (Array.isArray(value)) {
5976          fixed[name] = value.map(i => {
5977            if (typeof i === 'object' && i.toJSON) {
5978              return i.toJSON(null, inputs)
5979            } else {
5980              return i
5981            }
5982          })
5983        } else if (typeof value === 'object' && value.toJSON) {
5984          fixed[name] = value.toJSON(null, inputs)
5985        } else if (name === 'source') {
5986          let inputId = inputs.get(value.input)
5987          if (inputId == null) {
5988            inputId = inputsNextIndex
5989            inputs.set(value.input, inputsNextIndex)
5990            inputsNextIndex++
5991          }
5992          fixed[name] = {
5993            end: value.end,
5994            inputId,
5995            start: value.start
5996          }
5997        } else {
5998          fixed[name] = value
5999        }
6000      }
6001  
6002      if (emitInputs) {
6003        fixed.inputs = [...inputs.keys()].map(input => input.toJSON())
6004      }
6005  
6006      return fixed
6007    }
6008  
6009    toProxy() {
6010      if (!this.proxyCache) {
6011        this.proxyCache = new Proxy(this, this.getProxyProcessor())
6012      }
6013      return this.proxyCache
6014    }
6015  
6016    toString(stringifier = stringify) {
6017      if (stringifier.stringify) stringifier = stringifier.stringify
6018      let result = ''
6019      stringifier(this, i => {
6020        result += i
6021      })
6022      return result
6023    }
6024  
6025    warn(result, text, opts) {
6026      let data = { node: this }
6027      for (let i in opts) data[i] = opts[i]
6028      return result.warn(text, data)
6029    }
6030  }
6031  
6032  module.exports = Node
6033  Node.default = Node
6034  
6035  
6036  /***/ }),
6037  
6038  /***/ 7520:
6039  /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
6040  
6041  module.exports = __webpack_require__(7191);
6042  
6043  
6044  /***/ }),
6045  
6046  /***/ 7661:
6047  /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
6048  
6049  "use strict";
6050  
6051  
6052  let MapGenerator = __webpack_require__(1670)
6053  let parse = __webpack_require__(4295)
6054  const Result = __webpack_require__(9055)
6055  let stringify = __webpack_require__(633)
6056  let warnOnce = __webpack_require__(3122)
6057  
6058  class NoWorkResult {
6059    get content() {
6060      return this.result.css
6061    }
6062  
6063    get css() {
6064      return this.result.css
6065    }
6066  
6067    get map() {
6068      return this.result.map
6069    }
6070  
6071    get messages() {
6072      return []
6073    }
6074  
6075    get opts() {
6076      return this.result.opts
6077    }
6078  
6079    get processor() {
6080      return this.result.processor
6081    }
6082  
6083    get root() {
6084      if (this._root) {
6085        return this._root
6086      }
6087  
6088      let root
6089      let parser = parse
6090  
6091      try {
6092        root = parser(this._css, this._opts)
6093      } catch (error) {
6094        this.error = error
6095      }
6096  
6097      if (this.error) {
6098        throw this.error
6099      } else {
6100        this._root = root
6101        return root
6102      }
6103    }
6104  
6105    get [Symbol.toStringTag]() {
6106      return 'NoWorkResult'
6107    }
6108  
6109    constructor(processor, css, opts) {
6110      css = css.toString()
6111      this.stringified = false
6112  
6113      this._processor = processor
6114      this._css = css
6115      this._opts = opts
6116      this._map = undefined
6117      let root
6118  
6119      let str = stringify
6120      this.result = new Result(this._processor, root, this._opts)
6121      this.result.css = css
6122  
6123      let self = this
6124      Object.defineProperty(this.result, 'root', {
6125        get() {
6126          return self.root
6127        }
6128      })
6129  
6130      let map = new MapGenerator(str, root, this._opts, css)
6131      if (map.isMap()) {
6132        let [generatedCSS, generatedMap] = map.generate()
6133        if (generatedCSS) {
6134          this.result.css = generatedCSS
6135        }
6136        if (generatedMap) {
6137          this.result.map = generatedMap
6138        }
6139      } else {
6140        map.clearAnnotation()
6141        this.result.css = map.css
6142      }
6143    }
6144  
6145    async() {
6146      if (this.error) return Promise.reject(this.error)
6147      return Promise.resolve(this.result)
6148    }
6149  
6150    catch(onRejected) {
6151      return this.async().catch(onRejected)
6152    }
6153  
6154    finally(onFinally) {
6155      return this.async().then(onFinally, onFinally)
6156    }
6157  
6158    sync() {
6159      if (this.error) throw this.error
6160      return this.result
6161    }
6162  
6163    then(onFulfilled, onRejected) {
6164      if (false) {}
6165  
6166      return this.async().then(onFulfilled, onRejected)
6167    }
6168  
6169    toString() {
6170      return this._css
6171    }
6172  
6173    warnings() {
6174      return []
6175    }
6176  }
6177  
6178  module.exports = NoWorkResult
6179  NoWorkResult.default = NoWorkResult
6180  
6181  
6182  /***/ }),
6183  
6184  /***/ 7734:
6185  /***/ ((module) => {
6186  
6187  "use strict";
6188  
6189  
6190  // do not edit .js files directly - edit src/index.jst
6191  
6192  
6193    var envHasBigInt64Array = typeof BigInt64Array !== 'undefined';
6194  
6195  
6196  module.exports = function equal(a, b) {
6197    if (a === b) return true;
6198  
6199    if (a && b && typeof a == 'object' && typeof b == 'object') {
6200      if (a.constructor !== b.constructor) return false;
6201  
6202      var length, i, keys;
6203      if (Array.isArray(a)) {
6204        length = a.length;
6205        if (length != b.length) return false;
6206        for (i = length; i-- !== 0;)
6207          if (!equal(a[i], b[i])) return false;
6208        return true;
6209      }
6210  
6211  
6212      if ((a instanceof Map) && (b instanceof Map)) {
6213        if (a.size !== b.size) return false;
6214        for (i of a.entries())
6215          if (!b.has(i[0])) return false;
6216        for (i of a.entries())
6217          if (!equal(i[1], b.get(i[0]))) return false;
6218        return true;
6219      }
6220  
6221      if ((a instanceof Set) && (b instanceof Set)) {
6222        if (a.size !== b.size) return false;
6223        for (i of a.entries())
6224          if (!b.has(i[0])) return false;
6225        return true;
6226      }
6227  
6228      if (ArrayBuffer.isView(a) && ArrayBuffer.isView(b)) {
6229        length = a.length;
6230        if (length != b.length) return false;
6231        for (i = length; i-- !== 0;)
6232          if (a[i] !== b[i]) return false;
6233        return true;
6234      }
6235  
6236  
6237      if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;
6238      if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf();
6239      if (a.toString !== Object.prototype.toString) return a.toString() === b.toString();
6240  
6241      keys = Object.keys(a);
6242      length = keys.length;
6243      if (length !== Object.keys(b).length) return false;
6244  
6245      for (i = length; i-- !== 0;)
6246        if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;
6247  
6248      for (i = length; i-- !== 0;) {
6249        var key = keys[i];
6250  
6251        if (!equal(a[key], b[key])) return false;
6252      }
6253  
6254      return true;
6255    }
6256  
6257    // true if both NaN, false otherwise
6258    return a!==a && b!==b;
6259  };
6260  
6261  
6262  /***/ }),
6263  
6264  /***/ 8021:
6265  /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
6266  
6267  "use strict";
6268  var __webpack_unused_export__;
6269  /*istanbul ignore start*/
6270  
6271  
6272  __webpack_unused_export__ = ({
6273    value: true
6274  });
6275  exports.JJ = diffChars;
6276  __webpack_unused_export__ = void 0;
6277  
6278  /*istanbul ignore end*/
6279  var
6280  /*istanbul ignore start*/
6281  _base = _interopRequireDefault(__webpack_require__(5417))
6282  /*istanbul ignore end*/
6283  ;
6284  
6285  /*istanbul ignore start*/ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
6286  
6287  /*istanbul ignore end*/
6288  var characterDiff = new
6289  /*istanbul ignore start*/
6290  _base
6291  /*istanbul ignore end*/
6292  .
6293  /*istanbul ignore start*/
6294  default
6295  /*istanbul ignore end*/
6296  ();
6297  
6298  /*istanbul ignore start*/
6299  __webpack_unused_export__ = characterDiff;
6300  
6301  /*istanbul ignore end*/
6302  function diffChars(oldStr, newStr, options) {
6303    return characterDiff.diff(oldStr, newStr, options);
6304  }
6305  
6306  
6307  /***/ }),
6308  
6309  /***/ 8202:
6310  /***/ ((module) => {
6311  
6312  "use strict";
6313  /**
6314   * Copyright (c) 2015, Facebook, Inc.
6315   * All rights reserved.
6316   *
6317   * This source code is licensed under the BSD-style license found in the
6318   * LICENSE file in the root directory of this source tree. An additional grant
6319   * of patent rights can be found in the PATENTS file in the same directory.
6320   *
6321   * @providesModule ExecutionEnvironment
6322   */
6323  
6324  /*jslint evil: true */
6325  
6326  
6327  
6328  var canUseDOM = !!(
6329    typeof window !== 'undefined' &&
6330    window.document &&
6331    window.document.createElement
6332  );
6333  
6334  /**
6335   * Simple, lightweight module assisting with the detection and context of
6336   * Worker. Helps avoid circular dependencies and allows code to reason about
6337   * whether or not they are in a Worker, even if they never include the main
6338   * `ReactWorker` dependency.
6339   */
6340  var ExecutionEnvironment = {
6341  
6342    canUseDOM: canUseDOM,
6343  
6344    canUseWorkers: typeof Worker !== 'undefined',
6345  
6346    canUseEventListeners:
6347      canUseDOM && !!(window.addEventListener || window.attachEvent),
6348  
6349    canUseViewport: canUseDOM && !!window.screen,
6350  
6351    isInWorker: !canUseDOM // For now, this is true - might change in the future.
6352  
6353  };
6354  
6355  module.exports = ExecutionEnvironment;
6356  
6357  
6358  /***/ }),
6359  
6360  /***/ 8491:
6361  /***/ ((module) => {
6362  
6363  var openParentheses = "(".charCodeAt(0);
6364  var closeParentheses = ")".charCodeAt(0);
6365  var singleQuote = "'".charCodeAt(0);
6366  var doubleQuote = '"'.charCodeAt(0);
6367  var backslash = "\\".charCodeAt(0);
6368  var slash = "/".charCodeAt(0);
6369  var comma = ",".charCodeAt(0);
6370  var colon = ":".charCodeAt(0);
6371  var star = "*".charCodeAt(0);
6372  var uLower = "u".charCodeAt(0);
6373  var uUpper = "U".charCodeAt(0);
6374  var plus = "+".charCodeAt(0);
6375  var isUnicodeRange = /^[a-f0-9?-]+$/i;
6376  
6377  module.exports = function(input) {
6378    var tokens = [];
6379    var value = input;
6380  
6381    var next,
6382      quote,
6383      prev,
6384      token,
6385      escape,
6386      escapePos,
6387      whitespacePos,
6388      parenthesesOpenPos;
6389    var pos = 0;
6390    var code = value.charCodeAt(pos);
6391    var max = value.length;
6392    var stack = [{ nodes: tokens }];
6393    var balanced = 0;
6394    var parent;
6395  
6396    var name = "";
6397    var before = "";
6398    var after = "";
6399  
6400    while (pos < max) {
6401      // Whitespaces
6402      if (code <= 32) {
6403        next = pos;
6404        do {
6405          next += 1;
6406          code = value.charCodeAt(next);
6407        } while (code <= 32);
6408        token = value.slice(pos, next);
6409  
6410        prev = tokens[tokens.length - 1];
6411        if (code === closeParentheses && balanced) {
6412          after = token;
6413        } else if (prev && prev.type === "div") {
6414          prev.after = token;
6415          prev.sourceEndIndex += token.length;
6416        } else if (
6417          code === comma ||
6418          code === colon ||
6419          (code === slash &&
6420            value.charCodeAt(next + 1) !== star &&
6421            (!parent ||
6422              (parent && parent.type === "function" && parent.value !== "calc")))
6423        ) {
6424          before = token;
6425        } else {
6426          tokens.push({
6427            type: "space",
6428            sourceIndex: pos,
6429            sourceEndIndex: next,
6430            value: token
6431          });
6432        }
6433  
6434        pos = next;
6435  
6436        // Quotes
6437      } else if (code === singleQuote || code === doubleQuote) {
6438        next = pos;
6439        quote = code === singleQuote ? "'" : '"';
6440        token = {
6441          type: "string",
6442          sourceIndex: pos,
6443          quote: quote
6444        };
6445        do {
6446          escape = false;
6447          next = value.indexOf(quote, next + 1);
6448          if (~next) {
6449            escapePos = next;
6450            while (value.charCodeAt(escapePos - 1) === backslash) {
6451              escapePos -= 1;
6452              escape = !escape;
6453            }
6454          } else {
6455            value += quote;
6456            next = value.length - 1;
6457            token.unclosed = true;
6458          }
6459        } while (escape);
6460        token.value = value.slice(pos + 1, next);
6461        token.sourceEndIndex = token.unclosed ? next : next + 1;
6462        tokens.push(token);
6463        pos = next + 1;
6464        code = value.charCodeAt(pos);
6465  
6466        // Comments
6467      } else if (code === slash && value.charCodeAt(pos + 1) === star) {
6468        next = value.indexOf("*/", pos);
6469  
6470        token = {
6471          type: "comment",
6472          sourceIndex: pos,
6473          sourceEndIndex: next + 2
6474        };
6475  
6476        if (next === -1) {
6477          token.unclosed = true;
6478          next = value.length;
6479          token.sourceEndIndex = next;
6480        }
6481  
6482        token.value = value.slice(pos + 2, next);
6483        tokens.push(token);
6484  
6485        pos = next + 2;
6486        code = value.charCodeAt(pos);
6487  
6488        // Operation within calc
6489      } else if (
6490        (code === slash || code === star) &&
6491        parent &&
6492        parent.type === "function" &&
6493        parent.value === "calc"
6494      ) {
6495        token = value[pos];
6496        tokens.push({
6497          type: "word",
6498          sourceIndex: pos - before.length,
6499          sourceEndIndex: pos + token.length,
6500          value: token
6501        });
6502        pos += 1;
6503        code = value.charCodeAt(pos);
6504  
6505        // Dividers
6506      } else if (code === slash || code === comma || code === colon) {
6507        token = value[pos];
6508  
6509        tokens.push({
6510          type: "div",
6511          sourceIndex: pos - before.length,
6512          sourceEndIndex: pos + token.length,
6513          value: token,
6514          before: before,
6515          after: ""
6516        });
6517        before = "";
6518  
6519        pos += 1;
6520        code = value.charCodeAt(pos);
6521  
6522        // Open parentheses
6523      } else if (openParentheses === code) {
6524        // Whitespaces after open parentheses
6525        next = pos;
6526        do {
6527          next += 1;
6528          code = value.charCodeAt(next);
6529        } while (code <= 32);
6530        parenthesesOpenPos = pos;
6531        token = {
6532          type: "function",
6533          sourceIndex: pos - name.length,
6534          value: name,
6535          before: value.slice(parenthesesOpenPos + 1, next)
6536        };
6537        pos = next;
6538  
6539        if (name === "url" && code !== singleQuote && code !== doubleQuote) {
6540          next -= 1;
6541          do {
6542            escape = false;
6543            next = value.indexOf(")", next + 1);
6544            if (~next) {
6545              escapePos = next;
6546              while (value.charCodeAt(escapePos - 1) === backslash) {
6547                escapePos -= 1;
6548                escape = !escape;
6549              }
6550            } else {
6551              value += ")";
6552              next = value.length - 1;
6553              token.unclosed = true;
6554            }
6555          } while (escape);
6556          // Whitespaces before closed
6557          whitespacePos = next;
6558          do {
6559            whitespacePos -= 1;
6560            code = value.charCodeAt(whitespacePos);
6561          } while (code <= 32);
6562          if (parenthesesOpenPos < whitespacePos) {
6563            if (pos !== whitespacePos + 1) {
6564              token.nodes = [
6565                {
6566                  type: "word",
6567                  sourceIndex: pos,
6568                  sourceEndIndex: whitespacePos + 1,
6569                  value: value.slice(pos, whitespacePos + 1)
6570                }
6571              ];
6572            } else {
6573              token.nodes = [];
6574            }
6575            if (token.unclosed && whitespacePos + 1 !== next) {
6576              token.after = "";
6577              token.nodes.push({
6578                type: "space",
6579                sourceIndex: whitespacePos + 1,
6580                sourceEndIndex: next,
6581                value: value.slice(whitespacePos + 1, next)
6582              });
6583            } else {
6584              token.after = value.slice(whitespacePos + 1, next);
6585              token.sourceEndIndex = next;
6586            }
6587          } else {
6588            token.after = "";
6589            token.nodes = [];
6590          }
6591          pos = next + 1;
6592          token.sourceEndIndex = token.unclosed ? next : pos;
6593          code = value.charCodeAt(pos);
6594          tokens.push(token);
6595        } else {
6596          balanced += 1;
6597          token.after = "";
6598          token.sourceEndIndex = pos + 1;
6599          tokens.push(token);
6600          stack.push(token);
6601          tokens = token.nodes = [];
6602          parent = token;
6603        }
6604        name = "";
6605  
6606        // Close parentheses
6607      } else if (closeParentheses === code && balanced) {
6608        pos += 1;
6609        code = value.charCodeAt(pos);
6610  
6611        parent.after = after;
6612        parent.sourceEndIndex += after.length;
6613        after = "";
6614        balanced -= 1;
6615        stack[stack.length - 1].sourceEndIndex = pos;
6616        stack.pop();
6617        parent = stack[balanced];
6618        tokens = parent.nodes;
6619  
6620        // Words
6621      } else {
6622        next = pos;
6623        do {
6624          if (code === backslash) {
6625            next += 1;
6626          }
6627          next += 1;
6628          code = value.charCodeAt(next);
6629        } while (
6630          next < max &&
6631          !(
6632            code <= 32 ||
6633            code === singleQuote ||
6634            code === doubleQuote ||
6635            code === comma ||
6636            code === colon ||
6637            code === slash ||
6638            code === openParentheses ||
6639            (code === star &&
6640              parent &&
6641              parent.type === "function" &&
6642              parent.value === "calc") ||
6643            (code === slash &&
6644              parent.type === "function" &&
6645              parent.value === "calc") ||
6646            (code === closeParentheses && balanced)
6647          )
6648        );
6649        token = value.slice(pos, next);
6650  
6651        if (openParentheses === code) {
6652          name = token;
6653        } else if (
6654          (uLower === token.charCodeAt(0) || uUpper === token.charCodeAt(0)) &&
6655          plus === token.charCodeAt(1) &&
6656          isUnicodeRange.test(token.slice(2))
6657        ) {
6658          tokens.push({
6659            type: "unicode-range",
6660            sourceIndex: pos,
6661            sourceEndIndex: next,
6662            value: token
6663          });
6664        } else {
6665          tokens.push({
6666            type: "word",
6667            sourceIndex: pos,
6668            sourceEndIndex: next,
6669            value: token
6670          });
6671        }
6672  
6673        pos = next;
6674      }
6675    }
6676  
6677    for (pos = stack.length - 1; pos; pos -= 1) {
6678      stack[pos].unclosed = true;
6679      stack[pos].sourceEndIndex = value.length;
6680    }
6681  
6682    return stack[0].nodes;
6683  };
6684  
6685  
6686  /***/ }),
6687  
6688  /***/ 9055:
6689  /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
6690  
6691  "use strict";
6692  
6693  
6694  let Warning = __webpack_require__(5776)
6695  
6696  class Result {
6697    get content() {
6698      return this.css
6699    }
6700  
6701    constructor(processor, root, opts) {
6702      this.processor = processor
6703      this.messages = []
6704      this.root = root
6705      this.opts = opts
6706      this.css = undefined
6707      this.map = undefined
6708    }
6709  
6710    toString() {
6711      return this.css
6712    }
6713  
6714    warn(text, opts = {}) {
6715      if (!opts.plugin) {
6716        if (this.lastPlugin && this.lastPlugin.postcssPlugin) {
6717          opts.plugin = this.lastPlugin.postcssPlugin
6718        }
6719      }
6720  
6721      let warning = new Warning(text, opts)
6722      this.messages.push(warning)
6723  
6724      return warning
6725    }
6726  
6727    warnings() {
6728      return this.messages.filter(i => i.type === 'warning')
6729    }
6730  }
6731  
6732  module.exports = Result
6733  Result.default = Result
6734  
6735  
6736  /***/ }),
6737  
6738  /***/ 9434:
6739  /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
6740  
6741  "use strict";
6742  
6743  
6744  let Container = __webpack_require__(683)
6745  
6746  let LazyResult, Processor
6747  
6748  class Root extends Container {
6749    constructor(defaults) {
6750      super(defaults)
6751      this.type = 'root'
6752      if (!this.nodes) this.nodes = []
6753    }
6754  
6755    normalize(child, sample, type) {
6756      let nodes = super.normalize(child)
6757  
6758      if (sample) {
6759        if (type === 'prepend') {
6760          if (this.nodes.length > 1) {
6761            sample.raws.before = this.nodes[1].raws.before
6762          } else {
6763            delete sample.raws.before
6764          }
6765        } else if (this.first !== sample) {
6766          for (let node of nodes) {
6767            node.raws.before = sample.raws.before
6768          }
6769        }
6770      }
6771  
6772      return nodes
6773    }
6774  
6775    removeChild(child, ignore) {
6776      let index = this.index(child)
6777  
6778      if (!ignore && index === 0 && this.nodes.length > 1) {
6779        this.nodes[1].raws.before = this.nodes[index].raws.before
6780      }
6781  
6782      return super.removeChild(child)
6783    }
6784  
6785    toResult(opts = {}) {
6786      let lazy = new LazyResult(new Processor(), this, opts)
6787      return lazy.stringify()
6788    }
6789  }
6790  
6791  Root.registerLazyResult = dependant => {
6792    LazyResult = dependant
6793  }
6794  
6795  Root.registerProcessor = dependant => {
6796    Processor = dependant
6797  }
6798  
6799  module.exports = Root
6800  Root.default = Root
6801  
6802  Container.registerRoot(Root)
6803  
6804  
6805  /***/ }),
6806  
6807  /***/ 9656:
6808  /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
6809  
6810  "use strict";
6811  
6812  
6813  let Document = __webpack_require__(271)
6814  let LazyResult = __webpack_require__(448)
6815  let NoWorkResult = __webpack_require__(7661)
6816  let Root = __webpack_require__(9434)
6817  
6818  class Processor {
6819    constructor(plugins = []) {
6820      this.version = '8.5.3'
6821      this.plugins = this.normalize(plugins)
6822    }
6823  
6824    normalize(plugins) {
6825      let normalized = []
6826      for (let i of plugins) {
6827        if (i.postcss === true) {
6828          i = i()
6829        } else if (i.postcss) {
6830          i = i.postcss
6831        }
6832  
6833        if (typeof i === 'object' && Array.isArray(i.plugins)) {
6834          normalized = normalized.concat(i.plugins)
6835        } else if (typeof i === 'object' && i.postcssPlugin) {
6836          normalized.push(i)
6837        } else if (typeof i === 'function') {
6838          normalized.push(i)
6839        } else if (typeof i === 'object' && (i.parse || i.stringify)) {
6840          if (false) {}
6841        } else {
6842          throw new Error(i + ' is not a PostCSS plugin')
6843        }
6844      }
6845      return normalized
6846    }
6847  
6848    process(css, opts = {}) {
6849      if (
6850        !this.plugins.length &&
6851        !opts.parser &&
6852        !opts.stringifier &&
6853        !opts.syntax
6854      ) {
6855        return new NoWorkResult(this, css, opts)
6856      } else {
6857        return new LazyResult(this, css, opts)
6858      }
6859    }
6860  
6861    use(plugin) {
6862      this.plugins = this.plugins.concat(this.normalize([plugin]))
6863      return this
6864    }
6865  }
6866  
6867  module.exports = Processor
6868  Processor.default = Processor
6869  
6870  Root.registerProcessor(Processor)
6871  Document.registerProcessor(Processor)
6872  
6873  
6874  /***/ }),
6875  
6876  /***/ 9681:
6877  /***/ ((module) => {
6878  
6879  var characterMap = {
6880      "À": "A",
6881      "Á": "A",
6882      "Â": "A",
6883      "Ã": "A",
6884      "Ä": "A",
6885      "Å": "A",
6886      "Ấ": "A",
6887      "Ắ": "A",
6888      "Ẳ": "A",
6889      "Ẵ": "A",
6890      "Ặ": "A",
6891      "Æ": "AE",
6892      "Ầ": "A",
6893      "Ằ": "A",
6894      "Ȃ": "A",
6895      "Ả": "A",
6896      "Ạ": "A",
6897      "Ẩ": "A",
6898      "Ẫ": "A",
6899      "Ậ": "A",
6900      "Ç": "C",
6901      "Ḉ": "C",
6902      "È": "E",
6903      "É": "E",
6904      "Ê": "E",
6905      "Ë": "E",
6906      "Ế": "E",
6907      "Ḗ": "E",
6908      "Ề": "E",
6909      "Ḕ": "E",
6910      "Ḝ": "E",
6911      "Ȇ": "E",
6912      "Ẻ": "E",
6913      "Ẽ": "E",
6914      "Ẹ": "E",
6915      "Ể": "E",
6916      "Ễ": "E",
6917      "Ệ": "E",
6918      "Ì": "I",
6919      "Í": "I",
6920      "Î": "I",
6921      "Ï": "I",
6922      "Ḯ": "I",
6923      "Ȋ": "I",
6924      "Ỉ": "I",
6925      "Ị": "I",
6926      "Ð": "D",
6927      "Ñ": "N",
6928      "Ò": "O",
6929      "Ó": "O",
6930      "Ô": "O",
6931      "Õ": "O",
6932      "Ö": "O",
6933      "Ø": "O",
6934      "Ố": "O",
6935      "Ṍ": "O",
6936      "Ṓ": "O",
6937      "Ȏ": "O",
6938      "Ỏ": "O",
6939      "Ọ": "O",
6940      "Ổ": "O",
6941      "Ỗ": "O",
6942      "Ộ": "O",
6943      "Ờ": "O",
6944      "Ở": "O",
6945      "Ỡ": "O",
6946      "Ớ": "O",
6947      "Ợ": "O",
6948      "Ù": "U",
6949      "Ú": "U",
6950      "Û": "U",
6951      "Ü": "U",
6952      "Ủ": "U",
6953      "Ụ": "U",
6954      "Ử": "U",
6955      "Ữ": "U",
6956      "Ự": "U",
6957      "Ý": "Y",
6958      "à": "a",
6959      "á": "a",
6960      "â": "a",
6961      "ã": "a",
6962      "ä": "a",
6963      "å": "a",
6964      "ấ": "a",
6965      "ắ": "a",
6966      "ẳ": "a",
6967      "ẵ": "a",
6968      "ặ": "a",
6969      "æ": "ae",
6970      "ầ": "a",
6971      "ằ": "a",
6972      "ȃ": "a",
6973      "ả": "a",
6974      "ạ": "a",
6975      "ẩ": "a",
6976      "ẫ": "a",
6977      "ậ": "a",
6978      "ç": "c",
6979      "ḉ": "c",
6980      "è": "e",
6981      "é": "e",
6982      "ê": "e",
6983      "ë": "e",
6984      "ế": "e",
6985      "ḗ": "e",
6986      "ề": "e",
6987      "ḕ": "e",
6988      "ḝ": "e",
6989      "ȇ": "e",
6990      "ẻ": "e",
6991      "ẽ": "e",
6992      "ẹ": "e",
6993      "ể": "e",
6994      "ễ": "e",
6995      "ệ": "e",
6996      "ì": "i",
6997      "í": "i",
6998      "î": "i",
6999      "ï": "i",
7000      "ḯ": "i",
7001      "ȋ": "i",
7002      "ỉ": "i",
7003      "ị": "i",
7004      "ð": "d",
7005      "ñ": "n",
7006      "ò": "o",
7007      "ó": "o",
7008      "ô": "o",
7009      "õ": "o",
7010      "ö": "o",
7011      "ø": "o",
7012      "ố": "o",
7013      "ṍ": "o",
7014      "ṓ": "o",
7015      "ȏ": "o",
7016      "ỏ": "o",
7017      "ọ": "o",
7018      "ổ": "o",
7019      "ỗ": "o",
7020      "ộ": "o",
7021      "ờ": "o",
7022      "ở": "o",
7023      "ỡ": "o",
7024      "ớ": "o",
7025      "ợ": "o",
7026      "ù": "u",
7027      "ú": "u",
7028      "û": "u",
7029      "ü": "u",
7030      "ủ": "u",
7031      "ụ": "u",
7032      "ử": "u",
7033      "ữ": "u",
7034      "ự": "u",
7035      "ý": "y",
7036      "ÿ": "y",
7037      "Ā": "A",
7038      "ā": "a",
7039      "Ă": "A",
7040      "ă": "a",
7041      "Ą": "A",
7042      "ą": "a",
7043      "Ć": "C",
7044      "ć": "c",
7045      "Ĉ": "C",
7046      "ĉ": "c",
7047      "Ċ": "C",
7048      "ċ": "c",
7049      "Č": "C",
7050      "č": "c",
7051      "C̆": "C",
7052      "c̆": "c",
7053      "Ď": "D",
7054      "ď": "d",
7055      "Đ": "D",
7056      "đ": "d",
7057      "Ē": "E",
7058      "ē": "e",
7059      "Ĕ": "E",
7060      "ĕ": "e",
7061      "Ė": "E",
7062      "ė": "e",
7063      "Ę": "E",
7064      "ę": "e",
7065      "Ě": "E",
7066      "ě": "e",
7067      "Ĝ": "G",
7068      "Ǵ": "G",
7069      "ĝ": "g",
7070      "ǵ": "g",
7071      "Ğ": "G",
7072      "ğ": "g",
7073      "Ġ": "G",
7074      "ġ": "g",
7075      "Ģ": "G",
7076      "ģ": "g",
7077      "Ĥ": "H",
7078      "ĥ": "h",
7079      "Ħ": "H",
7080      "ħ": "h",
7081      "Ḫ": "H",
7082      "ḫ": "h",
7083      "Ĩ": "I",
7084      "ĩ": "i",
7085      "Ī": "I",
7086      "ī": "i",
7087      "Ĭ": "I",
7088      "ĭ": "i",
7089      "Į": "I",
7090      "į": "i",
7091      "İ": "I",
7092      "ı": "i",
7093      "IJ": "IJ",
7094      "ij": "ij",
7095      "Ĵ": "J",
7096      "ĵ": "j",
7097      "Ķ": "K",
7098      "ķ": "k",
7099      "Ḱ": "K",
7100      "ḱ": "k",
7101      "K̆": "K",
7102      "k̆": "k",
7103      "Ĺ": "L",
7104      "ĺ": "l",
7105      "Ļ": "L",
7106      "ļ": "l",
7107      "Ľ": "L",
7108      "ľ": "l",
7109      "Ŀ": "L",
7110      "ŀ": "l",
7111      "Ł": "l",
7112      "ł": "l",
7113      "Ḿ": "M",
7114      "ḿ": "m",
7115      "M̆": "M",
7116      "m̆": "m",
7117      "Ń": "N",
7118      "ń": "n",
7119      "Ņ": "N",
7120      "ņ": "n",
7121      "Ň": "N",
7122      "ň": "n",
7123      "ʼn": "n",
7124      "N̆": "N",
7125      "n̆": "n",
7126      "Ō": "O",
7127      "ō": "o",
7128      "Ŏ": "O",
7129      "ŏ": "o",
7130      "Ő": "O",
7131      "ő": "o",
7132      "Œ": "OE",
7133      "œ": "oe",
7134      "P̆": "P",
7135      "p̆": "p",
7136      "Ŕ": "R",
7137      "ŕ": "r",
7138      "Ŗ": "R",
7139      "ŗ": "r",
7140      "Ř": "R",
7141      "ř": "r",
7142      "R̆": "R",
7143      "r̆": "r",
7144      "Ȓ": "R",
7145      "ȓ": "r",
7146      "Ś": "S",
7147      "ś": "s",
7148      "Ŝ": "S",
7149      "ŝ": "s",
7150      "Ş": "S",
7151      "Ș": "S",
7152      "ș": "s",
7153      "ş": "s",
7154      "Š": "S",
7155      "š": "s",
7156      "Ţ": "T",
7157      "ţ": "t",
7158      "ț": "t",
7159      "Ț": "T",
7160      "Ť": "T",
7161      "ť": "t",
7162      "Ŧ": "T",
7163      "ŧ": "t",
7164      "T̆": "T",
7165      "t̆": "t",
7166      "Ũ": "U",
7167      "ũ": "u",
7168      "Ū": "U",
7169      "ū": "u",
7170      "Ŭ": "U",
7171      "ŭ": "u",
7172      "Ů": "U",
7173      "ů": "u",
7174      "Ű": "U",
7175      "ű": "u",
7176      "Ų": "U",
7177      "ų": "u",
7178      "Ȗ": "U",
7179      "ȗ": "u",
7180      "V̆": "V",
7181      "v̆": "v",
7182      "Ŵ": "W",
7183      "ŵ": "w",
7184      "Ẃ": "W",
7185      "ẃ": "w",
7186      "X̆": "X",
7187      "x̆": "x",
7188      "Ŷ": "Y",
7189      "ŷ": "y",
7190      "Ÿ": "Y",
7191      "Y̆": "Y",
7192      "y̆": "y",
7193      "Ź": "Z",
7194      "ź": "z",
7195      "Ż": "Z",
7196      "ż": "z",
7197      "Ž": "Z",
7198      "ž": "z",
7199      "ſ": "s",
7200      "ƒ": "f",
7201      "Ơ": "O",
7202      "ơ": "o",
7203      "Ư": "U",
7204      "ư": "u",
7205      "Ǎ": "A",
7206      "ǎ": "a",
7207      "Ǐ": "I",
7208      "ǐ": "i",
7209      "Ǒ": "O",
7210      "ǒ": "o",
7211      "Ǔ": "U",
7212      "ǔ": "u",
7213      "Ǖ": "U",
7214      "ǖ": "u",
7215      "Ǘ": "U",
7216      "ǘ": "u",
7217      "Ǚ": "U",
7218      "ǚ": "u",
7219      "Ǜ": "U",
7220      "ǜ": "u",
7221      "Ứ": "U",
7222      "ứ": "u",
7223      "Ṹ": "U",
7224      "ṹ": "u",
7225      "Ǻ": "A",
7226      "ǻ": "a",
7227      "Ǽ": "AE",
7228      "ǽ": "ae",
7229      "Ǿ": "O",
7230      "ǿ": "o",
7231      "Þ": "TH",
7232      "þ": "th",
7233      "Ṕ": "P",
7234      "ṕ": "p",
7235      "Ṥ": "S",
7236      "ṥ": "s",
7237      "X́": "X",
7238      "x́": "x",
7239      "Ѓ": "Г",
7240      "ѓ": "г",
7241      "Ќ": "К",
7242      "ќ": "к",
7243      "A̋": "A",
7244      "a̋": "a",
7245      "E̋": "E",
7246      "e̋": "e",
7247      "I̋": "I",
7248      "i̋": "i",
7249      "Ǹ": "N",
7250      "ǹ": "n",
7251      "Ồ": "O",
7252      "ồ": "o",
7253      "Ṑ": "O",
7254      "ṑ": "o",
7255      "Ừ": "U",
7256      "ừ": "u",
7257      "Ẁ": "W",
7258      "ẁ": "w",
7259      "Ỳ": "Y",
7260      "ỳ": "y",
7261      "Ȁ": "A",
7262      "ȁ": "a",
7263      "Ȅ": "E",
7264      "ȅ": "e",
7265      "Ȉ": "I",
7266      "ȉ": "i",
7267      "Ȍ": "O",
7268      "ȍ": "o",
7269      "Ȑ": "R",
7270      "ȑ": "r",
7271      "Ȕ": "U",
7272      "ȕ": "u",
7273      "B̌": "B",
7274      "b̌": "b",
7275      "Č̣": "C",
7276      "č̣": "c",
7277      "Ê̌": "E",
7278      "ê̌": "e",
7279      "F̌": "F",
7280      "f̌": "f",
7281      "Ǧ": "G",
7282      "ǧ": "g",
7283      "Ȟ": "H",
7284      "ȟ": "h",
7285      "J̌": "J",
7286      "ǰ": "j",
7287      "Ǩ": "K",
7288      "ǩ": "k",
7289      "M̌": "M",
7290      "m̌": "m",
7291      "P̌": "P",
7292      "p̌": "p",
7293      "Q̌": "Q",
7294      "q̌": "q",
7295      "Ř̩": "R",
7296      "ř̩": "r",
7297      "Ṧ": "S",
7298      "ṧ": "s",
7299      "V̌": "V",
7300      "v̌": "v",
7301      "W̌": "W",
7302      "w̌": "w",
7303      "X̌": "X",
7304      "x̌": "x",
7305      "Y̌": "Y",
7306      "y̌": "y",
7307      "A̧": "A",
7308      "a̧": "a",
7309      "B̧": "B",
7310      "b̧": "b",
7311      "Ḑ": "D",
7312      "ḑ": "d",
7313      "Ȩ": "E",
7314      "ȩ": "e",
7315      "Ɛ̧": "E",
7316      "ɛ̧": "e",
7317      "Ḩ": "H",
7318      "ḩ": "h",
7319      "I̧": "I",
7320      "i̧": "i",
7321      "Ɨ̧": "I",
7322      "ɨ̧": "i",
7323      "M̧": "M",
7324      "m̧": "m",
7325      "O̧": "O",
7326      "o̧": "o",
7327      "Q̧": "Q",
7328      "q̧": "q",
7329      "U̧": "U",
7330      "u̧": "u",
7331      "X̧": "X",
7332      "x̧": "x",
7333      "Z̧": "Z",
7334      "z̧": "z",
7335      "й":"и",
7336      "Й":"И",
7337      "ё":"е",
7338      "Ё":"Е",
7339  };
7340  
7341  var chars = Object.keys(characterMap).join('|');
7342  var allAccents = new RegExp(chars, 'g');
7343  var firstAccent = new RegExp(chars, '');
7344  
7345  function matcher(match) {
7346      return characterMap[match];
7347  }
7348  
7349  var removeAccents = function(string) {
7350      return string.replace(allAccents, matcher);
7351  };
7352  
7353  var hasAccents = function(string) {
7354      return !!string.match(firstAccent);
7355  };
7356  
7357  module.exports = removeAccents;
7358  module.exports.has = hasAccents;
7359  module.exports.remove = removeAccents;
7360  
7361  
7362  /***/ }),
7363  
7364  /***/ 9746:
7365  /***/ (() => {
7366  
7367  /* (ignored) */
7368  
7369  /***/ }),
7370  
7371  /***/ 9977:
7372  /***/ (() => {
7373  
7374  /* (ignored) */
7375  
7376  /***/ })
7377  
7378  /******/     });
7379  /************************************************************************/
7380  /******/     // The module cache
7381  /******/     var __webpack_module_cache__ = {};
7382  /******/     
7383  /******/     // The require function
7384  /******/ 	function __webpack_require__(moduleId) {
7385  /******/         // Check if module is in cache
7386  /******/         var cachedModule = __webpack_module_cache__[moduleId];
7387  /******/         if (cachedModule !== undefined) {
7388  /******/             return cachedModule.exports;
7389  /******/         }
7390  /******/         // Create a new module (and put it into the cache)
7391  /******/         var module = __webpack_module_cache__[moduleId] = {
7392  /******/             // no module.id needed
7393  /******/             // no module.loaded needed
7394  /******/             exports: {}
7395  /******/         };
7396  /******/     
7397  /******/         // Execute the module function
7398  /******/         __webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);
7399  /******/     
7400  /******/         // Return the exports of the module
7401  /******/         return module.exports;
7402  /******/     }
7403  /******/     
7404  /************************************************************************/
7405  /******/     /* webpack/runtime/compat get default export */
7406  /******/     (() => {
7407  /******/         // getDefaultExport function for compatibility with non-harmony modules
7408  /******/         __webpack_require__.n = (module) => {
7409  /******/             var getter = module && module.__esModule ?
7410  /******/                 () => (module['default']) :
7411  /******/                 () => (module);
7412  /******/             __webpack_require__.d(getter, { a: getter });
7413  /******/             return getter;
7414  /******/         };
7415  /******/     })();
7416  /******/     
7417  /******/     /* webpack/runtime/define property getters */
7418  /******/     (() => {
7419  /******/         // define getter functions for harmony exports
7420  /******/         __webpack_require__.d = (exports, definition) => {
7421  /******/             for(var key in definition) {
7422  /******/                 if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
7423  /******/                     Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
7424  /******/                 }
7425  /******/             }
7426  /******/         };
7427  /******/     })();
7428  /******/     
7429  /******/     /* webpack/runtime/hasOwnProperty shorthand */
7430  /******/     (() => {
7431  /******/         __webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
7432  /******/     })();
7433  /******/     
7434  /******/     /* webpack/runtime/make namespace object */
7435  /******/     (() => {
7436  /******/         // define __esModule on exports
7437  /******/         __webpack_require__.r = (exports) => {
7438  /******/             if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
7439  /******/                 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
7440  /******/             }
7441  /******/             Object.defineProperty(exports, '__esModule', { value: true });
7442  /******/         };
7443  /******/     })();
7444  /******/     
7445  /************************************************************************/
7446  var __webpack_exports__ = {};
7447  // This entry needs to be wrapped in an IIFE because it needs to be in strict mode.
7448  (() => {
7449  "use strict";
7450  // ESM COMPAT FLAG
7451  __webpack_require__.r(__webpack_exports__);
7452  
7453  // EXPORTS
7454  __webpack_require__.d(__webpack_exports__, {
7455    AlignmentControl: () => (/* reexport */ AlignmentControl),
7456    AlignmentToolbar: () => (/* reexport */ AlignmentToolbar),
7457    Autocomplete: () => (/* reexport */ autocomplete),
7458    BlockAlignmentControl: () => (/* reexport */ BlockAlignmentControl),
7459    BlockAlignmentToolbar: () => (/* reexport */ BlockAlignmentToolbar),
7460    BlockBreadcrumb: () => (/* reexport */ block_breadcrumb),
7461    BlockCanvas: () => (/* reexport */ block_canvas),
7462    BlockColorsStyleSelector: () => (/* reexport */ color_style_selector),
7463    BlockContextProvider: () => (/* reexport */ BlockContextProvider),
7464    BlockControls: () => (/* reexport */ block_controls),
7465    BlockEdit: () => (/* reexport */ BlockEdit),
7466    BlockEditorKeyboardShortcuts: () => (/* reexport */ keyboard_shortcuts),
7467    BlockEditorProvider: () => (/* reexport */ components_provider),
7468    BlockFormatControls: () => (/* reexport */ BlockFormatControls),
7469    BlockIcon: () => (/* reexport */ block_icon),
7470    BlockInspector: () => (/* reexport */ block_inspector),
7471    BlockList: () => (/* reexport */ BlockList),
7472    BlockMover: () => (/* reexport */ block_mover),
7473    BlockNavigationDropdown: () => (/* reexport */ dropdown),
7474    BlockPopover: () => (/* reexport */ block_popover),
7475    BlockPreview: () => (/* reexport */ block_preview),
7476    BlockSelectionClearer: () => (/* reexport */ BlockSelectionClearer),
7477    BlockSettingsMenu: () => (/* reexport */ block_settings_menu),
7478    BlockSettingsMenuControls: () => (/* reexport */ block_settings_menu_controls),
7479    BlockStyles: () => (/* reexport */ block_styles),
7480    BlockTitle: () => (/* reexport */ BlockTitle),
7481    BlockToolbar: () => (/* reexport */ BlockToolbar),
7482    BlockTools: () => (/* reexport */ BlockTools),
7483    BlockVerticalAlignmentControl: () => (/* reexport */ BlockVerticalAlignmentControl),
7484    BlockVerticalAlignmentToolbar: () => (/* reexport */ BlockVerticalAlignmentToolbar),
7485    ButtonBlockAppender: () => (/* reexport */ button_block_appender),
7486    ButtonBlockerAppender: () => (/* reexport */ ButtonBlockerAppender),
7487    ColorPalette: () => (/* reexport */ color_palette),
7488    ColorPaletteControl: () => (/* reexport */ ColorPaletteControl),
7489    ContrastChecker: () => (/* reexport */ contrast_checker),
7490    CopyHandler: () => (/* reexport */ CopyHandler),
7491    DefaultBlockAppender: () => (/* reexport */ DefaultBlockAppender),
7492    FontSizePicker: () => (/* reexport */ font_size_picker),
7493    HeadingLevelDropdown: () => (/* reexport */ HeadingLevelDropdown),
7494    HeightControl: () => (/* reexport */ HeightControl),
7495    InnerBlocks: () => (/* reexport */ inner_blocks),
7496    Inserter: () => (/* reexport */ inserter),
7497    InspectorAdvancedControls: () => (/* reexport */ InspectorAdvancedControls),
7498    InspectorControls: () => (/* reexport */ inspector_controls),
7499    JustifyContentControl: () => (/* reexport */ JustifyContentControl),
7500    JustifyToolbar: () => (/* reexport */ JustifyToolbar),
7501    LineHeightControl: () => (/* reexport */ line_height_control),
7502    LinkControl: () => (/* reexport */ link_control),
7503    MediaPlaceholder: () => (/* reexport */ media_placeholder),
7504    MediaReplaceFlow: () => (/* reexport */ media_replace_flow),
7505    MediaUpload: () => (/* reexport */ media_upload),
7506    MediaUploadCheck: () => (/* reexport */ check),
7507    MultiSelectScrollIntoView: () => (/* reexport */ MultiSelectScrollIntoView),
7508    NavigableToolbar: () => (/* reexport */ NavigableToolbar),
7509    ObserveTyping: () => (/* reexport */ observe_typing),
7510    PanelColorSettings: () => (/* reexport */ panel_color_settings),
7511    PlainText: () => (/* reexport */ plain_text),
7512    RecursionProvider: () => (/* reexport */ RecursionProvider),
7513    RichText: () => (/* reexport */ rich_text),
7514    RichTextShortcut: () => (/* reexport */ RichTextShortcut),
7515    RichTextToolbarButton: () => (/* reexport */ RichTextToolbarButton),
7516    SETTINGS_DEFAULTS: () => (/* reexport */ SETTINGS_DEFAULTS),
7517    SkipToSelectedBlock: () => (/* reexport */ SkipToSelectedBlock),
7518    ToolSelector: () => (/* reexport */ tool_selector),
7519    Typewriter: () => (/* reexport */ typewriter),
7520    URLInput: () => (/* reexport */ url_input),
7521    URLInputButton: () => (/* reexport */ url_input_button),
7522    URLPopover: () => (/* reexport */ url_popover),
7523    Warning: () => (/* reexport */ warning),
7524    WritingFlow: () => (/* reexport */ writing_flow),
7525    __experimentalBlockAlignmentMatrixControl: () => (/* reexport */ block_alignment_matrix_control),
7526    __experimentalBlockFullHeightAligmentControl: () => (/* reexport */ block_full_height_alignment_control),
7527    __experimentalBlockPatternSetup: () => (/* reexport */ block_pattern_setup),
7528    __experimentalBlockPatternsList: () => (/* reexport */ block_patterns_list),
7529    __experimentalBlockVariationPicker: () => (/* reexport */ block_variation_picker),
7530    __experimentalBlockVariationTransforms: () => (/* reexport */ block_variation_transforms),
7531    __experimentalBorderRadiusControl: () => (/* reexport */ BorderRadiusControl),
7532    __experimentalColorGradientControl: () => (/* reexport */ control),
7533    __experimentalColorGradientSettingsDropdown: () => (/* reexport */ ColorGradientSettingsDropdown),
7534    __experimentalDateFormatPicker: () => (/* reexport */ DateFormatPicker),
7535    __experimentalDuotoneControl: () => (/* reexport */ duotone_control),
7536    __experimentalFontAppearanceControl: () => (/* reexport */ FontAppearanceControl),
7537    __experimentalFontFamilyControl: () => (/* reexport */ FontFamilyControl),
7538    __experimentalGetBorderClassesAndStyles: () => (/* reexport */ getBorderClassesAndStyles),
7539    __experimentalGetColorClassesAndStyles: () => (/* reexport */ getColorClassesAndStyles),
7540    __experimentalGetElementClassName: () => (/* reexport */ __experimentalGetElementClassName),
7541    __experimentalGetGapCSSValue: () => (/* reexport */ getGapCSSValue),
7542    __experimentalGetGradientClass: () => (/* reexport */ __experimentalGetGradientClass),
7543    __experimentalGetGradientObjectByGradientValue: () => (/* reexport */ __experimentalGetGradientObjectByGradientValue),
7544    __experimentalGetShadowClassesAndStyles: () => (/* reexport */ getShadowClassesAndStyles),
7545    __experimentalGetSpacingClassesAndStyles: () => (/* reexport */ getSpacingClassesAndStyles),
7546    __experimentalImageEditor: () => (/* reexport */ ImageEditor),
7547    __experimentalImageSizeControl: () => (/* reexport */ ImageSizeControl),
7548    __experimentalImageURLInputUI: () => (/* reexport */ ImageURLInputUI),
7549    __experimentalInspectorPopoverHeader: () => (/* reexport */ InspectorPopoverHeader),
7550    __experimentalLetterSpacingControl: () => (/* reexport */ LetterSpacingControl),
7551    __experimentalLibrary: () => (/* reexport */ library),
7552    __experimentalLinkControl: () => (/* reexport */ DeprecatedExperimentalLinkControl),
7553    __experimentalLinkControlSearchInput: () => (/* reexport */ __experimentalLinkControlSearchInput),
7554    __experimentalLinkControlSearchItem: () => (/* reexport */ __experimentalLinkControlSearchItem),
7555    __experimentalLinkControlSearchResults: () => (/* reexport */ __experimentalLinkControlSearchResults),
7556    __experimentalListView: () => (/* reexport */ components_list_view),
7557    __experimentalPanelColorGradientSettings: () => (/* reexport */ panel_color_gradient_settings),
7558    __experimentalPreviewOptions: () => (/* reexport */ PreviewOptions),
7559    __experimentalPublishDateTimePicker: () => (/* reexport */ publish_date_time_picker),
7560    __experimentalRecursionProvider: () => (/* reexport */ DeprecatedExperimentalRecursionProvider),
7561    __experimentalResponsiveBlockControl: () => (/* reexport */ responsive_block_control),
7562    __experimentalSpacingSizesControl: () => (/* reexport */ SpacingSizesControl),
7563    __experimentalTextDecorationControl: () => (/* reexport */ TextDecorationControl),
7564    __experimentalTextTransformControl: () => (/* reexport */ TextTransformControl),
7565    __experimentalUnitControl: () => (/* reexport */ UnitControl),
7566    __experimentalUseBlockOverlayActive: () => (/* reexport */ useBlockOverlayActive),
7567    __experimentalUseBlockPreview: () => (/* reexport */ useBlockPreview),
7568    __experimentalUseBorderProps: () => (/* reexport */ useBorderProps),
7569    __experimentalUseColorProps: () => (/* reexport */ useColorProps),
7570    __experimentalUseCustomSides: () => (/* reexport */ useCustomSides),
7571    __experimentalUseGradient: () => (/* reexport */ __experimentalUseGradient),
7572    __experimentalUseHasRecursion: () => (/* reexport */ DeprecatedExperimentalUseHasRecursion),
7573    __experimentalUseMultipleOriginColorsAndGradients: () => (/* reexport */ useMultipleOriginColorsAndGradients),
7574    __experimentalUseResizeCanvas: () => (/* reexport */ useResizeCanvas),
7575    __experimentalWritingModeControl: () => (/* reexport */ WritingModeControl),
7576    __unstableBlockNameContext: () => (/* reexport */ block_name_context),
7577    __unstableBlockSettingsMenuFirstItem: () => (/* reexport */ block_settings_menu_first_item),
7578    __unstableBlockToolbarLastItem: () => (/* reexport */ block_toolbar_last_item),
7579    __unstableEditorStyles: () => (/* reexport */ editor_styles),
7580    __unstableIframe: () => (/* reexport */ iframe),
7581    __unstableInserterMenuExtension: () => (/* reexport */ inserter_menu_extension),
7582    __unstableRichTextInputEvent: () => (/* reexport */ __unstableRichTextInputEvent),
7583    __unstableUseBlockSelectionClearer: () => (/* reexport */ useBlockSelectionClearer),
7584    __unstableUseClipboardHandler: () => (/* reexport */ __unstableUseClipboardHandler),
7585    __unstableUseMouseMoveTypingReset: () => (/* reexport */ useMouseMoveTypingReset),
7586    __unstableUseTypewriter: () => (/* reexport */ useTypewriter),
7587    __unstableUseTypingObserver: () => (/* reexport */ useTypingObserver),
7588    createCustomColorsHOC: () => (/* reexport */ createCustomColorsHOC),
7589    getColorClassName: () => (/* reexport */ getColorClassName),
7590    getColorObjectByAttributeValues: () => (/* reexport */ getColorObjectByAttributeValues),
7591    getColorObjectByColorValue: () => (/* reexport */ getColorObjectByColorValue),
7592    getComputedFluidTypographyValue: () => (/* reexport */ getComputedFluidTypographyValue),
7593    getCustomValueFromPreset: () => (/* reexport */ getCustomValueFromPreset),
7594    getFontSize: () => (/* reexport */ utils_getFontSize),
7595    getFontSizeClass: () => (/* reexport */ getFontSizeClass),
7596    getFontSizeObjectByValue: () => (/* reexport */ utils_getFontSizeObjectByValue),
7597    getGradientSlugByValue: () => (/* reexport */ getGradientSlugByValue),
7598    getGradientValueBySlug: () => (/* reexport */ getGradientValueBySlug),
7599    getPxFromCssUnit: () => (/* reexport */ get_px_from_css_unit),
7600    getSpacingPresetCssVar: () => (/* reexport */ getSpacingPresetCssVar),
7601    getTypographyClassesAndStyles: () => (/* reexport */ getTypographyClassesAndStyles),
7602    isValueSpacingPreset: () => (/* reexport */ isValueSpacingPreset),
7603    privateApis: () => (/* reexport */ privateApis),
7604    store: () => (/* reexport */ store),
7605    storeConfig: () => (/* reexport */ storeConfig),
7606    transformStyles: () => (/* reexport */ transform_styles),
7607    useBlockBindingsUtils: () => (/* reexport */ useBlockBindingsUtils),
7608    useBlockCommands: () => (/* reexport */ useBlockCommands),
7609    useBlockDisplayInformation: () => (/* reexport */ useBlockDisplayInformation),
7610    useBlockEditContext: () => (/* reexport */ useBlockEditContext),
7611    useBlockEditingMode: () => (/* reexport */ useBlockEditingMode),
7612    useBlockProps: () => (/* reexport */ use_block_props_useBlockProps),
7613    useCachedTruthy: () => (/* reexport */ useCachedTruthy),
7614    useHasRecursion: () => (/* reexport */ useHasRecursion),
7615    useInnerBlocksProps: () => (/* reexport */ useInnerBlocksProps),
7616    useSetting: () => (/* reexport */ useSetting),
7617    useSettings: () => (/* reexport */ use_settings_useSettings),
7618    useStyleOverride: () => (/* reexport */ useStyleOverride),
7619    withColorContext: () => (/* reexport */ with_color_context),
7620    withColors: () => (/* reexport */ withColors),
7621    withFontSizes: () => (/* reexport */ with_font_sizes)
7622  });
7623  
7624  // NAMESPACE OBJECT: ./node_modules/@wordpress/block-editor/build-module/store/private-selectors.js
7625  var private_selectors_namespaceObject = {};
7626  __webpack_require__.r(private_selectors_namespaceObject);
7627  __webpack_require__.d(private_selectors_namespaceObject, {
7628    getAllPatterns: () => (getAllPatterns),
7629    getBlockRemovalRules: () => (getBlockRemovalRules),
7630    getBlockSettings: () => (getBlockSettings),
7631    getBlockStyles: () => (getBlockStyles),
7632    getBlockWithoutAttributes: () => (getBlockWithoutAttributes),
7633    getClosestAllowedInsertionPoint: () => (getClosestAllowedInsertionPoint),
7634    getClosestAllowedInsertionPointForPattern: () => (getClosestAllowedInsertionPointForPattern),
7635    getContentLockingParent: () => (getContentLockingParent),
7636    getEnabledBlockParents: () => (getEnabledBlockParents),
7637    getEnabledClientIdsTree: () => (getEnabledClientIdsTree),
7638    getExpandedBlock: () => (getExpandedBlock),
7639    getInserterMediaCategories: () => (getInserterMediaCategories),
7640    getInsertionPoint: () => (getInsertionPoint),
7641    getLastFocus: () => (getLastFocus),
7642    getLastInsertedBlocksClientIds: () => (getLastInsertedBlocksClientIds),
7643    getOpenedBlockSettingsMenu: () => (getOpenedBlockSettingsMenu),
7644    getParentSectionBlock: () => (getParentSectionBlock),
7645    getPatternBySlug: () => (getPatternBySlug),
7646    getRegisteredInserterMediaCategories: () => (getRegisteredInserterMediaCategories),
7647    getRemovalPromptData: () => (getRemovalPromptData),
7648    getReusableBlocks: () => (getReusableBlocks),
7649    getSectionRootClientId: () => (getSectionRootClientId),
7650    getStyleOverrides: () => (getStyleOverrides),
7651    getTemporarilyEditingAsBlocks: () => (getTemporarilyEditingAsBlocks),
7652    getTemporarilyEditingFocusModeToRevert: () => (getTemporarilyEditingFocusModeToRevert),
7653    getZoomLevel: () => (getZoomLevel),
7654    hasAllowedPatterns: () => (hasAllowedPatterns),
7655    isBlockInterfaceHidden: () => (private_selectors_isBlockInterfaceHidden),
7656    isBlockSubtreeDisabled: () => (isBlockSubtreeDisabled),
7657    isDragging: () => (private_selectors_isDragging),
7658    isSectionBlock: () => (isSectionBlock),
7659    isZoomOut: () => (isZoomOut)
7660  });
7661  
7662  // NAMESPACE OBJECT: ./node_modules/@wordpress/block-editor/build-module/store/selectors.js
7663  var selectors_namespaceObject = {};
7664  __webpack_require__.r(selectors_namespaceObject);
7665  __webpack_require__.d(selectors_namespaceObject, {
7666    __experimentalGetActiveBlockIdByBlockNames: () => (__experimentalGetActiveBlockIdByBlockNames),
7667    __experimentalGetAllowedBlocks: () => (__experimentalGetAllowedBlocks),
7668    __experimentalGetAllowedPatterns: () => (__experimentalGetAllowedPatterns),
7669    __experimentalGetBlockListSettingsForBlocks: () => (__experimentalGetBlockListSettingsForBlocks),
7670    __experimentalGetDirectInsertBlock: () => (__experimentalGetDirectInsertBlock),
7671    __experimentalGetGlobalBlocksByName: () => (__experimentalGetGlobalBlocksByName),
7672    __experimentalGetLastBlockAttributeChanges: () => (__experimentalGetLastBlockAttributeChanges),
7673    __experimentalGetParsedPattern: () => (__experimentalGetParsedPattern),
7674    __experimentalGetPatternTransformItems: () => (__experimentalGetPatternTransformItems),
7675    __experimentalGetPatternsByBlockTypes: () => (__experimentalGetPatternsByBlockTypes),
7676    __experimentalGetReusableBlockTitle: () => (__experimentalGetReusableBlockTitle),
7677    __unstableGetBlockWithoutInnerBlocks: () => (__unstableGetBlockWithoutInnerBlocks),
7678    __unstableGetClientIdWithClientIdsTree: () => (__unstableGetClientIdWithClientIdsTree),
7679    __unstableGetClientIdsTree: () => (__unstableGetClientIdsTree),
7680    __unstableGetContentLockingParent: () => (__unstableGetContentLockingParent),
7681    __unstableGetEditorMode: () => (__unstableGetEditorMode),
7682    __unstableGetSelectedBlocksWithPartialSelection: () => (__unstableGetSelectedBlocksWithPartialSelection),
7683    __unstableGetTemporarilyEditingAsBlocks: () => (__unstableGetTemporarilyEditingAsBlocks),
7684    __unstableGetTemporarilyEditingFocusModeToRevert: () => (__unstableGetTemporarilyEditingFocusModeToRevert),
7685    __unstableGetVisibleBlocks: () => (__unstableGetVisibleBlocks),
7686    __unstableHasActiveBlockOverlayActive: () => (__unstableHasActiveBlockOverlayActive),
7687    __unstableIsFullySelected: () => (__unstableIsFullySelected),
7688    __unstableIsLastBlockChangeIgnored: () => (__unstableIsLastBlockChangeIgnored),
7689    __unstableIsSelectionCollapsed: () => (__unstableIsSelectionCollapsed),
7690    __unstableIsSelectionMergeable: () => (__unstableIsSelectionMergeable),
7691    __unstableIsWithinBlockOverlay: () => (__unstableIsWithinBlockOverlay),
7692    __unstableSelectionHasUnmergeableBlock: () => (__unstableSelectionHasUnmergeableBlock),
7693    areInnerBlocksControlled: () => (areInnerBlocksControlled),
7694    canEditBlock: () => (canEditBlock),
7695    canInsertBlockType: () => (canInsertBlockType),
7696    canInsertBlocks: () => (canInsertBlocks),
7697    canLockBlockType: () => (canLockBlockType),
7698    canMoveBlock: () => (canMoveBlock),
7699    canMoveBlocks: () => (canMoveBlocks),
7700    canRemoveBlock: () => (canRemoveBlock),
7701    canRemoveBlocks: () => (canRemoveBlocks),
7702    didAutomaticChange: () => (didAutomaticChange),
7703    getAdjacentBlockClientId: () => (getAdjacentBlockClientId),
7704    getAllowedBlocks: () => (getAllowedBlocks),
7705    getBlock: () => (getBlock),
7706    getBlockAttributes: () => (getBlockAttributes),
7707    getBlockCount: () => (getBlockCount),
7708    getBlockEditingMode: () => (getBlockEditingMode),
7709    getBlockHierarchyRootClientId: () => (getBlockHierarchyRootClientId),
7710    getBlockIndex: () => (getBlockIndex),
7711    getBlockInsertionPoint: () => (getBlockInsertionPoint),
7712    getBlockListSettings: () => (getBlockListSettings),
7713    getBlockMode: () => (getBlockMode),
7714    getBlockName: () => (getBlockName),
7715    getBlockNamesByClientId: () => (getBlockNamesByClientId),
7716    getBlockOrder: () => (getBlockOrder),
7717    getBlockParents: () => (getBlockParents),
7718    getBlockParentsByBlockName: () => (getBlockParentsByBlockName),
7719    getBlockRootClientId: () => (getBlockRootClientId),
7720    getBlockSelectionEnd: () => (getBlockSelectionEnd),
7721    getBlockSelectionStart: () => (getBlockSelectionStart),
7722    getBlockTransformItems: () => (getBlockTransformItems),
7723    getBlocks: () => (getBlocks),
7724    getBlocksByClientId: () => (getBlocksByClientId),
7725    getBlocksByName: () => (getBlocksByName),
7726    getClientIdsOfDescendants: () => (getClientIdsOfDescendants),
7727    getClientIdsWithDescendants: () => (getClientIdsWithDescendants),
7728    getDirectInsertBlock: () => (getDirectInsertBlock),
7729    getDraggedBlockClientIds: () => (getDraggedBlockClientIds),
7730    getFirstMultiSelectedBlockClientId: () => (getFirstMultiSelectedBlockClientId),
7731    getGlobalBlockCount: () => (getGlobalBlockCount),
7732    getHoveredBlockClientId: () => (getHoveredBlockClientId),
7733    getInserterItems: () => (getInserterItems),
7734    getLastMultiSelectedBlockClientId: () => (getLastMultiSelectedBlockClientId),
7735    getLowestCommonAncestorWithSelectedBlock: () => (getLowestCommonAncestorWithSelectedBlock),
7736    getMultiSelectedBlockClientIds: () => (getMultiSelectedBlockClientIds),
7737    getMultiSelectedBlocks: () => (getMultiSelectedBlocks),
7738    getMultiSelectedBlocksEndClientId: () => (getMultiSelectedBlocksEndClientId),
7739    getMultiSelectedBlocksStartClientId: () => (getMultiSelectedBlocksStartClientId),
7740    getNextBlockClientId: () => (getNextBlockClientId),
7741    getPatternsByBlockTypes: () => (getPatternsByBlockTypes),
7742    getPreviousBlockClientId: () => (getPreviousBlockClientId),
7743    getSelectedBlock: () => (getSelectedBlock),
7744    getSelectedBlockClientId: () => (getSelectedBlockClientId),
7745    getSelectedBlockClientIds: () => (getSelectedBlockClientIds),
7746    getSelectedBlockCount: () => (getSelectedBlockCount),
7747    getSelectedBlocksInitialCaretPosition: () => (getSelectedBlocksInitialCaretPosition),
7748    getSelectionEnd: () => (getSelectionEnd),
7749    getSelectionStart: () => (getSelectionStart),
7750    getSettings: () => (getSettings),
7751    getTemplate: () => (getTemplate),
7752    getTemplateLock: () => (getTemplateLock),
7753    hasBlockMovingClientId: () => (hasBlockMovingClientId),
7754    hasDraggedInnerBlock: () => (hasDraggedInnerBlock),
7755    hasInserterItems: () => (hasInserterItems),
7756    hasMultiSelection: () => (hasMultiSelection),
7757    hasSelectedBlock: () => (hasSelectedBlock),
7758    hasSelectedInnerBlock: () => (hasSelectedInnerBlock),
7759    isAncestorBeingDragged: () => (isAncestorBeingDragged),
7760    isAncestorMultiSelected: () => (isAncestorMultiSelected),
7761    isBlockBeingDragged: () => (isBlockBeingDragged),
7762    isBlockHighlighted: () => (isBlockHighlighted),
7763    isBlockInsertionPointVisible: () => (isBlockInsertionPointVisible),
7764    isBlockMultiSelected: () => (isBlockMultiSelected),
7765    isBlockSelected: () => (isBlockSelected),
7766    isBlockValid: () => (isBlockValid),
7767    isBlockVisible: () => (isBlockVisible),
7768    isBlockWithinSelection: () => (isBlockWithinSelection),
7769    isCaretWithinFormattedText: () => (isCaretWithinFormattedText),
7770    isDraggingBlocks: () => (isDraggingBlocks),
7771    isFirstMultiSelectedBlock: () => (isFirstMultiSelectedBlock),
7772    isGroupable: () => (isGroupable),
7773    isLastBlockChangePersistent: () => (isLastBlockChangePersistent),
7774    isMultiSelecting: () => (selectors_isMultiSelecting),
7775    isNavigationMode: () => (isNavigationMode),
7776    isSelectionEnabled: () => (selectors_isSelectionEnabled),
7777    isTyping: () => (selectors_isTyping),
7778    isUngroupable: () => (isUngroupable),
7779    isValidTemplate: () => (isValidTemplate),
7780    wasBlockJustInserted: () => (wasBlockJustInserted)
7781  });
7782  
7783  // NAMESPACE OBJECT: ./node_modules/@wordpress/block-editor/build-module/store/private-actions.js
7784  var private_actions_namespaceObject = {};
7785  __webpack_require__.r(private_actions_namespaceObject);
7786  __webpack_require__.d(private_actions_namespaceObject, {
7787    __experimentalUpdateSettings: () => (__experimentalUpdateSettings),
7788    clearBlockRemovalPrompt: () => (clearBlockRemovalPrompt),
7789    deleteStyleOverride: () => (deleteStyleOverride),
7790    ensureDefaultBlock: () => (ensureDefaultBlock),
7791    expandBlock: () => (expandBlock),
7792    hideBlockInterface: () => (hideBlockInterface),
7793    modifyContentLockBlock: () => (modifyContentLockBlock),
7794    privateRemoveBlocks: () => (privateRemoveBlocks),
7795    resetZoomLevel: () => (resetZoomLevel),
7796    setBlockRemovalRules: () => (setBlockRemovalRules),
7797    setInsertionPoint: () => (setInsertionPoint),
7798    setLastFocus: () => (setLastFocus),
7799    setOpenedBlockSettingsMenu: () => (setOpenedBlockSettingsMenu),
7800    setStyleOverride: () => (setStyleOverride),
7801    setZoomLevel: () => (setZoomLevel),
7802    showBlockInterface: () => (showBlockInterface),
7803    startDragging: () => (startDragging),
7804    stopDragging: () => (stopDragging),
7805    stopEditingAsBlocks: () => (stopEditingAsBlocks)
7806  });
7807  
7808  // NAMESPACE OBJECT: ./node_modules/@wordpress/block-editor/build-module/store/actions.js
7809  var actions_namespaceObject = {};
7810  __webpack_require__.r(actions_namespaceObject);
7811  __webpack_require__.d(actions_namespaceObject, {
7812    __unstableDeleteSelection: () => (__unstableDeleteSelection),
7813    __unstableExpandSelection: () => (__unstableExpandSelection),
7814    __unstableMarkAutomaticChange: () => (__unstableMarkAutomaticChange),
7815    __unstableMarkLastChangeAsPersistent: () => (__unstableMarkLastChangeAsPersistent),
7816    __unstableMarkNextChangeAsNotPersistent: () => (__unstableMarkNextChangeAsNotPersistent),
7817    __unstableSaveReusableBlock: () => (__unstableSaveReusableBlock),
7818    __unstableSetEditorMode: () => (__unstableSetEditorMode),
7819    __unstableSetTemporarilyEditingAsBlocks: () => (__unstableSetTemporarilyEditingAsBlocks),
7820    __unstableSplitSelection: () => (__unstableSplitSelection),
7821    clearSelectedBlock: () => (clearSelectedBlock),
7822    duplicateBlocks: () => (duplicateBlocks),
7823    enterFormattedText: () => (enterFormattedText),
7824    exitFormattedText: () => (exitFormattedText),
7825    flashBlock: () => (flashBlock),
7826    hideInsertionPoint: () => (hideInsertionPoint),
7827    hoverBlock: () => (hoverBlock),
7828    insertAfterBlock: () => (insertAfterBlock),
7829    insertBeforeBlock: () => (insertBeforeBlock),
7830    insertBlock: () => (insertBlock),
7831    insertBlocks: () => (insertBlocks),
7832    insertDefaultBlock: () => (insertDefaultBlock),
7833    mergeBlocks: () => (mergeBlocks),
7834    moveBlockToPosition: () => (moveBlockToPosition),
7835    moveBlocksDown: () => (moveBlocksDown),
7836    moveBlocksToPosition: () => (moveBlocksToPosition),
7837    moveBlocksUp: () => (moveBlocksUp),
7838    multiSelect: () => (multiSelect),
7839    receiveBlocks: () => (receiveBlocks),
7840    registerInserterMediaCategory: () => (registerInserterMediaCategory),
7841    removeBlock: () => (removeBlock),
7842    removeBlocks: () => (removeBlocks),
7843    replaceBlock: () => (replaceBlock),
7844    replaceBlocks: () => (replaceBlocks),
7845    replaceInnerBlocks: () => (replaceInnerBlocks),
7846    resetBlocks: () => (resetBlocks),
7847    resetSelection: () => (resetSelection),
7848    selectBlock: () => (selectBlock),
7849    selectNextBlock: () => (selectNextBlock),
7850    selectPreviousBlock: () => (selectPreviousBlock),
7851    selectionChange: () => (selectionChange),
7852    setBlockEditingMode: () => (setBlockEditingMode),
7853    setBlockMovingClientId: () => (setBlockMovingClientId),
7854    setBlockVisibility: () => (setBlockVisibility),
7855    setHasControlledInnerBlocks: () => (setHasControlledInnerBlocks),
7856    setNavigationMode: () => (setNavigationMode),
7857    setTemplateValidity: () => (setTemplateValidity),
7858    showInsertionPoint: () => (showInsertionPoint),
7859    startDraggingBlocks: () => (startDraggingBlocks),
7860    startMultiSelect: () => (startMultiSelect),
7861    startTyping: () => (startTyping),
7862    stopDraggingBlocks: () => (stopDraggingBlocks),
7863    stopMultiSelect: () => (stopMultiSelect),
7864    stopTyping: () => (stopTyping),
7865    synchronizeTemplate: () => (synchronizeTemplate),
7866    toggleBlockHighlight: () => (toggleBlockHighlight),
7867    toggleBlockMode: () => (toggleBlockMode),
7868    toggleSelection: () => (toggleSelection),
7869    unsetBlockEditingMode: () => (unsetBlockEditingMode),
7870    updateBlock: () => (updateBlock),
7871    updateBlockAttributes: () => (updateBlockAttributes),
7872    updateBlockListSettings: () => (updateBlockListSettings),
7873    updateSettings: () => (updateSettings),
7874    validateBlocksToTemplate: () => (validateBlocksToTemplate)
7875  });
7876  
7877  // NAMESPACE OBJECT: ./node_modules/@wordpress/upload-media/build-module/store/selectors.js
7878  var store_selectors_namespaceObject = {};
7879  __webpack_require__.r(store_selectors_namespaceObject);
7880  __webpack_require__.d(store_selectors_namespaceObject, {
7881    getItems: () => (getItems),
7882    getSettings: () => (selectors_getSettings),
7883    isUploading: () => (isUploading),
7884    isUploadingById: () => (isUploadingById),
7885    isUploadingByUrl: () => (isUploadingByUrl)
7886  });
7887  
7888  // NAMESPACE OBJECT: ./node_modules/@wordpress/upload-media/build-module/store/private-selectors.js
7889  var store_private_selectors_namespaceObject = {};
7890  __webpack_require__.r(store_private_selectors_namespaceObject);
7891  __webpack_require__.d(store_private_selectors_namespaceObject, {
7892    getAllItems: () => (getAllItems),
7893    getBlobUrls: () => (getBlobUrls),
7894    getItem: () => (getItem),
7895    getPausedUploadForPost: () => (getPausedUploadForPost),
7896    isBatchUploaded: () => (isBatchUploaded),
7897    isPaused: () => (isPaused),
7898    isUploadingToPost: () => (isUploadingToPost)
7899  });
7900  
7901  // NAMESPACE OBJECT: ./node_modules/@wordpress/upload-media/build-module/store/actions.js
7902  var store_actions_namespaceObject = {};
7903  __webpack_require__.r(store_actions_namespaceObject);
7904  __webpack_require__.d(store_actions_namespaceObject, {
7905    addItems: () => (addItems),
7906    cancelItem: () => (cancelItem)
7907  });
7908  
7909  // NAMESPACE OBJECT: ./node_modules/@wordpress/upload-media/build-module/store/private-actions.js
7910  var store_private_actions_namespaceObject = {};
7911  __webpack_require__.r(store_private_actions_namespaceObject);
7912  __webpack_require__.d(store_private_actions_namespaceObject, {
7913    addItem: () => (addItem),
7914    finishOperation: () => (finishOperation),
7915    pauseQueue: () => (pauseQueue),
7916    prepareItem: () => (prepareItem),
7917    processItem: () => (processItem),
7918    removeItem: () => (removeItem),
7919    resumeQueue: () => (resumeQueue),
7920    revokeBlobUrls: () => (revokeBlobUrls),
7921    updateSettings: () => (private_actions_updateSettings),
7922    uploadItem: () => (uploadItem)
7923  });
7924  
7925  // NAMESPACE OBJECT: ./node_modules/@wordpress/block-editor/build-module/components/global-styles/index.js
7926  var global_styles_namespaceObject = {};
7927  __webpack_require__.r(global_styles_namespaceObject);
7928  __webpack_require__.d(global_styles_namespaceObject, {
7929    AdvancedPanel: () => (AdvancedPanel),
7930    BackgroundPanel: () => (background_panel_BackgroundImagePanel),
7931    BorderPanel: () => (BorderPanel),
7932    ColorPanel: () => (ColorPanel),
7933    DimensionsPanel: () => (DimensionsPanel),
7934    FiltersPanel: () => (FiltersPanel),
7935    GlobalStylesContext: () => (GlobalStylesContext),
7936    ImageSettingsPanel: () => (ImageSettingsPanel),
7937    TypographyPanel: () => (TypographyPanel),
7938    areGlobalStyleConfigsEqual: () => (areGlobalStyleConfigsEqual),
7939    getBlockCSSSelector: () => (getBlockCSSSelector),
7940    getBlockSelectors: () => (getBlockSelectors),
7941    getGlobalStylesChanges: () => (getGlobalStylesChanges),
7942    getLayoutStyles: () => (getLayoutStyles),
7943    toStyles: () => (toStyles),
7944    useGlobalSetting: () => (useGlobalSetting),
7945    useGlobalStyle: () => (useGlobalStyle),
7946    useGlobalStylesOutput: () => (useGlobalStylesOutput),
7947    useGlobalStylesOutputWithConfig: () => (useGlobalStylesOutputWithConfig),
7948    useGlobalStylesReset: () => (useGlobalStylesReset),
7949    useHasBackgroundPanel: () => (useHasBackgroundPanel),
7950    useHasBorderPanel: () => (useHasBorderPanel),
7951    useHasBorderPanelControls: () => (useHasBorderPanelControls),
7952    useHasColorPanel: () => (useHasColorPanel),
7953    useHasDimensionsPanel: () => (useHasDimensionsPanel),
7954    useHasFiltersPanel: () => (useHasFiltersPanel),
7955    useHasImageSettingsPanel: () => (useHasImageSettingsPanel),
7956    useHasTypographyPanel: () => (useHasTypographyPanel),
7957    useSettingsForBlockElement: () => (useSettingsForBlockElement)
7958  });
7959  
7960  ;// external ["wp","blocks"]
7961  const external_wp_blocks_namespaceObject = window["wp"]["blocks"];
7962  ;// external ["wp","element"]
7963  const external_wp_element_namespaceObject = window["wp"]["element"];
7964  ;// external ["wp","data"]
7965  const external_wp_data_namespaceObject = window["wp"]["data"];
7966  ;// external ["wp","compose"]
7967  const external_wp_compose_namespaceObject = window["wp"]["compose"];
7968  ;// external ["wp","hooks"]
7969  const external_wp_hooks_namespaceObject = window["wp"]["hooks"];
7970  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-edit/context.js
7971  /**
7972   * WordPress dependencies
7973   */
7974  
7975  const mayDisplayControlsKey = Symbol('mayDisplayControls');
7976  const mayDisplayParentControlsKey = Symbol('mayDisplayParentControls');
7977  const blockEditingModeKey = Symbol('blockEditingMode');
7978  const blockBindingsKey = Symbol('blockBindings');
7979  const isPreviewModeKey = Symbol('isPreviewMode');
7980  const DEFAULT_BLOCK_EDIT_CONTEXT = {
7981    name: '',
7982    isSelected: false
7983  };
7984  const Context = (0,external_wp_element_namespaceObject.createContext)(DEFAULT_BLOCK_EDIT_CONTEXT);
7985  const {
7986    Provider
7987  } = Context;
7988  
7989  
7990  /**
7991   * A hook that returns the block edit context.
7992   *
7993   * @return {Object} Block edit context
7994   */
7995  function useBlockEditContext() {
7996    return (0,external_wp_element_namespaceObject.useContext)(Context);
7997  }
7998  
7999  ;// external ["wp","deprecated"]
8000  const external_wp_deprecated_namespaceObject = window["wp"]["deprecated"];
8001  var external_wp_deprecated_default = /*#__PURE__*/__webpack_require__.n(external_wp_deprecated_namespaceObject);
8002  // EXTERNAL MODULE: ./node_modules/fast-deep-equal/es6/index.js
8003  var es6 = __webpack_require__(7734);
8004  var es6_default = /*#__PURE__*/__webpack_require__.n(es6);
8005  ;// external ["wp","i18n"]
8006  const external_wp_i18n_namespaceObject = window["wp"]["i18n"];
8007  ;// ./node_modules/@wordpress/block-editor/build-module/store/defaults.js
8008  /**
8009   * WordPress dependencies
8010   */
8011  
8012  const PREFERENCES_DEFAULTS = {
8013    insertUsage: {}
8014  };
8015  
8016  /**
8017   * The default editor settings
8018   *
8019   * @typedef {Object} SETTINGS_DEFAULT
8020   * @property {boolean}       alignWide                              Enable/Disable Wide/Full Alignments
8021   * @property {boolean}       supportsLayout                         Enable/disable layouts support in container blocks.
8022   * @property {boolean}       imageEditing                           Image Editing settings set to false to disable.
8023   * @property {Array}         imageSizes                             Available image sizes
8024   * @property {number}        maxWidth                               Max width to constraint resizing
8025   * @property {boolean|Array} allowedBlockTypes                      Allowed block types
8026   * @property {boolean}       hasFixedToolbar                        Whether or not the editor toolbar is fixed
8027   * @property {boolean}       distractionFree                        Whether or not the editor UI is distraction free
8028   * @property {boolean}       focusMode                              Whether the focus mode is enabled or not
8029   * @property {Array}         styles                                 Editor Styles
8030   * @property {boolean}       keepCaretInsideBlock                   Whether caret should move between blocks in edit mode
8031   * @property {string}        bodyPlaceholder                        Empty post placeholder
8032   * @property {string}        titlePlaceholder                       Empty title placeholder
8033   * @property {boolean}       canLockBlocks                          Whether the user can manage Block Lock state
8034   * @property {boolean}       codeEditingEnabled                     Whether or not the user can switch to the code editor
8035   * @property {boolean}       generateAnchors                        Enable/Disable auto anchor generation for Heading blocks
8036   * @property {boolean}       enableOpenverseMediaCategory           Enable/Disable the Openverse media category in the inserter.
8037   * @property {boolean}       clearBlockSelection                    Whether the block editor should clear selection on mousedown when a block is not clicked.
8038   * @property {boolean}       __experimentalCanUserUseUnfilteredHTML Whether the user should be able to use unfiltered HTML or the HTML should be filtered e.g., to remove elements considered insecure like iframes.
8039   * @property {boolean}       __experimentalBlockDirectory           Whether the user has enabled the Block Directory
8040   * @property {Array}         __experimentalBlockPatterns            Array of objects representing the block patterns
8041   * @property {Array}         __experimentalBlockPatternCategories   Array of objects representing the block pattern categories
8042   */
8043  const SETTINGS_DEFAULTS = {
8044    alignWide: false,
8045    supportsLayout: true,
8046    // colors setting is not used anymore now defaults are passed from theme.json on the server and core has its own defaults.
8047    // The setting is only kept for backward compatibility purposes.
8048    colors: [{
8049      name: (0,external_wp_i18n_namespaceObject.__)('Black'),
8050      slug: 'black',
8051      color: '#000000'
8052    }, {
8053      name: (0,external_wp_i18n_namespaceObject.__)('Cyan bluish gray'),
8054      slug: 'cyan-bluish-gray',
8055      color: '#abb8c3'
8056    }, {
8057      name: (0,external_wp_i18n_namespaceObject.__)('White'),
8058      slug: 'white',
8059      color: '#ffffff'
8060    }, {
8061      name: (0,external_wp_i18n_namespaceObject.__)('Pale pink'),
8062      slug: 'pale-pink',
8063      color: '#f78da7'
8064    }, {
8065      name: (0,external_wp_i18n_namespaceObject.__)('Vivid red'),
8066      slug: 'vivid-red',
8067      color: '#cf2e2e'
8068    }, {
8069      name: (0,external_wp_i18n_namespaceObject.__)('Luminous vivid orange'),
8070      slug: 'luminous-vivid-orange',
8071      color: '#ff6900'
8072    }, {
8073      name: (0,external_wp_i18n_namespaceObject.__)('Luminous vivid amber'),
8074      slug: 'luminous-vivid-amber',
8075      color: '#fcb900'
8076    }, {
8077      name: (0,external_wp_i18n_namespaceObject.__)('Light green cyan'),
8078      slug: 'light-green-cyan',
8079      color: '#7bdcb5'
8080    }, {
8081      name: (0,external_wp_i18n_namespaceObject.__)('Vivid green cyan'),
8082      slug: 'vivid-green-cyan',
8083      color: '#00d084'
8084    }, {
8085      name: (0,external_wp_i18n_namespaceObject.__)('Pale cyan blue'),
8086      slug: 'pale-cyan-blue',
8087      color: '#8ed1fc'
8088    }, {
8089      name: (0,external_wp_i18n_namespaceObject.__)('Vivid cyan blue'),
8090      slug: 'vivid-cyan-blue',
8091      color: '#0693e3'
8092    }, {
8093      name: (0,external_wp_i18n_namespaceObject.__)('Vivid purple'),
8094      slug: 'vivid-purple',
8095      color: '#9b51e0'
8096    }],
8097    // fontSizes setting is not used anymore now defaults are passed from theme.json on the server and core has its own defaults.
8098    // The setting is only kept for backward compatibility purposes.
8099    fontSizes: [{
8100      name: (0,external_wp_i18n_namespaceObject._x)('Small', 'font size name'),
8101      size: 13,
8102      slug: 'small'
8103    }, {
8104      name: (0,external_wp_i18n_namespaceObject._x)('Normal', 'font size name'),
8105      size: 16,
8106      slug: 'normal'
8107    }, {
8108      name: (0,external_wp_i18n_namespaceObject._x)('Medium', 'font size name'),
8109      size: 20,
8110      slug: 'medium'
8111    }, {
8112      name: (0,external_wp_i18n_namespaceObject._x)('Large', 'font size name'),
8113      size: 36,
8114      slug: 'large'
8115    }, {
8116      name: (0,external_wp_i18n_namespaceObject._x)('Huge', 'font size name'),
8117      size: 42,
8118      slug: 'huge'
8119    }],
8120    // Image default size slug.
8121    imageDefaultSize: 'large',
8122    imageSizes: [{
8123      slug: 'thumbnail',
8124      name: (0,external_wp_i18n_namespaceObject.__)('Thumbnail')
8125    }, {
8126      slug: 'medium',
8127      name: (0,external_wp_i18n_namespaceObject.__)('Medium')
8128    }, {
8129      slug: 'large',
8130      name: (0,external_wp_i18n_namespaceObject.__)('Large')
8131    }, {
8132      slug: 'full',
8133      name: (0,external_wp_i18n_namespaceObject.__)('Full Size')
8134    }],
8135    // Allow plugin to disable Image Editor if need be.
8136    imageEditing: true,
8137    // This is current max width of the block inner area
8138    // It's used to constraint image resizing and this value could be overridden later by themes
8139    maxWidth: 580,
8140    // Allowed block types for the editor, defaulting to true (all supported).
8141    allowedBlockTypes: true,
8142    // Maximum upload size in bytes allowed for the site.
8143    maxUploadFileSize: 0,
8144    // List of allowed mime types and file extensions.
8145    allowedMimeTypes: null,
8146    // Allows to disable block locking interface.
8147    canLockBlocks: true,
8148    // Allows to disable Openverse media category in the inserter.
8149    enableOpenverseMediaCategory: true,
8150    clearBlockSelection: true,
8151    __experimentalCanUserUseUnfilteredHTML: false,
8152    __experimentalBlockDirectory: false,
8153    __mobileEnablePageTemplates: false,
8154    __experimentalBlockPatterns: [],
8155    __experimentalBlockPatternCategories: [],
8156    isPreviewMode: false,
8157    // These settings will be completely revamped in the future.
8158    // The goal is to evolve this into an API which will instruct
8159    // the block inspector to animate transitions between what it
8160    // displays based on the relationship between the selected block
8161    // and its parent, and only enable it if the parent is controlling
8162    // its children blocks.
8163    blockInspectorAnimation: {
8164      animationParent: 'core/navigation',
8165      'core/navigation': {
8166        enterDirection: 'leftToRight'
8167      },
8168      'core/navigation-submenu': {
8169        enterDirection: 'rightToLeft'
8170      },
8171      'core/navigation-link': {
8172        enterDirection: 'rightToLeft'
8173      },
8174      'core/search': {
8175        enterDirection: 'rightToLeft'
8176      },
8177      'core/social-links': {
8178        enterDirection: 'rightToLeft'
8179      },
8180      'core/page-list': {
8181        enterDirection: 'rightToLeft'
8182      },
8183      'core/spacer': {
8184        enterDirection: 'rightToLeft'
8185      },
8186      'core/home-link': {
8187        enterDirection: 'rightToLeft'
8188      },
8189      'core/site-title': {
8190        enterDirection: 'rightToLeft'
8191      },
8192      'core/site-logo': {
8193        enterDirection: 'rightToLeft'
8194      }
8195    },
8196    generateAnchors: false,
8197    // gradients setting is not used anymore now defaults are passed from theme.json on the server and core has its own defaults.
8198    // The setting is only kept for backward compatibility purposes.
8199    gradients: [{
8200      name: (0,external_wp_i18n_namespaceObject.__)('Vivid cyan blue to vivid purple'),
8201      gradient: 'linear-gradient(135deg,rgba(6,147,227,1) 0%,rgb(155,81,224) 100%)',
8202      slug: 'vivid-cyan-blue-to-vivid-purple'
8203    }, {
8204      name: (0,external_wp_i18n_namespaceObject.__)('Light green cyan to vivid green cyan'),
8205      gradient: 'linear-gradient(135deg,rgb(122,220,180) 0%,rgb(0,208,130) 100%)',
8206      slug: 'light-green-cyan-to-vivid-green-cyan'
8207    }, {
8208      name: (0,external_wp_i18n_namespaceObject.__)('Luminous vivid amber to luminous vivid orange'),
8209      gradient: 'linear-gradient(135deg,rgba(252,185,0,1) 0%,rgba(255,105,0,1) 100%)',
8210      slug: 'luminous-vivid-amber-to-luminous-vivid-orange'
8211    }, {
8212      name: (0,external_wp_i18n_namespaceObject.__)('Luminous vivid orange to vivid red'),
8213      gradient: 'linear-gradient(135deg,rgba(255,105,0,1) 0%,rgb(207,46,46) 100%)',
8214      slug: 'luminous-vivid-orange-to-vivid-red'
8215    }, {
8216      name: (0,external_wp_i18n_namespaceObject.__)('Very light gray to cyan bluish gray'),
8217      gradient: 'linear-gradient(135deg,rgb(238,238,238) 0%,rgb(169,184,195) 100%)',
8218      slug: 'very-light-gray-to-cyan-bluish-gray'
8219    }, {
8220      name: (0,external_wp_i18n_namespaceObject.__)('Cool to warm spectrum'),
8221      gradient: 'linear-gradient(135deg,rgb(74,234,220) 0%,rgb(151,120,209) 20%,rgb(207,42,186) 40%,rgb(238,44,130) 60%,rgb(251,105,98) 80%,rgb(254,248,76) 100%)',
8222      slug: 'cool-to-warm-spectrum'
8223    }, {
8224      name: (0,external_wp_i18n_namespaceObject.__)('Blush light purple'),
8225      gradient: 'linear-gradient(135deg,rgb(255,206,236) 0%,rgb(152,150,240) 100%)',
8226      slug: 'blush-light-purple'
8227    }, {
8228      name: (0,external_wp_i18n_namespaceObject.__)('Blush bordeaux'),
8229      gradient: 'linear-gradient(135deg,rgb(254,205,165) 0%,rgb(254,45,45) 50%,rgb(107,0,62) 100%)',
8230      slug: 'blush-bordeaux'
8231    }, {
8232      name: (0,external_wp_i18n_namespaceObject.__)('Luminous dusk'),
8233      gradient: 'linear-gradient(135deg,rgb(255,203,112) 0%,rgb(199,81,192) 50%,rgb(65,88,208) 100%)',
8234      slug: 'luminous-dusk'
8235    }, {
8236      name: (0,external_wp_i18n_namespaceObject.__)('Pale ocean'),
8237      gradient: 'linear-gradient(135deg,rgb(255,245,203) 0%,rgb(182,227,212) 50%,rgb(51,167,181) 100%)',
8238      slug: 'pale-ocean'
8239    }, {
8240      name: (0,external_wp_i18n_namespaceObject.__)('Electric grass'),
8241      gradient: 'linear-gradient(135deg,rgb(202,248,128) 0%,rgb(113,206,126) 100%)',
8242      slug: 'electric-grass'
8243    }, {
8244      name: (0,external_wp_i18n_namespaceObject.__)('Midnight'),
8245      gradient: 'linear-gradient(135deg,rgb(2,3,129) 0%,rgb(40,116,252) 100%)',
8246      slug: 'midnight'
8247    }],
8248    __unstableResolvedAssets: {
8249      styles: [],
8250      scripts: []
8251    }
8252  };
8253  
8254  ;// ./node_modules/@wordpress/block-editor/build-module/store/array.js
8255  /**
8256   * Insert one or multiple elements into a given position of an array.
8257   *
8258   * @param {Array}  array    Source array.
8259   * @param {*}      elements Elements to insert.
8260   * @param {number} index    Insert Position.
8261   *
8262   * @return {Array} Result.
8263   */
8264  function insertAt(array, elements, index) {
8265    return [...array.slice(0, index), ...(Array.isArray(elements) ? elements : [elements]), ...array.slice(index)];
8266  }
8267  
8268  /**
8269   * Moves an element in an array.
8270   *
8271   * @param {Array}  array Source array.
8272   * @param {number} from  Source index.
8273   * @param {number} to    Destination index.
8274   * @param {number} count Number of elements to move.
8275   *
8276   * @return {Array} Result.
8277   */
8278  function moveTo(array, from, to, count = 1) {
8279    const withoutMovedElements = [...array];
8280    withoutMovedElements.splice(from, count);
8281    return insertAt(withoutMovedElements, array.slice(from, from + count), to);
8282  }
8283  
8284  ;// ./node_modules/@wordpress/block-editor/build-module/store/private-keys.js
8285  const globalStylesDataKey = Symbol('globalStylesDataKey');
8286  const globalStylesLinksDataKey = Symbol('globalStylesLinks');
8287  const selectBlockPatternsKey = Symbol('selectBlockPatternsKey');
8288  const reusableBlocksSelectKey = Symbol('reusableBlocksSelect');
8289  const sectionRootClientIdKey = Symbol('sectionRootClientIdKey');
8290  
8291  ;// external ["wp","privateApis"]
8292  const external_wp_privateApis_namespaceObject = window["wp"]["privateApis"];
8293  ;// ./node_modules/@wordpress/block-editor/build-module/lock-unlock.js
8294  /**
8295   * WordPress dependencies
8296   */
8297  
8298  const {
8299    lock,
8300    unlock
8301  } = (0,external_wp_privateApis_namespaceObject.__dangerousOptInToUnstableAPIsOnlyForCoreModules)('I acknowledge private features are not for use in themes or plugins and doing so will break in the next version of WordPress.', '@wordpress/block-editor');
8302  
8303  ;// ./node_modules/@wordpress/block-editor/build-module/store/reducer.js
8304  /**
8305   * External dependencies
8306   */
8307  
8308  
8309  /**
8310   * WordPress dependencies
8311   */
8312  
8313  
8314  
8315  
8316  
8317  /**
8318   * Internal dependencies
8319   */
8320  
8321  
8322  
8323  
8324  const {
8325    isContentBlock
8326  } = unlock(external_wp_blocks_namespaceObject.privateApis);
8327  const identity = x => x;
8328  
8329  /**
8330   * Given an array of blocks, returns an object where each key is a nesting
8331   * context, the value of which is an array of block client IDs existing within
8332   * that nesting context.
8333   *
8334   * @param {Array}   blocks       Blocks to map.
8335   * @param {?string} rootClientId Assumed root client ID.
8336   *
8337   * @return {Object} Block order map object.
8338   */
8339  function mapBlockOrder(blocks, rootClientId = '') {
8340    const result = new Map();
8341    const current = [];
8342    result.set(rootClientId, current);
8343    blocks.forEach(block => {
8344      const {
8345        clientId,
8346        innerBlocks
8347      } = block;
8348      current.push(clientId);
8349      mapBlockOrder(innerBlocks, clientId).forEach((order, subClientId) => {
8350        result.set(subClientId, order);
8351      });
8352    });
8353    return result;
8354  }
8355  
8356  /**
8357   * Given an array of blocks, returns an object where each key contains
8358   * the clientId of the block and the value is the parent of the block.
8359   *
8360   * @param {Array}   blocks       Blocks to map.
8361   * @param {?string} rootClientId Assumed root client ID.
8362   *
8363   * @return {Object} Block order map object.
8364   */
8365  function mapBlockParents(blocks, rootClientId = '') {
8366    const result = [];
8367    const stack = [[rootClientId, blocks]];
8368    while (stack.length) {
8369      const [parent, currentBlocks] = stack.shift();
8370      currentBlocks.forEach(({
8371        innerBlocks,
8372        ...block
8373      }) => {
8374        result.push([block.clientId, parent]);
8375        if (innerBlocks?.length) {
8376          stack.push([block.clientId, innerBlocks]);
8377        }
8378      });
8379    }
8380    return result;
8381  }
8382  
8383  /**
8384   * Helper method to iterate through all blocks, recursing into inner blocks,
8385   * applying a transformation function to each one.
8386   * Returns a flattened object with the transformed blocks.
8387   *
8388   * @param {Array}    blocks    Blocks to flatten.
8389   * @param {Function} transform Transforming function to be applied to each block.
8390   *
8391   * @return {Array} Flattened object.
8392   */
8393  function flattenBlocks(blocks, transform = identity) {
8394    const result = [];
8395    const stack = [...blocks];
8396    while (stack.length) {
8397      const {
8398        innerBlocks,
8399        ...block
8400      } = stack.shift();
8401      stack.push(...innerBlocks);
8402      result.push([block.clientId, transform(block)]);
8403    }
8404    return result;
8405  }
8406  function getFlattenedClientIds(blocks) {
8407    const result = {};
8408    const stack = [...blocks];
8409    while (stack.length) {
8410      const {
8411        innerBlocks,
8412        ...block
8413      } = stack.shift();
8414      stack.push(...innerBlocks);
8415      result[block.clientId] = true;
8416    }
8417    return result;
8418  }
8419  
8420  /**
8421   * Given an array of blocks, returns an object containing all blocks, without
8422   * attributes, recursing into inner blocks. Keys correspond to the block client
8423   * ID, the value of which is the attributes object.
8424   *
8425   * @param {Array} blocks Blocks to flatten.
8426   *
8427   * @return {Array} Flattened block attributes object.
8428   */
8429  function getFlattenedBlocksWithoutAttributes(blocks) {
8430    return flattenBlocks(blocks, block => {
8431      const {
8432        attributes,
8433        ...restBlock
8434      } = block;
8435      return restBlock;
8436    });
8437  }
8438  
8439  /**
8440   * Given an array of blocks, returns an object containing all block attributes,
8441   * recursing into inner blocks. Keys correspond to the block client ID, the
8442   * value of which is the attributes object.
8443   *
8444   * @param {Array} blocks Blocks to flatten.
8445   *
8446   * @return {Array} Flattened block attributes object.
8447   */
8448  function getFlattenedBlockAttributes(blocks) {
8449    return flattenBlocks(blocks, block => block.attributes);
8450  }
8451  
8452  /**
8453   * Returns true if the two object arguments have the same keys, or false
8454   * otherwise.
8455   *
8456   * @param {Object} a First object.
8457   * @param {Object} b Second object.
8458   *
8459   * @return {boolean} Whether the two objects have the same keys.
8460   */
8461  function hasSameKeys(a, b) {
8462    return es6_default()(Object.keys(a), Object.keys(b));
8463  }
8464  
8465  /**
8466   * Returns true if, given the currently dispatching action and the previously
8467   * dispatched action, the two actions are updating the same block attribute, or
8468   * false otherwise.
8469   *
8470   * @param {Object} action     Currently dispatching action.
8471   * @param {Object} lastAction Previously dispatched action.
8472   *
8473   * @return {boolean} Whether actions are updating the same block attribute.
8474   */
8475  function isUpdatingSameBlockAttribute(action, lastAction) {
8476    return action.type === 'UPDATE_BLOCK_ATTRIBUTES' && lastAction !== undefined && lastAction.type === 'UPDATE_BLOCK_ATTRIBUTES' && es6_default()(action.clientIds, lastAction.clientIds) && hasSameKeys(action.attributes, lastAction.attributes);
8477  }
8478  function updateBlockTreeForBlocks(state, blocks) {
8479    const treeToUpdate = state.tree;
8480    const stack = [...blocks];
8481    const flattenedBlocks = [...blocks];
8482    while (stack.length) {
8483      const block = stack.shift();
8484      stack.push(...block.innerBlocks);
8485      flattenedBlocks.push(...block.innerBlocks);
8486    }
8487    // Create objects before mutating them, that way it's always defined.
8488    for (const block of flattenedBlocks) {
8489      treeToUpdate.set(block.clientId, {});
8490    }
8491    for (const block of flattenedBlocks) {
8492      treeToUpdate.set(block.clientId, Object.assign(treeToUpdate.get(block.clientId), {
8493        ...state.byClientId.get(block.clientId),
8494        attributes: state.attributes.get(block.clientId),
8495        innerBlocks: block.innerBlocks.map(subBlock => treeToUpdate.get(subBlock.clientId))
8496      }));
8497    }
8498  }
8499  function updateParentInnerBlocksInTree(state, updatedClientIds, updateChildrenOfUpdatedClientIds = false) {
8500    const treeToUpdate = state.tree;
8501    const uncontrolledParents = new Set([]);
8502    const controlledParents = new Set();
8503    for (const clientId of updatedClientIds) {
8504      let current = updateChildrenOfUpdatedClientIds ? clientId : state.parents.get(clientId);
8505      do {
8506        if (state.controlledInnerBlocks[current]) {
8507          // Should stop on controlled blocks.
8508          // If we reach a controlled parent, break out of the loop.
8509          controlledParents.add(current);
8510          break;
8511        } else {
8512          // Else continue traversing up through parents.
8513          uncontrolledParents.add(current);
8514          current = state.parents.get(current);
8515        }
8516      } while (current !== undefined);
8517    }
8518  
8519    // To make sure the order of assignments doesn't matter,
8520    // we first create empty objects and mutates the inner blocks later.
8521    for (const clientId of uncontrolledParents) {
8522      treeToUpdate.set(clientId, {
8523        ...treeToUpdate.get(clientId)
8524      });
8525    }
8526    for (const clientId of uncontrolledParents) {
8527      treeToUpdate.get(clientId).innerBlocks = (state.order.get(clientId) || []).map(subClientId => treeToUpdate.get(subClientId));
8528    }
8529  
8530    // Controlled parent blocks, need a dedicated key for their inner blocks
8531    // to be used when doing getBlocks( controlledBlockClientId ).
8532    for (const clientId of controlledParents) {
8533      treeToUpdate.set('controlled||' + clientId, {
8534        innerBlocks: (state.order.get(clientId) || []).map(subClientId => treeToUpdate.get(subClientId))
8535      });
8536    }
8537  }
8538  
8539  /**
8540   * Higher-order reducer intended to compute full block objects key for each block in the post.
8541   * This is a denormalization to optimize the performance of the getBlock selectors and avoid
8542   * recomputing the block objects and avoid heavy memoization.
8543   *
8544   * @param {Function} reducer Original reducer function.
8545   *
8546   * @return {Function} Enhanced reducer function.
8547   */
8548  const withBlockTree = reducer => (state = {}, action) => {
8549    const newState = reducer(state, action);
8550    if (newState === state) {
8551      return state;
8552    }
8553    newState.tree = state.tree ? state.tree : new Map();
8554    switch (action.type) {
8555      case 'RECEIVE_BLOCKS':
8556      case 'INSERT_BLOCKS':
8557        {
8558          newState.tree = new Map(newState.tree);
8559          updateBlockTreeForBlocks(newState, action.blocks);
8560          updateParentInnerBlocksInTree(newState, action.rootClientId ? [action.rootClientId] : [''], true);
8561          break;
8562        }
8563      case 'UPDATE_BLOCK':
8564        newState.tree = new Map(newState.tree);
8565        newState.tree.set(action.clientId, {
8566          ...newState.tree.get(action.clientId),
8567          ...newState.byClientId.get(action.clientId),
8568          attributes: newState.attributes.get(action.clientId)
8569        });
8570        updateParentInnerBlocksInTree(newState, [action.clientId], false);
8571        break;
8572      case 'SYNC_DERIVED_BLOCK_ATTRIBUTES':
8573      case 'UPDATE_BLOCK_ATTRIBUTES':
8574        {
8575          newState.tree = new Map(newState.tree);
8576          action.clientIds.forEach(clientId => {
8577            newState.tree.set(clientId, {
8578              ...newState.tree.get(clientId),
8579              attributes: newState.attributes.get(clientId)
8580            });
8581          });
8582          updateParentInnerBlocksInTree(newState, action.clientIds, false);
8583          break;
8584        }
8585      case 'REPLACE_BLOCKS_AUGMENTED_WITH_CHILDREN':
8586        {
8587          const inserterClientIds = getFlattenedClientIds(action.blocks);
8588          newState.tree = new Map(newState.tree);
8589          action.replacedClientIds.forEach(clientId => {
8590            newState.tree.delete(clientId);
8591            // Controlled inner blocks are only removed
8592            // if the block doesn't move to another position
8593            // otherwise their content will be lost.
8594            if (!inserterClientIds[clientId]) {
8595              newState.tree.delete('controlled||' + clientId);
8596            }
8597          });
8598          updateBlockTreeForBlocks(newState, action.blocks);
8599          updateParentInnerBlocksInTree(newState, action.blocks.map(b => b.clientId), false);
8600  
8601          // If there are no replaced blocks, it means we're removing blocks so we need to update their parent.
8602          const parentsOfRemovedBlocks = [];
8603          for (const clientId of action.clientIds) {
8604            const parentId = state.parents.get(clientId);
8605            if (parentId !== undefined && (parentId === '' || newState.byClientId.get(parentId))) {
8606              parentsOfRemovedBlocks.push(parentId);
8607            }
8608          }
8609          updateParentInnerBlocksInTree(newState, parentsOfRemovedBlocks, true);
8610          break;
8611        }
8612      case 'REMOVE_BLOCKS_AUGMENTED_WITH_CHILDREN':
8613        const parentsOfRemovedBlocks = [];
8614        for (const clientId of action.clientIds) {
8615          const parentId = state.parents.get(clientId);
8616          if (parentId !== undefined && (parentId === '' || newState.byClientId.get(parentId))) {
8617            parentsOfRemovedBlocks.push(parentId);
8618          }
8619        }
8620        newState.tree = new Map(newState.tree);
8621        action.removedClientIds.forEach(clientId => {
8622          newState.tree.delete(clientId);
8623          newState.tree.delete('controlled||' + clientId);
8624        });
8625        updateParentInnerBlocksInTree(newState, parentsOfRemovedBlocks, true);
8626        break;
8627      case 'MOVE_BLOCKS_TO_POSITION':
8628        {
8629          const updatedBlockUids = [];
8630          if (action.fromRootClientId) {
8631            updatedBlockUids.push(action.fromRootClientId);
8632          } else {
8633            updatedBlockUids.push('');
8634          }
8635          if (action.toRootClientId) {
8636            updatedBlockUids.push(action.toRootClientId);
8637          }
8638          newState.tree = new Map(newState.tree);
8639          updateParentInnerBlocksInTree(newState, updatedBlockUids, true);
8640          break;
8641        }
8642      case 'MOVE_BLOCKS_UP':
8643      case 'MOVE_BLOCKS_DOWN':
8644        {
8645          const updatedBlockUids = [action.rootClientId ? action.rootClientId : ''];
8646          newState.tree = new Map(newState.tree);
8647          updateParentInnerBlocksInTree(newState, updatedBlockUids, true);
8648          break;
8649        }
8650      case 'SAVE_REUSABLE_BLOCK_SUCCESS':
8651        {
8652          const updatedBlockUids = [];
8653          newState.attributes.forEach((attributes, clientId) => {
8654            if (newState.byClientId.get(clientId).name === 'core/block' && attributes.ref === action.updatedId) {
8655              updatedBlockUids.push(clientId);
8656            }
8657          });
8658          newState.tree = new Map(newState.tree);
8659          updatedBlockUids.forEach(clientId => {
8660            newState.tree.set(clientId, {
8661              ...newState.byClientId.get(clientId),
8662              attributes: newState.attributes.get(clientId),
8663              innerBlocks: newState.tree.get(clientId).innerBlocks
8664            });
8665          });
8666          updateParentInnerBlocksInTree(newState, updatedBlockUids, false);
8667        }
8668    }
8669    return newState;
8670  };
8671  
8672  /**
8673   * Higher-order reducer intended to augment the blocks reducer, assigning an
8674   * `isPersistentChange` property value corresponding to whether a change in
8675   * state can be considered as persistent. All changes are considered persistent
8676   * except when updating the same block attribute as in the previous action.
8677   *
8678   * @param {Function} reducer Original reducer function.
8679   *
8680   * @return {Function} Enhanced reducer function.
8681   */
8682  function withPersistentBlockChange(reducer) {
8683    let lastAction;
8684    let markNextChangeAsNotPersistent = false;
8685    let explicitPersistent;
8686    return (state, action) => {
8687      let nextState = reducer(state, action);
8688      let nextIsPersistentChange;
8689      if (action.type === 'SET_EXPLICIT_PERSISTENT') {
8690        var _state$isPersistentCh;
8691        explicitPersistent = action.isPersistentChange;
8692        nextIsPersistentChange = (_state$isPersistentCh = state.isPersistentChange) !== null && _state$isPersistentCh !== void 0 ? _state$isPersistentCh : true;
8693      }
8694      if (explicitPersistent !== undefined) {
8695        nextIsPersistentChange = explicitPersistent;
8696        return nextIsPersistentChange === nextState.isPersistentChange ? nextState : {
8697          ...nextState,
8698          isPersistentChange: nextIsPersistentChange
8699        };
8700      }
8701      const isExplicitPersistentChange = action.type === 'MARK_LAST_CHANGE_AS_PERSISTENT' || markNextChangeAsNotPersistent;
8702  
8703      // Defer to previous state value (or default) unless changing or
8704      // explicitly marking as persistent.
8705      if (state === nextState && !isExplicitPersistentChange) {
8706        var _state$isPersistentCh2;
8707        markNextChangeAsNotPersistent = action.type === 'MARK_NEXT_CHANGE_AS_NOT_PERSISTENT';
8708        nextIsPersistentChange = (_state$isPersistentCh2 = state?.isPersistentChange) !== null && _state$isPersistentCh2 !== void 0 ? _state$isPersistentCh2 : true;
8709        if (state.isPersistentChange === nextIsPersistentChange) {
8710          return state;
8711        }
8712        return {
8713          ...nextState,
8714          isPersistentChange: nextIsPersistentChange
8715        };
8716      }
8717      nextState = {
8718        ...nextState,
8719        isPersistentChange: isExplicitPersistentChange ? !markNextChangeAsNotPersistent : !isUpdatingSameBlockAttribute(action, lastAction)
8720      };
8721  
8722      // In comparing against the previous action, consider only those which
8723      // would have qualified as one which would have been ignored or not
8724      // have resulted in a changed state.
8725      lastAction = action;
8726      markNextChangeAsNotPersistent = action.type === 'MARK_NEXT_CHANGE_AS_NOT_PERSISTENT';
8727      return nextState;
8728    };
8729  }
8730  
8731  /**
8732   * Higher-order reducer intended to augment the blocks reducer, assigning an
8733   * `isIgnoredChange` property value corresponding to whether a change in state
8734   * can be considered as ignored. A change is considered ignored when the result
8735   * of an action not incurred by direct user interaction.
8736   *
8737   * @param {Function} reducer Original reducer function.
8738   *
8739   * @return {Function} Enhanced reducer function.
8740   */
8741  function withIgnoredBlockChange(reducer) {
8742    /**
8743     * Set of action types for which a blocks state change should be ignored.
8744     *
8745     * @type {Set}
8746     */
8747    const IGNORED_ACTION_TYPES = new Set(['RECEIVE_BLOCKS']);
8748    return (state, action) => {
8749      const nextState = reducer(state, action);
8750      if (nextState !== state) {
8751        nextState.isIgnoredChange = IGNORED_ACTION_TYPES.has(action.type);
8752      }
8753      return nextState;
8754    };
8755  }
8756  
8757  /**
8758   * Higher-order reducer targeting the combined blocks reducer, augmenting
8759   * block client IDs in remove action to include cascade of inner blocks.
8760   *
8761   * @param {Function} reducer Original reducer function.
8762   *
8763   * @return {Function} Enhanced reducer function.
8764   */
8765  const withInnerBlocksRemoveCascade = reducer => (state, action) => {
8766    // Gets all children which need to be removed.
8767    const getAllChildren = clientIds => {
8768      let result = clientIds;
8769      for (let i = 0; i < result.length; i++) {
8770        if (!state.order.get(result[i]) || action.keepControlledInnerBlocks && action.keepControlledInnerBlocks[result[i]]) {
8771          continue;
8772        }
8773        if (result === clientIds) {
8774          result = [...result];
8775        }
8776        result.push(...state.order.get(result[i]));
8777      }
8778      return result;
8779    };
8780    if (state) {
8781      switch (action.type) {
8782        case 'REMOVE_BLOCKS':
8783          action = {
8784            ...action,
8785            type: 'REMOVE_BLOCKS_AUGMENTED_WITH_CHILDREN',
8786            removedClientIds: getAllChildren(action.clientIds)
8787          };
8788          break;
8789        case 'REPLACE_BLOCKS':
8790          action = {
8791            ...action,
8792            type: 'REPLACE_BLOCKS_AUGMENTED_WITH_CHILDREN',
8793            replacedClientIds: getAllChildren(action.clientIds)
8794          };
8795          break;
8796      }
8797    }
8798    return reducer(state, action);
8799  };
8800  
8801  /**
8802   * Higher-order reducer which targets the combined blocks reducer and handles
8803   * the `RESET_BLOCKS` action. When dispatched, this action will replace all
8804   * blocks that exist in the post, leaving blocks that exist only in state (e.g.
8805   * reusable blocks and blocks controlled by inner blocks controllers) alone.
8806   *
8807   * @param {Function} reducer Original reducer function.
8808   *
8809   * @return {Function} Enhanced reducer function.
8810   */
8811  const withBlockReset = reducer => (state, action) => {
8812    if (action.type === 'RESET_BLOCKS') {
8813      const newState = {
8814        ...state,
8815        byClientId: new Map(getFlattenedBlocksWithoutAttributes(action.blocks)),
8816        attributes: new Map(getFlattenedBlockAttributes(action.blocks)),
8817        order: mapBlockOrder(action.blocks),
8818        parents: new Map(mapBlockParents(action.blocks)),
8819        controlledInnerBlocks: {}
8820      };
8821      newState.tree = new Map(state?.tree);
8822      updateBlockTreeForBlocks(newState, action.blocks);
8823      newState.tree.set('', {
8824        innerBlocks: action.blocks.map(subBlock => newState.tree.get(subBlock.clientId))
8825      });
8826      return newState;
8827    }
8828    return reducer(state, action);
8829  };
8830  
8831  /**
8832   * Higher-order reducer which targets the combined blocks reducer and handles
8833   * the `REPLACE_INNER_BLOCKS` action. When dispatched, this action the state
8834   * should become equivalent to the execution of a `REMOVE_BLOCKS` action
8835   * containing all the child's of the root block followed by the execution of
8836   * `INSERT_BLOCKS` with the new blocks.
8837   *
8838   * @param {Function} reducer Original reducer function.
8839   *
8840   * @return {Function} Enhanced reducer function.
8841   */
8842  const withReplaceInnerBlocks = reducer => (state, action) => {
8843    if (action.type !== 'REPLACE_INNER_BLOCKS') {
8844      return reducer(state, action);
8845    }
8846  
8847    // Finds every nested inner block controller. We must check the action blocks
8848    // and not just the block parent state because some inner block controllers
8849    // should be deleted if specified, whereas others should not be deleted. If
8850    // a controlled should not be deleted, then we need to avoid deleting its
8851    // inner blocks from the block state because its inner blocks will not be
8852    // attached to the block in the action.
8853    const nestedControllers = {};
8854    if (Object.keys(state.controlledInnerBlocks).length) {
8855      const stack = [...action.blocks];
8856      while (stack.length) {
8857        const {
8858          innerBlocks,
8859          ...block
8860        } = stack.shift();
8861        stack.push(...innerBlocks);
8862        if (!!state.controlledInnerBlocks[block.clientId]) {
8863          nestedControllers[block.clientId] = true;
8864        }
8865      }
8866    }
8867  
8868    // The `keepControlledInnerBlocks` prop will keep the inner blocks of the
8869    // marked block in the block state so that they can be reattached to the
8870    // marked block when we re-insert everything a few lines below.
8871    let stateAfterBlocksRemoval = state;
8872    if (state.order.get(action.rootClientId)) {
8873      stateAfterBlocksRemoval = reducer(stateAfterBlocksRemoval, {
8874        type: 'REMOVE_BLOCKS',
8875        keepControlledInnerBlocks: nestedControllers,
8876        clientIds: state.order.get(action.rootClientId)
8877      });
8878    }
8879    let stateAfterInsert = stateAfterBlocksRemoval;
8880    if (action.blocks.length) {
8881      stateAfterInsert = reducer(stateAfterInsert, {
8882        ...action,
8883        type: 'INSERT_BLOCKS',
8884        index: 0
8885      });
8886  
8887      // We need to re-attach the controlled inner blocks to the blocks tree and
8888      // preserve their block order. Otherwise, an inner block controller's blocks
8889      // will be deleted entirely from its entity.
8890      const stateAfterInsertOrder = new Map(stateAfterInsert.order);
8891      Object.keys(nestedControllers).forEach(key => {
8892        if (state.order.get(key)) {
8893          stateAfterInsertOrder.set(key, state.order.get(key));
8894        }
8895      });
8896      stateAfterInsert.order = stateAfterInsertOrder;
8897      stateAfterInsert.tree = new Map(stateAfterInsert.tree);
8898      Object.keys(nestedControllers).forEach(_key => {
8899        const key = `controlled||$_key}`;
8900        if (state.tree.has(key)) {
8901          stateAfterInsert.tree.set(key, state.tree.get(key));
8902        }
8903      });
8904    }
8905    return stateAfterInsert;
8906  };
8907  
8908  /**
8909   * Higher-order reducer which targets the combined blocks reducer and handles
8910   * the `SAVE_REUSABLE_BLOCK_SUCCESS` action. This action can't be handled by
8911   * regular reducers and needs a higher-order reducer since it needs access to
8912   * both `byClientId` and `attributes` simultaneously.
8913   *
8914   * @param {Function} reducer Original reducer function.
8915   *
8916   * @return {Function} Enhanced reducer function.
8917   */
8918  const withSaveReusableBlock = reducer => (state, action) => {
8919    if (state && action.type === 'SAVE_REUSABLE_BLOCK_SUCCESS') {
8920      const {
8921        id,
8922        updatedId
8923      } = action;
8924  
8925      // If a temporary reusable block is saved, we swap the temporary id with the final one.
8926      if (id === updatedId) {
8927        return state;
8928      }
8929      state = {
8930        ...state
8931      };
8932      state.attributes = new Map(state.attributes);
8933      state.attributes.forEach((attributes, clientId) => {
8934        const {
8935          name
8936        } = state.byClientId.get(clientId);
8937        if (name === 'core/block' && attributes.ref === id) {
8938          state.attributes.set(clientId, {
8939            ...attributes,
8940            ref: updatedId
8941          });
8942        }
8943      });
8944    }
8945    return reducer(state, action);
8946  };
8947  /**
8948   * Higher-order reducer which removes blocks from state when switching parent block controlled state.
8949   *
8950   * @param {Function} reducer Original reducer function.
8951   *
8952   * @return {Function} Enhanced reducer function.
8953   */
8954  const withResetControlledBlocks = reducer => (state, action) => {
8955    if (action.type === 'SET_HAS_CONTROLLED_INNER_BLOCKS') {
8956      // when switching a block from controlled to uncontrolled or inverse,
8957      // we need to remove its content first.
8958      const tempState = reducer(state, {
8959        type: 'REPLACE_INNER_BLOCKS',
8960        rootClientId: action.clientId,
8961        blocks: []
8962      });
8963      return reducer(tempState, action);
8964    }
8965    return reducer(state, action);
8966  };
8967  
8968  /**
8969   * Reducer returning the blocks state.
8970   *
8971   * @param {Object} state  Current state.
8972   * @param {Object} action Dispatched action.
8973   *
8974   * @return {Object} Updated state.
8975   */
8976  const blocks = (0,external_wp_compose_namespaceObject.pipe)(external_wp_data_namespaceObject.combineReducers, withSaveReusableBlock,
8977  // Needs to be before withBlockCache.
8978  withBlockTree,
8979  // Needs to be before withInnerBlocksRemoveCascade.
8980  withInnerBlocksRemoveCascade, withReplaceInnerBlocks,
8981  // Needs to be after withInnerBlocksRemoveCascade.
8982  withBlockReset, withPersistentBlockChange, withIgnoredBlockChange, withResetControlledBlocks)({
8983    // The state is using a Map instead of a plain object for performance reasons.
8984    // You can run the "./test/performance.js" unit test to check the impact
8985    // code changes can have on this reducer.
8986    byClientId(state = new Map(), action) {
8987      switch (action.type) {
8988        case 'RECEIVE_BLOCKS':
8989        case 'INSERT_BLOCKS':
8990          {
8991            const newState = new Map(state);
8992            getFlattenedBlocksWithoutAttributes(action.blocks).forEach(([key, value]) => {
8993              newState.set(key, value);
8994            });
8995            return newState;
8996          }
8997        case 'UPDATE_BLOCK':
8998          {
8999            // Ignore updates if block isn't known.
9000            if (!state.has(action.clientId)) {
9001              return state;
9002            }
9003  
9004            // Do nothing if only attributes change.
9005            const {
9006              attributes,
9007              ...changes
9008            } = action.updates;
9009            if (Object.values(changes).length === 0) {
9010              return state;
9011            }
9012            const newState = new Map(state);
9013            newState.set(action.clientId, {
9014              ...state.get(action.clientId),
9015              ...changes
9016            });
9017            return newState;
9018          }
9019        case 'REPLACE_BLOCKS_AUGMENTED_WITH_CHILDREN':
9020          {
9021            if (!action.blocks) {
9022              return state;
9023            }
9024            const newState = new Map(state);
9025            action.replacedClientIds.forEach(clientId => {
9026              newState.delete(clientId);
9027            });
9028            getFlattenedBlocksWithoutAttributes(action.blocks).forEach(([key, value]) => {
9029              newState.set(key, value);
9030            });
9031            return newState;
9032          }
9033        case 'REMOVE_BLOCKS_AUGMENTED_WITH_CHILDREN':
9034          {
9035            const newState = new Map(state);
9036            action.removedClientIds.forEach(clientId => {
9037              newState.delete(clientId);
9038            });
9039            return newState;
9040          }
9041      }
9042      return state;
9043    },
9044    // The state is using a Map instead of a plain object for performance reasons.
9045    // You can run the "./test/performance.js" unit test to check the impact
9046    // code changes can have on this reducer.
9047    attributes(state = new Map(), action) {
9048      switch (action.type) {
9049        case 'RECEIVE_BLOCKS':
9050        case 'INSERT_BLOCKS':
9051          {
9052            const newState = new Map(state);
9053            getFlattenedBlockAttributes(action.blocks).forEach(([key, value]) => {
9054              newState.set(key, value);
9055            });
9056            return newState;
9057          }
9058        case 'UPDATE_BLOCK':
9059          {
9060            // Ignore updates if block isn't known or there are no attribute changes.
9061            if (!state.get(action.clientId) || !action.updates.attributes) {
9062              return state;
9063            }
9064            const newState = new Map(state);
9065            newState.set(action.clientId, {
9066              ...state.get(action.clientId),
9067              ...action.updates.attributes
9068            });
9069            return newState;
9070          }
9071        case 'SYNC_DERIVED_BLOCK_ATTRIBUTES':
9072        case 'UPDATE_BLOCK_ATTRIBUTES':
9073          {
9074            // Avoid a state change if none of the block IDs are known.
9075            if (action.clientIds.every(id => !state.get(id))) {
9076              return state;
9077            }
9078            let hasChange = false;
9079            const newState = new Map(state);
9080            for (const clientId of action.clientIds) {
9081              var _action$attributes;
9082              const updatedAttributeEntries = Object.entries(action.uniqueByBlock ? action.attributes[clientId] : (_action$attributes = action.attributes) !== null && _action$attributes !== void 0 ? _action$attributes : {});
9083              if (updatedAttributeEntries.length === 0) {
9084                continue;
9085              }
9086              let hasUpdatedAttributes = false;
9087              const existingAttributes = state.get(clientId);
9088              const newAttributes = {};
9089              updatedAttributeEntries.forEach(([key, value]) => {
9090                if (existingAttributes[key] !== value) {
9091                  hasUpdatedAttributes = true;
9092                  newAttributes[key] = value;
9093                }
9094              });
9095              hasChange = hasChange || hasUpdatedAttributes;
9096              if (hasUpdatedAttributes) {
9097                newState.set(clientId, {
9098                  ...existingAttributes,
9099                  ...newAttributes
9100                });
9101              }
9102            }
9103            return hasChange ? newState : state;
9104          }
9105        case 'REPLACE_BLOCKS_AUGMENTED_WITH_CHILDREN':
9106          {
9107            if (!action.blocks) {
9108              return state;
9109            }
9110            const newState = new Map(state);
9111            action.replacedClientIds.forEach(clientId => {
9112              newState.delete(clientId);
9113            });
9114            getFlattenedBlockAttributes(action.blocks).forEach(([key, value]) => {
9115              newState.set(key, value);
9116            });
9117            return newState;
9118          }
9119        case 'REMOVE_BLOCKS_AUGMENTED_WITH_CHILDREN':
9120          {
9121            const newState = new Map(state);
9122            action.removedClientIds.forEach(clientId => {
9123              newState.delete(clientId);
9124            });
9125            return newState;
9126          }
9127      }
9128      return state;
9129    },
9130    // The state is using a Map instead of a plain object for performance reasons.
9131    // You can run the "./test/performance.js" unit test to check the impact
9132    // code changes can have on this reducer.
9133    order(state = new Map(), action) {
9134      switch (action.type) {
9135        case 'RECEIVE_BLOCKS':
9136          {
9137            var _state$get;
9138            const blockOrder = mapBlockOrder(action.blocks);
9139            const newState = new Map(state);
9140            blockOrder.forEach((order, clientId) => {
9141              if (clientId !== '') {
9142                newState.set(clientId, order);
9143              }
9144            });
9145            newState.set('', ((_state$get = state.get('')) !== null && _state$get !== void 0 ? _state$get : []).concat(blockOrder['']));
9146            return newState;
9147          }
9148        case 'INSERT_BLOCKS':
9149          {
9150            const {
9151              rootClientId = ''
9152            } = action;
9153            const subState = state.get(rootClientId) || [];
9154            const mappedBlocks = mapBlockOrder(action.blocks, rootClientId);
9155            const {
9156              index = subState.length
9157            } = action;
9158            const newState = new Map(state);
9159            mappedBlocks.forEach((order, clientId) => {
9160              newState.set(clientId, order);
9161            });
9162            newState.set(rootClientId, insertAt(subState, mappedBlocks.get(rootClientId), index));
9163            return newState;
9164          }
9165        case 'MOVE_BLOCKS_TO_POSITION':
9166          {
9167            var _state$get$filter;
9168            const {
9169              fromRootClientId = '',
9170              toRootClientId = '',
9171              clientIds
9172            } = action;
9173            const {
9174              index = state.get(toRootClientId).length
9175            } = action;
9176  
9177            // Moving inside the same parent block.
9178            if (fromRootClientId === toRootClientId) {
9179              const subState = state.get(toRootClientId);
9180              const fromIndex = subState.indexOf(clientIds[0]);
9181              const newState = new Map(state);
9182              newState.set(toRootClientId, moveTo(state.get(toRootClientId), fromIndex, index, clientIds.length));
9183              return newState;
9184            }
9185  
9186            // Moving from a parent block to another.
9187            const newState = new Map(state);
9188            newState.set(fromRootClientId, (_state$get$filter = state.get(fromRootClientId)?.filter(id => !clientIds.includes(id))) !== null && _state$get$filter !== void 0 ? _state$get$filter : []);
9189            newState.set(toRootClientId, insertAt(state.get(toRootClientId), clientIds, index));
9190            return newState;
9191          }
9192        case 'MOVE_BLOCKS_UP':
9193          {
9194            const {
9195              clientIds,
9196              rootClientId = ''
9197            } = action;
9198            const firstClientId = clientIds[0];
9199            const subState = state.get(rootClientId);
9200            if (!subState.length || firstClientId === subState[0]) {
9201              return state;
9202            }
9203            const firstIndex = subState.indexOf(firstClientId);
9204            const newState = new Map(state);
9205            newState.set(rootClientId, moveTo(subState, firstIndex, firstIndex - 1, clientIds.length));
9206            return newState;
9207          }
9208        case 'MOVE_BLOCKS_DOWN':
9209          {
9210            const {
9211              clientIds,
9212              rootClientId = ''
9213            } = action;
9214            const firstClientId = clientIds[0];
9215            const lastClientId = clientIds[clientIds.length - 1];
9216            const subState = state.get(rootClientId);
9217            if (!subState.length || lastClientId === subState[subState.length - 1]) {
9218              return state;
9219            }
9220            const firstIndex = subState.indexOf(firstClientId);
9221            const newState = new Map(state);
9222            newState.set(rootClientId, moveTo(subState, firstIndex, firstIndex + 1, clientIds.length));
9223            return newState;
9224          }
9225        case 'REPLACE_BLOCKS_AUGMENTED_WITH_CHILDREN':
9226          {
9227            const {
9228              clientIds
9229            } = action;
9230            if (!action.blocks) {
9231              return state;
9232            }
9233            const mappedBlocks = mapBlockOrder(action.blocks);
9234            const newState = new Map(state);
9235            action.replacedClientIds.forEach(clientId => {
9236              newState.delete(clientId);
9237            });
9238            mappedBlocks.forEach((order, clientId) => {
9239              if (clientId !== '') {
9240                newState.set(clientId, order);
9241              }
9242            });
9243            newState.forEach((order, clientId) => {
9244              const newSubOrder = Object.values(order).reduce((result, subClientId) => {
9245                if (subClientId === clientIds[0]) {
9246                  return [...result, ...mappedBlocks.get('')];
9247                }
9248                if (clientIds.indexOf(subClientId) === -1) {
9249                  result.push(subClientId);
9250                }
9251                return result;
9252              }, []);
9253              newState.set(clientId, newSubOrder);
9254            });
9255            return newState;
9256          }
9257        case 'REMOVE_BLOCKS_AUGMENTED_WITH_CHILDREN':
9258          {
9259            const newState = new Map(state);
9260            // Remove inner block ordering for removed blocks.
9261            action.removedClientIds.forEach(clientId => {
9262              newState.delete(clientId);
9263            });
9264            newState.forEach((order, clientId) => {
9265              var _order$filter;
9266              const newSubOrder = (_order$filter = order?.filter(id => !action.removedClientIds.includes(id))) !== null && _order$filter !== void 0 ? _order$filter : [];
9267              if (newSubOrder.length !== order.length) {
9268                newState.set(clientId, newSubOrder);
9269              }
9270            });
9271            return newState;
9272          }
9273      }
9274      return state;
9275    },
9276    // While technically redundant data as the inverse of `order`, it serves as
9277    // an optimization for the selectors which derive the ancestry of a block.
9278    parents(state = new Map(), action) {
9279      switch (action.type) {
9280        case 'RECEIVE_BLOCKS':
9281          {
9282            const newState = new Map(state);
9283            mapBlockParents(action.blocks).forEach(([key, value]) => {
9284              newState.set(key, value);
9285            });
9286            return newState;
9287          }
9288        case 'INSERT_BLOCKS':
9289          {
9290            const newState = new Map(state);
9291            mapBlockParents(action.blocks, action.rootClientId || '').forEach(([key, value]) => {
9292              newState.set(key, value);
9293            });
9294            return newState;
9295          }
9296        case 'MOVE_BLOCKS_TO_POSITION':
9297          {
9298            const newState = new Map(state);
9299            action.clientIds.forEach(id => {
9300              newState.set(id, action.toRootClientId || '');
9301            });
9302            return newState;
9303          }
9304        case 'REPLACE_BLOCKS_AUGMENTED_WITH_CHILDREN':
9305          {
9306            const newState = new Map(state);
9307            action.replacedClientIds.forEach(clientId => {
9308              newState.delete(clientId);
9309            });
9310            mapBlockParents(action.blocks, state.get(action.clientIds[0])).forEach(([key, value]) => {
9311              newState.set(key, value);
9312            });
9313            return newState;
9314          }
9315        case 'REMOVE_BLOCKS_AUGMENTED_WITH_CHILDREN':
9316          {
9317            const newState = new Map(state);
9318            action.removedClientIds.forEach(clientId => {
9319              newState.delete(clientId);
9320            });
9321            return newState;
9322          }
9323      }
9324      return state;
9325    },
9326    controlledInnerBlocks(state = {}, {
9327      type,
9328      clientId,
9329      hasControlledInnerBlocks
9330    }) {
9331      if (type === 'SET_HAS_CONTROLLED_INNER_BLOCKS') {
9332        return {
9333          ...state,
9334          [clientId]: hasControlledInnerBlocks
9335        };
9336      }
9337      return state;
9338    }
9339  });
9340  
9341  /**
9342   * Reducer returning visibility status of block interface.
9343   *
9344   * @param {boolean} state  Current state.
9345   * @param {Object}  action Dispatched action.
9346   *
9347   * @return {boolean} Updated state.
9348   */
9349  function isBlockInterfaceHidden(state = false, action) {
9350    switch (action.type) {
9351      case 'HIDE_BLOCK_INTERFACE':
9352        return true;
9353      case 'SHOW_BLOCK_INTERFACE':
9354        return false;
9355    }
9356    return state;
9357  }
9358  
9359  /**
9360   * Reducer returning typing state.
9361   *
9362   * @param {boolean} state  Current state.
9363   * @param {Object}  action Dispatched action.
9364   *
9365   * @return {boolean} Updated state.
9366   */
9367  function isTyping(state = false, action) {
9368    switch (action.type) {
9369      case 'START_TYPING':
9370        return true;
9371      case 'STOP_TYPING':
9372        return false;
9373    }
9374    return state;
9375  }
9376  
9377  /**
9378   * Reducer returning dragging state. It is possible for a user to be dragging
9379   * data from outside of the editor, so this state is separate from `draggedBlocks`.
9380   *
9381   * @param {boolean} state  Current state.
9382   * @param {Object}  action Dispatched action.
9383   *
9384   * @return {boolean} Updated state.
9385   */
9386  function isDragging(state = false, action) {
9387    switch (action.type) {
9388      case 'START_DRAGGING':
9389        return true;
9390      case 'STOP_DRAGGING':
9391        return false;
9392    }
9393    return state;
9394  }
9395  
9396  /**
9397   * Reducer returning dragged block client id.
9398   *
9399   * @param {string[]} state  Current state.
9400   * @param {Object}   action Dispatched action.
9401   *
9402   * @return {string[]} Updated state.
9403   */
9404  function draggedBlocks(state = [], action) {
9405    switch (action.type) {
9406      case 'START_DRAGGING_BLOCKS':
9407        return action.clientIds;
9408      case 'STOP_DRAGGING_BLOCKS':
9409        return [];
9410    }
9411    return state;
9412  }
9413  
9414  /**
9415   * Reducer tracking the visible blocks.
9416   *
9417   * @param {Record<string,boolean>} state  Current state.
9418   * @param {Object}                 action Dispatched action.
9419   *
9420   * @return {Record<string,boolean>} Block visibility.
9421   */
9422  function blockVisibility(state = {}, action) {
9423    if (action.type === 'SET_BLOCK_VISIBILITY') {
9424      return {
9425        ...state,
9426        ...action.updates
9427      };
9428    }
9429    return state;
9430  }
9431  
9432  /**
9433   * Internal helper reducer for selectionStart and selectionEnd. Can hold a block
9434   * selection, represented by an object with property clientId.
9435   *
9436   * @param {Object} state  Current state.
9437   * @param {Object} action Dispatched action.
9438   *
9439   * @return {Object} Updated state.
9440   */
9441  function selectionHelper(state = {}, action) {
9442    switch (action.type) {
9443      case 'CLEAR_SELECTED_BLOCK':
9444        {
9445          if (state.clientId) {
9446            return {};
9447          }
9448          return state;
9449        }
9450      case 'SELECT_BLOCK':
9451        if (action.clientId === state.clientId) {
9452          return state;
9453        }
9454        return {
9455          clientId: action.clientId
9456        };
9457      case 'REPLACE_INNER_BLOCKS':
9458      case 'INSERT_BLOCKS':
9459        {
9460          if (!action.updateSelection || !action.blocks.length) {
9461            return state;
9462          }
9463          return {
9464            clientId: action.blocks[0].clientId
9465          };
9466        }
9467      case 'REMOVE_BLOCKS':
9468        if (!action.clientIds || !action.clientIds.length || action.clientIds.indexOf(state.clientId) === -1) {
9469          return state;
9470        }
9471        return {};
9472      case 'REPLACE_BLOCKS':
9473        {
9474          if (action.clientIds.indexOf(state.clientId) === -1) {
9475            return state;
9476          }
9477          const blockToSelect = action.blocks[action.indexToSelect] || action.blocks[action.blocks.length - 1];
9478          if (!blockToSelect) {
9479            return {};
9480          }
9481          if (blockToSelect.clientId === state.clientId) {
9482            return state;
9483          }
9484          return {
9485            clientId: blockToSelect.clientId
9486          };
9487        }
9488    }
9489    return state;
9490  }
9491  
9492  /**
9493   * Reducer returning the selection state.
9494   *
9495   * @param {boolean} state  Current state.
9496   * @param {Object}  action Dispatched action.
9497   *
9498   * @return {boolean} Updated state.
9499   */
9500  function selection(state = {}, action) {
9501    switch (action.type) {
9502      case 'SELECTION_CHANGE':
9503        if (action.clientId) {
9504          return {
9505            selectionStart: {
9506              clientId: action.clientId,
9507              attributeKey: action.attributeKey,
9508              offset: action.startOffset
9509            },
9510            selectionEnd: {
9511              clientId: action.clientId,
9512              attributeKey: action.attributeKey,
9513              offset: action.endOffset
9514            }
9515          };
9516        }
9517        return {
9518          selectionStart: action.start || state.selectionStart,
9519          selectionEnd: action.end || state.selectionEnd
9520        };
9521      case 'RESET_SELECTION':
9522        const {
9523          selectionStart,
9524          selectionEnd
9525        } = action;
9526        return {
9527          selectionStart,
9528          selectionEnd
9529        };
9530      case 'MULTI_SELECT':
9531        const {
9532          start,
9533          end
9534        } = action;
9535        if (start === state.selectionStart?.clientId && end === state.selectionEnd?.clientId) {
9536          return state;
9537        }
9538        return {
9539          selectionStart: {
9540            clientId: start
9541          },
9542          selectionEnd: {
9543            clientId: end
9544          }
9545        };
9546      case 'RESET_BLOCKS':
9547        const startClientId = state?.selectionStart?.clientId;
9548        const endClientId = state?.selectionEnd?.clientId;
9549  
9550        // Do nothing if there's no selected block.
9551        if (!startClientId && !endClientId) {
9552          return state;
9553        }
9554  
9555        // If the start of the selection won't exist after reset, remove selection.
9556        if (!action.blocks.some(block => block.clientId === startClientId)) {
9557          return {
9558            selectionStart: {},
9559            selectionEnd: {}
9560          };
9561        }
9562  
9563        // If the end of the selection won't exist after reset, collapse selection.
9564        if (!action.blocks.some(block => block.clientId === endClientId)) {
9565          return {
9566            ...state,
9567            selectionEnd: state.selectionStart
9568          };
9569        }
9570    }
9571    const selectionStart = selectionHelper(state.selectionStart, action);
9572    const selectionEnd = selectionHelper(state.selectionEnd, action);
9573    if (selectionStart === state.selectionStart && selectionEnd === state.selectionEnd) {
9574      return state;
9575    }
9576    return {
9577      selectionStart,
9578      selectionEnd
9579    };
9580  }
9581  
9582  /**
9583   * Reducer returning whether the user is multi-selecting.
9584   *
9585   * @param {boolean} state  Current state.
9586   * @param {Object}  action Dispatched action.
9587   *
9588   * @return {boolean} Updated state.
9589   */
9590  function isMultiSelecting(state = false, action) {
9591    switch (action.type) {
9592      case 'START_MULTI_SELECT':
9593        return true;
9594      case 'STOP_MULTI_SELECT':
9595        return false;
9596    }
9597    return state;
9598  }
9599  
9600  /**
9601   * Reducer returning whether selection is enabled.
9602   *
9603   * @param {boolean} state  Current state.
9604   * @param {Object}  action Dispatched action.
9605   *
9606   * @return {boolean} Updated state.
9607   */
9608  function isSelectionEnabled(state = true, action) {
9609    switch (action.type) {
9610      case 'TOGGLE_SELECTION':
9611        return action.isSelectionEnabled;
9612    }
9613    return state;
9614  }
9615  
9616  /**
9617   * Reducer returning the data needed to display a prompt when certain blocks
9618   * are removed, or `false` if no such prompt is requested.
9619   *
9620   * @param {boolean} state  Current state.
9621   * @param {Object}  action Dispatched action.
9622   *
9623   * @return {Object|false} Data for removal prompt display, if any.
9624   */
9625  function removalPromptData(state = false, action) {
9626    switch (action.type) {
9627      case 'DISPLAY_BLOCK_REMOVAL_PROMPT':
9628        const {
9629          clientIds,
9630          selectPrevious,
9631          message
9632        } = action;
9633        return {
9634          clientIds,
9635          selectPrevious,
9636          message
9637        };
9638      case 'CLEAR_BLOCK_REMOVAL_PROMPT':
9639        return false;
9640    }
9641    return state;
9642  }
9643  
9644  /**
9645   * Reducer returning any rules that a block editor may provide in order to
9646   * prevent a user from accidentally removing certain blocks. These rules are
9647   * then used to display a confirmation prompt to the user. For instance, in the
9648   * Site Editor, the Query Loop block is important enough to warrant such
9649   * confirmation.
9650   *
9651   * The data is a record whose keys are block types (e.g. 'core/query') and
9652   * whose values are the explanation to be shown to users (e.g. 'Query Loop
9653   * displays a list of posts or pages.').
9654   *
9655   * @param {boolean} state  Current state.
9656   * @param {Object}  action Dispatched action.
9657   *
9658   * @return {Record<string,string>} Updated state.
9659   */
9660  function blockRemovalRules(state = false, action) {
9661    switch (action.type) {
9662      case 'SET_BLOCK_REMOVAL_RULES':
9663        return action.rules;
9664    }
9665    return state;
9666  }
9667  
9668  /**
9669   * Reducer returning the initial block selection.
9670   *
9671   * Currently this in only used to restore the selection after block deletion and
9672   * pasting new content.This reducer should eventually be removed in favour of setting
9673   * selection directly.
9674   *
9675   * @param {boolean} state  Current state.
9676   * @param {Object}  action Dispatched action.
9677   *
9678   * @return {number|null} Initial position: 0, -1 or null.
9679   */
9680  function initialPosition(state = null, action) {
9681    if (action.type === 'REPLACE_BLOCKS' && action.initialPosition !== undefined) {
9682      return action.initialPosition;
9683    } else if (['MULTI_SELECT', 'SELECT_BLOCK', 'RESET_SELECTION', 'INSERT_BLOCKS', 'REPLACE_INNER_BLOCKS'].includes(action.type)) {
9684      return action.initialPosition;
9685    }
9686    return state;
9687  }
9688  function blocksMode(state = {}, action) {
9689    if (action.type === 'TOGGLE_BLOCK_MODE') {
9690      const {
9691        clientId
9692      } = action;
9693      return {
9694        ...state,
9695        [clientId]: state[clientId] && state[clientId] === 'html' ? 'visual' : 'html'
9696      };
9697    }
9698    return state;
9699  }
9700  
9701  /**
9702   * Reducer returning the block insertion point visibility, either null if there
9703   * is not an explicit insertion point assigned, or an object of its `index` and
9704   * `rootClientId`.
9705   *
9706   * @param {Object} state  Current state.
9707   * @param {Object} action Dispatched action.
9708   *
9709   * @return {Object} Updated state.
9710   */
9711  function insertionCue(state = null, action) {
9712    switch (action.type) {
9713      case 'SHOW_INSERTION_POINT':
9714        {
9715          const {
9716            rootClientId,
9717            index,
9718            __unstableWithInserter,
9719            operation,
9720            nearestSide
9721          } = action;
9722          const nextState = {
9723            rootClientId,
9724            index,
9725            __unstableWithInserter,
9726            operation,
9727            nearestSide
9728          };
9729  
9730          // Bail out updates if the states are the same.
9731          return es6_default()(state, nextState) ? state : nextState;
9732        }
9733      case 'HIDE_INSERTION_POINT':
9734        return null;
9735    }
9736    return state;
9737  }
9738  
9739  /**
9740   * Reducer returning whether the post blocks match the defined template or not.
9741   *
9742   * @param {Object} state  Current state.
9743   * @param {Object} action Dispatched action.
9744   *
9745   * @return {boolean} Updated state.
9746   */
9747  function template(state = {
9748    isValid: true
9749  }, action) {
9750    switch (action.type) {
9751      case 'SET_TEMPLATE_VALIDITY':
9752        return {
9753          ...state,
9754          isValid: action.isValid
9755        };
9756    }
9757    return state;
9758  }
9759  
9760  /**
9761   * Reducer returning the editor setting.
9762   *
9763   * @param {Object} state  Current state.
9764   * @param {Object} action Dispatched action.
9765   *
9766   * @return {Object} Updated state.
9767   */
9768  function settings(state = SETTINGS_DEFAULTS, action) {
9769    switch (action.type) {
9770      case 'UPDATE_SETTINGS':
9771        {
9772          const updatedSettings = action.reset ? {
9773            ...SETTINGS_DEFAULTS,
9774            ...action.settings
9775          } : {
9776            ...state,
9777            ...action.settings
9778          };
9779          Object.defineProperty(updatedSettings, '__unstableIsPreviewMode', {
9780            get() {
9781              external_wp_deprecated_default()('__unstableIsPreviewMode', {
9782                since: '6.8',
9783                alternative: 'isPreviewMode'
9784              });
9785              return this.isPreviewMode;
9786            }
9787          });
9788          return updatedSettings;
9789        }
9790    }
9791    return state;
9792  }
9793  
9794  /**
9795   * Reducer returning the user preferences.
9796   *
9797   * @param {Object} state  Current state.
9798   * @param {Object} action Dispatched action.
9799   *
9800   * @return {string} Updated state.
9801   */
9802  function preferences(state = PREFERENCES_DEFAULTS, action) {
9803    switch (action.type) {
9804      case 'INSERT_BLOCKS':
9805      case 'REPLACE_BLOCKS':
9806        {
9807          const nextInsertUsage = action.blocks.reduce((prevUsage, block) => {
9808            const {
9809              attributes,
9810              name: blockName
9811            } = block;
9812            let id = blockName;
9813            // If a block variation match is found change the name to be the same with the
9814            // one that is used for block variations in the Inserter (`getItemFromVariation`).
9815            const match = (0,external_wp_data_namespaceObject.select)(external_wp_blocks_namespaceObject.store).getActiveBlockVariation(blockName, attributes);
9816            if (match?.name) {
9817              id += '/' + match.name;
9818            }
9819            if (blockName === 'core/block') {
9820              id += '/' + attributes.ref;
9821            }
9822            return {
9823              ...prevUsage,
9824              [id]: {
9825                time: action.time,
9826                count: prevUsage[id] ? prevUsage[id].count + 1 : 1
9827              }
9828            };
9829          }, state.insertUsage);
9830          return {
9831            ...state,
9832            insertUsage: nextInsertUsage
9833          };
9834        }
9835    }
9836    return state;
9837  }
9838  
9839  /**
9840   * Reducer returning an object where each key is a block client ID, its value
9841   * representing the settings for its nested blocks.
9842   *
9843   * @param {Object} state  Current state.
9844   * @param {Object} action Dispatched action.
9845   *
9846   * @return {Object} Updated state.
9847   */
9848  const blockListSettings = (state = {}, action) => {
9849    switch (action.type) {
9850      // Even if the replaced blocks have the same client ID, our logic
9851      // should correct the state.
9852      case 'REPLACE_BLOCKS':
9853      case 'REMOVE_BLOCKS':
9854        {
9855          return Object.fromEntries(Object.entries(state).filter(([id]) => !action.clientIds.includes(id)));
9856        }
9857      case 'UPDATE_BLOCK_LIST_SETTINGS':
9858        {
9859          const updates = typeof action.clientId === 'string' ? {
9860            [action.clientId]: action.settings
9861          } : action.clientId;
9862  
9863          // Remove settings that are the same as the current state.
9864          for (const clientId in updates) {
9865            if (!updates[clientId]) {
9866              if (!state[clientId]) {
9867                delete updates[clientId];
9868              }
9869            } else if (es6_default()(state[clientId], updates[clientId])) {
9870              delete updates[clientId];
9871            }
9872          }
9873          if (Object.keys(updates).length === 0) {
9874            return state;
9875          }
9876          const merged = {
9877            ...state,
9878            ...updates
9879          };
9880          for (const clientId in updates) {
9881            if (!updates[clientId]) {
9882              delete merged[clientId];
9883            }
9884          }
9885          return merged;
9886        }
9887    }
9888    return state;
9889  };
9890  
9891  /**
9892   * Reducer return an updated state representing the most recent block attribute
9893   * update. The state is structured as an object where the keys represent the
9894   * client IDs of blocks, the values a subset of attributes from the most recent
9895   * block update. The state is always reset to null if the last action is
9896   * anything other than an attributes update.
9897   *
9898   * @param {Object<string,Object>} state  Current state.
9899   * @param {Object}                action Action object.
9900   *
9901   * @return {[string,Object]} Updated state.
9902   */
9903  function lastBlockAttributesChange(state = null, action) {
9904    switch (action.type) {
9905      case 'UPDATE_BLOCK':
9906        if (!action.updates.attributes) {
9907          break;
9908        }
9909        return {
9910          [action.clientId]: action.updates.attributes
9911        };
9912      case 'UPDATE_BLOCK_ATTRIBUTES':
9913        return action.clientIds.reduce((accumulator, id) => ({
9914          ...accumulator,
9915          [id]: action.uniqueByBlock ? action.attributes[id] : action.attributes
9916        }), {});
9917    }
9918    return state;
9919  }
9920  
9921  /**
9922   * Reducer returning current highlighted block.
9923   *
9924   * @param {boolean} state  Current highlighted block.
9925   * @param {Object}  action Dispatched action.
9926   *
9927   * @return {string} Updated state.
9928   */
9929  function highlightedBlock(state, action) {
9930    switch (action.type) {
9931      case 'TOGGLE_BLOCK_HIGHLIGHT':
9932        const {
9933          clientId,
9934          isHighlighted
9935        } = action;
9936        if (isHighlighted) {
9937          return clientId;
9938        } else if (state === clientId) {
9939          return null;
9940        }
9941        return state;
9942      case 'SELECT_BLOCK':
9943        if (action.clientId !== state) {
9944          return null;
9945        }
9946    }
9947    return state;
9948  }
9949  
9950  /**
9951   * Reducer returning current expanded block in the list view.
9952   *
9953   * @param {string|null} state  Current expanded block.
9954   * @param {Object}      action Dispatched action.
9955   *
9956   * @return {string|null} Updated state.
9957   */
9958  function expandedBlock(state = null, action) {
9959    switch (action.type) {
9960      case 'SET_BLOCK_EXPANDED_IN_LIST_VIEW':
9961        return action.clientId;
9962      case 'SELECT_BLOCK':
9963        if (action.clientId !== state) {
9964          return null;
9965        }
9966    }
9967    return state;
9968  }
9969  
9970  /**
9971   * Reducer returning the block insertion event list state.
9972   *
9973   * @param {Object} state  Current state.
9974   * @param {Object} action Dispatched action.
9975   *
9976   * @return {Object} Updated state.
9977   */
9978  function lastBlockInserted(state = {}, action) {
9979    switch (action.type) {
9980      case 'INSERT_BLOCKS':
9981      case 'REPLACE_BLOCKS':
9982        if (!action.blocks.length) {
9983          return state;
9984        }
9985        const clientIds = action.blocks.map(block => {
9986          return block.clientId;
9987        });
9988        const source = action.meta?.source;
9989        return {
9990          clientIds,
9991          source
9992        };
9993      case 'RESET_BLOCKS':
9994        return {};
9995    }
9996    return state;
9997  }
9998  
9999  /**
10000   * Reducer returning the block that is eding temporarily edited as blocks.
10001   *
10002   * @param {Object} state  Current state.
10003   * @param {Object} action Dispatched action.
10004   *
10005   * @return {Object} Updated state.
10006   */
10007  function temporarilyEditingAsBlocks(state = '', action) {
10008    if (action.type === 'SET_TEMPORARILY_EDITING_AS_BLOCKS') {
10009      return action.temporarilyEditingAsBlocks;
10010    }
10011    return state;
10012  }
10013  
10014  /**
10015   * Reducer returning the focus mode that should be used when temporarily edit as blocks finishes.
10016   *
10017   * @param {Object} state  Current state.
10018   * @param {Object} action Dispatched action.
10019   *
10020   * @return {Object} Updated state.
10021   */
10022  function temporarilyEditingFocusModeRevert(state = '', action) {
10023    if (action.type === 'SET_TEMPORARILY_EDITING_AS_BLOCKS') {
10024      return action.focusModeToRevert;
10025    }
10026    return state;
10027  }
10028  
10029  /**
10030   * Reducer returning a map of block client IDs to block editing modes.
10031   *
10032   * @param {Map}    state  Current state.
10033   * @param {Object} action Dispatched action.
10034   *
10035   * @return {Map} Updated state.
10036   */
10037  function blockEditingModes(state = new Map(), action) {
10038    switch (action.type) {
10039      case 'SET_BLOCK_EDITING_MODE':
10040        if (state.get(action.clientId) === action.mode) {
10041          return state;
10042        }
10043        return new Map(state).set(action.clientId, action.mode);
10044      case 'UNSET_BLOCK_EDITING_MODE':
10045        {
10046          if (!state.has(action.clientId)) {
10047            return state;
10048          }
10049          const newState = new Map(state);
10050          newState.delete(action.clientId);
10051          return newState;
10052        }
10053      case 'RESET_BLOCKS':
10054        {
10055          return state.has('') ? new Map().set('', state.get('')) : state;
10056        }
10057    }
10058    return state;
10059  }
10060  
10061  /**
10062   * Reducer returning the clientId of the block settings menu that is currently open.
10063   *
10064   * @param {string|null} state  Current state.
10065   * @param {Object}      action Dispatched action.
10066   *
10067   * @return {string|null} Updated state.
10068   */
10069  function openedBlockSettingsMenu(state = null, action) {
10070    if ('SET_OPENED_BLOCK_SETTINGS_MENU' === action.type) {
10071      var _action$clientId;
10072      return (_action$clientId = action?.clientId) !== null && _action$clientId !== void 0 ? _action$clientId : null;
10073    }
10074    return state;
10075  }
10076  
10077  /**
10078   * Reducer returning a map of style IDs to style overrides.
10079   *
10080   * @param {Map}    state  Current state.
10081   * @param {Object} action Dispatched action.
10082   *
10083   * @return {Map} Updated state.
10084   */
10085  function styleOverrides(state = new Map(), action) {
10086    switch (action.type) {
10087      case 'SET_STYLE_OVERRIDE':
10088        return new Map(state).set(action.id, action.style);
10089      case 'DELETE_STYLE_OVERRIDE':
10090        {
10091          const newState = new Map(state);
10092          newState.delete(action.id);
10093          return newState;
10094        }
10095    }
10096    return state;
10097  }
10098  
10099  /**
10100   * Reducer returning a map of the registered inserter media categories.
10101   *
10102   * @param {Array}  state  Current state.
10103   * @param {Object} action Dispatched action.
10104   *
10105   * @return {Array} Updated state.
10106   */
10107  function registeredInserterMediaCategories(state = [], action) {
10108    switch (action.type) {
10109      case 'REGISTER_INSERTER_MEDIA_CATEGORY':
10110        return [...state, action.category];
10111    }
10112    return state;
10113  }
10114  
10115  /**
10116   * Reducer setting last focused element
10117   *
10118   * @param {boolean} state  Current state.
10119   * @param {Object}  action Dispatched action.
10120   *
10121   * @return {boolean} Updated state.
10122   */
10123  function lastFocus(state = false, action) {
10124    switch (action.type) {
10125      case 'LAST_FOCUS':
10126        return action.lastFocus;
10127    }
10128    return state;
10129  }
10130  
10131  /**
10132   * Reducer setting currently hovered block.
10133   *
10134   * @param {boolean} state  Current state.
10135   * @param {Object}  action Dispatched action.
10136   *
10137   * @return {boolean} Updated state.
10138   */
10139  function hoveredBlockClientId(state = false, action) {
10140    switch (action.type) {
10141      case 'HOVER_BLOCK':
10142        return action.clientId;
10143    }
10144    return state;
10145  }
10146  
10147  /**
10148   * Reducer setting zoom out state.
10149   *
10150   * @param {boolean} state  Current state.
10151   * @param {Object}  action Dispatched action.
10152   *
10153   * @return {number} Updated state.
10154   */
10155  function zoomLevel(state = 100, action) {
10156    switch (action.type) {
10157      case 'SET_ZOOM_LEVEL':
10158        return action.zoom;
10159      case 'RESET_ZOOM_LEVEL':
10160        return 100;
10161    }
10162    return state;
10163  }
10164  
10165  /**
10166   * Reducer setting the insertion point
10167   *
10168   * @param {boolean} state  Current state.
10169   * @param {Object}  action Dispatched action.
10170   *
10171   * @return {Object} Updated state.
10172   */
10173  function insertionPoint(state = null, action) {
10174    switch (action.type) {
10175      case 'SET_INSERTION_POINT':
10176        return action.value;
10177      case 'SELECT_BLOCK':
10178        return null;
10179    }
10180    return state;
10181  }
10182  const combinedReducers = (0,external_wp_data_namespaceObject.combineReducers)({
10183    blocks,
10184    isDragging,
10185    isTyping,
10186    isBlockInterfaceHidden,
10187    draggedBlocks,
10188    selection,
10189    isMultiSelecting,
10190    isSelectionEnabled,
10191    initialPosition,
10192    blocksMode,
10193    blockListSettings,
10194    insertionPoint,
10195    insertionCue,
10196    template,
10197    settings,
10198    preferences,
10199    lastBlockAttributesChange,
10200    lastFocus,
10201    expandedBlock,
10202    highlightedBlock,
10203    lastBlockInserted,
10204    temporarilyEditingAsBlocks,
10205    temporarilyEditingFocusModeRevert,
10206    blockVisibility,
10207    blockEditingModes,
10208    styleOverrides,
10209    removalPromptData,
10210    blockRemovalRules,
10211    openedBlockSettingsMenu,
10212    registeredInserterMediaCategories,
10213    hoveredBlockClientId,
10214    zoomLevel
10215  });
10216  
10217  /**
10218   * Retrieves a block's tree structure, handling both controlled and uncontrolled inner blocks.
10219   *
10220   * @param {Object} state    The current state object.
10221   * @param {string} clientId The client ID of the block to retrieve.
10222   *
10223   * @return {Object|undefined} The block tree object, or undefined if not found. For controlled blocks,
10224   *                           returns a merged tree with controlled inner blocks.
10225   */
10226  function getBlockTreeBlock(state, clientId) {
10227    if (clientId === '') {
10228      const rootBlock = state.blocks.tree.get(clientId);
10229      if (!rootBlock) {
10230        return;
10231      }
10232  
10233      // Patch the root block to have a clientId property.
10234      // TODO - consider updating the blocks reducer so that the root block has this property.
10235      return {
10236        clientId: '',
10237        ...rootBlock
10238      };
10239    }
10240    if (!state.blocks.controlledInnerBlocks[clientId]) {
10241      return state.blocks.tree.get(clientId);
10242    }
10243    const controlledTree = state.blocks.tree.get(`controlled||$clientId}`);
10244    const regularTree = state.blocks.tree.get(clientId);
10245    return {
10246      ...regularTree,
10247      innerBlocks: controlledTree?.innerBlocks
10248    };
10249  }
10250  
10251  /**
10252   * Recursively traverses through a block tree of a given block and executes a callback for each block.
10253   *
10254   * @param {Object}   state    The store state.
10255   * @param {string}   clientId The clientId of the block to start traversing from.
10256   * @param {Function} callback Function to execute for each block encountered during traversal.
10257   *                            The callback receives the current block as its argument.
10258   */
10259  function traverseBlockTree(state, clientId, callback) {
10260    const tree = getBlockTreeBlock(state, clientId);
10261    if (!tree) {
10262      return;
10263    }
10264    callback(tree);
10265    if (!tree?.innerBlocks?.length) {
10266      return;
10267    }
10268    for (const innerBlock of tree?.innerBlocks) {
10269      traverseBlockTree(state, innerBlock.clientId, callback);
10270    }
10271  }
10272  
10273  /**
10274   * Checks if a block has a parent in a list of client IDs, and if so returns the client ID of the parent.
10275   *
10276   * @param {Object} state     The current state object.
10277   * @param {string} clientId  The client ID of the block to search the parents of.
10278   * @param {Array}  clientIds The client IDs of the blocks to check.
10279   *
10280   * @return {string|undefined} The client ID of the parent block if found, undefined otherwise.
10281   */
10282  function findParentInClientIdsList(state, clientId, clientIds) {
10283    if (!clientIds.length) {
10284      return;
10285    }
10286    let parent = state.blocks.parents.get(clientId);
10287    while (parent !== undefined) {
10288      if (clientIds.includes(parent)) {
10289        return parent;
10290      }
10291      parent = state.blocks.parents.get(parent);
10292    }
10293  }
10294  
10295  /**
10296   * Checks if a block has any bindings in its metadata attributes.
10297   *
10298   * @param {Object} block The block object to check for bindings.
10299   * @return {boolean}    True if the block has bindings, false otherwise.
10300   */
10301  function hasBindings(block) {
10302    return block?.attributes?.metadata?.bindings && Object.keys(block?.attributes?.metadata?.bindings).length;
10303  }
10304  
10305  /**
10306   * Computes and returns derived block editing modes for a given block tree.
10307   *
10308   * This function calculates the editing modes for each block in the tree, taking into account
10309   * various factors such as zoom level, navigation mode, sections, and synced patterns.
10310   *
10311   * @param {Object}  state        The current state object.
10312   * @param {boolean} isNavMode    Whether the navigation mode is active.
10313   * @param {string}  treeClientId The client ID of the root block for the tree. Defaults to an empty string.
10314   * @return {Map} A Map containing the derived block editing modes, keyed by block client ID.
10315   */
10316  function getDerivedBlockEditingModesForTree(state, isNavMode = false, treeClientId = '') {
10317    const isZoomedOut = state?.zoomLevel < 100 || state?.zoomLevel === 'auto-scaled';
10318    const derivedBlockEditingModes = new Map();
10319  
10320    // When there are sections, the majority of blocks are disabled,
10321    // so the default block editing mode is set to disabled.
10322    const sectionRootClientId = state.settings?.[sectionRootClientIdKey];
10323    const sectionClientIds = state.blocks.order.get(sectionRootClientId);
10324    const hasDisabledBlocks = Array.from(state.blockEditingModes).some(([, mode]) => mode === 'disabled');
10325    const templatePartClientIds = [];
10326    const syncedPatternClientIds = [];
10327    Object.keys(state.blocks.controlledInnerBlocks).forEach(clientId => {
10328      const block = state.blocks.byClientId?.get(clientId);
10329      if (block?.name === 'core/template-part') {
10330        templatePartClientIds.push(clientId);
10331      }
10332      if (block?.name === 'core/block') {
10333        syncedPatternClientIds.push(clientId);
10334      }
10335    });
10336    traverseBlockTree(state, treeClientId, block => {
10337      const {
10338        clientId,
10339        name: blockName
10340      } = block;
10341  
10342      // If the block already has an explicit block editing mode set,
10343      // don't override it.
10344      if (state.blockEditingModes.has(clientId)) {
10345        return;
10346      }
10347  
10348      // Disabled explicit block editing modes are inherited by children.
10349      // It's an expensive calculation, so only do it if there are disabled blocks.
10350      if (hasDisabledBlocks) {
10351        // Look through parents to find one with an explicit block editing mode.
10352        let ancestorBlockEditingMode;
10353        let parent = state.blocks.parents.get(clientId);
10354        while (parent !== undefined) {
10355          // There's a chance we only just calculated this for the parent,
10356          // if so we can return that value for a faster lookup.
10357          if (derivedBlockEditingModes.has(parent)) {
10358            ancestorBlockEditingMode = derivedBlockEditingModes.get(parent);
10359          } else if (state.blockEditingModes.has(parent)) {
10360            // Checking the explicit block editing mode will be slower,
10361            // as the block editing mode is more likely to be set on a
10362            // distant ancestor.
10363            ancestorBlockEditingMode = state.blockEditingModes.get(parent);
10364          }
10365          if (ancestorBlockEditingMode) {
10366            break;
10367          }
10368          parent = state.blocks.parents.get(parent);
10369        }
10370  
10371        // If the ancestor block editing mode is disabled, it's inherited by the child.
10372        if (ancestorBlockEditingMode === 'disabled') {
10373          derivedBlockEditingModes.set(clientId, 'disabled');
10374          return;
10375        }
10376      }
10377      if (isZoomedOut || isNavMode) {
10378        // If the root block is the section root set its editing mode to contentOnly.
10379        if (clientId === sectionRootClientId) {
10380          derivedBlockEditingModes.set(clientId, 'contentOnly');
10381          return;
10382        }
10383  
10384        // There are no sections, so everything else is disabled.
10385        if (!sectionClientIds?.length) {
10386          derivedBlockEditingModes.set(clientId, 'disabled');
10387          return;
10388        }
10389        if (sectionClientIds.includes(clientId)) {
10390          derivedBlockEditingModes.set(clientId, 'contentOnly');
10391          return;
10392        }
10393  
10394        // If zoomed out, all blocks that aren't sections or the section root are
10395        // disabled.
10396        if (isZoomedOut) {
10397          derivedBlockEditingModes.set(clientId, 'disabled');
10398          return;
10399        }
10400        const isInSection = !!findParentInClientIdsList(state, clientId, sectionClientIds);
10401        if (!isInSection) {
10402          if (clientId === '') {
10403            derivedBlockEditingModes.set(clientId, 'disabled');
10404            return;
10405          }
10406  
10407          // Allow selection of template parts outside of sections.
10408          if (blockName === 'core/template-part') {
10409            derivedBlockEditingModes.set(clientId, 'contentOnly');
10410            return;
10411          }
10412          const isInTemplatePart = !!findParentInClientIdsList(state, clientId, templatePartClientIds);
10413          // Allow contentOnly blocks in template parts outside of sections
10414          // to be editable. Only disable blocks that don't fit this criteria.
10415          if (!isInTemplatePart && !isContentBlock(blockName)) {
10416            derivedBlockEditingModes.set(clientId, 'disabled');
10417            return;
10418          }
10419        }
10420  
10421        // Handle synced pattern content so the inner blocks of a synced pattern are
10422        // properly disabled.
10423        if (syncedPatternClientIds.length) {
10424          const parentPatternClientId = findParentInClientIdsList(state, clientId, syncedPatternClientIds);
10425          if (parentPatternClientId) {
10426            // This is a pattern nested in another pattern, it should be disabled.
10427            if (findParentInClientIdsList(state, parentPatternClientId, syncedPatternClientIds)) {
10428              derivedBlockEditingModes.set(clientId, 'disabled');
10429              return;
10430            }
10431            if (hasBindings(block)) {
10432              derivedBlockEditingModes.set(clientId, 'contentOnly');
10433              return;
10434            }
10435  
10436            // Synced pattern content without a binding isn't editable
10437            // from the instance, the user has to edit the pattern source,
10438            // so return 'disabled'.
10439            derivedBlockEditingModes.set(clientId, 'disabled');
10440            return;
10441          }
10442        }
10443        if (blockName && isContentBlock(blockName)) {
10444          derivedBlockEditingModes.set(clientId, 'contentOnly');
10445          return;
10446        }
10447        derivedBlockEditingModes.set(clientId, 'disabled');
10448        return;
10449      }
10450      if (syncedPatternClientIds.length) {
10451        // Synced pattern blocks (core/block).
10452        if (syncedPatternClientIds.includes(clientId)) {
10453          // This is a pattern nested in another pattern, it should be disabled.
10454          if (findParentInClientIdsList(state, clientId, syncedPatternClientIds)) {
10455            derivedBlockEditingModes.set(clientId, 'disabled');
10456            return;
10457          }
10458  
10459          // Else do nothing, use the default block editing mode.
10460          return;
10461        }
10462  
10463        // Inner blocks of synced patterns.
10464        const parentPatternClientId = findParentInClientIdsList(state, clientId, syncedPatternClientIds);
10465        if (parentPatternClientId) {
10466          // This is a pattern nested in another pattern, it should be disabled.
10467          if (findParentInClientIdsList(state, parentPatternClientId, syncedPatternClientIds)) {
10468            derivedBlockEditingModes.set(clientId, 'disabled');
10469            return;
10470          }
10471          if (hasBindings(block)) {
10472            derivedBlockEditingModes.set(clientId, 'contentOnly');
10473            return;
10474          }
10475  
10476          // Synced pattern content without a binding isn't editable
10477          // from the instance, the user has to edit the pattern source,
10478          // so return 'disabled'.
10479          derivedBlockEditingModes.set(clientId, 'disabled');
10480        }
10481      }
10482    });
10483    return derivedBlockEditingModes;
10484  }
10485  
10486  /**
10487   * Updates the derived block editing modes based on added and removed blocks.
10488   *
10489   * This function handles the updating of block editing modes when blocks are added,
10490   * removed, or moved within the editor.
10491   *
10492   * It only returns a value when modifications are made to the block editing modes.
10493   *
10494   * @param {Object}  options                    The options for updating derived block editing modes.
10495   * @param {Object}  options.prevState          The previous state object.
10496   * @param {Object}  options.nextState          The next state object.
10497   * @param {Array}   [options.addedBlocks]      An array of blocks that were added.
10498   * @param {Array}   [options.removedClientIds] An array of client IDs of blocks that were removed.
10499   * @param {boolean} [options.isNavMode]        Whether the navigation mode is active.
10500   * @return {Map|undefined} The updated derived block editing modes, or undefined if no changes were made.
10501   */
10502  function getDerivedBlockEditingModesUpdates({
10503    prevState,
10504    nextState,
10505    addedBlocks,
10506    removedClientIds,
10507    isNavMode = false
10508  }) {
10509    const prevDerivedBlockEditingModes = isNavMode ? prevState.derivedNavModeBlockEditingModes : prevState.derivedBlockEditingModes;
10510    let nextDerivedBlockEditingModes;
10511  
10512    // Perform removals before additions to handle cases like the `MOVE_BLOCKS_TO_POSITION` action.
10513    // That action removes a set of clientIds, but adds the same blocks back in a different location.
10514    // If removals were performed after additions, those moved clientIds would be removed incorrectly.
10515    removedClientIds?.forEach(clientId => {
10516      // The actions only receive parent block IDs for removal.
10517      // Recurse through the block tree to ensure all blocks are removed.
10518      // Specifically use the previous state, before the blocks were removed.
10519      traverseBlockTree(prevState, clientId, block => {
10520        if (prevDerivedBlockEditingModes.has(block.clientId)) {
10521          if (!nextDerivedBlockEditingModes) {
10522            nextDerivedBlockEditingModes = new Map(prevDerivedBlockEditingModes);
10523          }
10524          nextDerivedBlockEditingModes.delete(block.clientId);
10525        }
10526      });
10527    });
10528    addedBlocks?.forEach(addedBlock => {
10529      traverseBlockTree(nextState, addedBlock.clientId, block => {
10530        const updates = getDerivedBlockEditingModesForTree(nextState, isNavMode, block.clientId);
10531        if (updates.size) {
10532          if (!nextDerivedBlockEditingModes) {
10533            nextDerivedBlockEditingModes = new Map([...(prevDerivedBlockEditingModes?.size ? prevDerivedBlockEditingModes : []), ...updates]);
10534          } else {
10535            nextDerivedBlockEditingModes = new Map([...(nextDerivedBlockEditingModes?.size ? nextDerivedBlockEditingModes : []), ...updates]);
10536          }
10537        }
10538      });
10539    });
10540    return nextDerivedBlockEditingModes;
10541  }
10542  
10543  /**
10544   * Higher-order reducer that adds derived block editing modes to the state.
10545   *
10546   * This function wraps a reducer and enhances it to handle actions that affect
10547   * block editing modes. It updates the derivedBlockEditingModes in the state
10548   * based on various actions such as adding, removing, or moving blocks, or changing
10549   * the editor mode.
10550   *
10551   * @param {Function} reducer The original reducer function to be wrapped.
10552   * @return {Function} A new reducer function that includes derived block editing modes handling.
10553   */
10554  function withDerivedBlockEditingModes(reducer) {
10555    return (state, action) => {
10556      var _state$derivedBlockEd, _state$derivedNavMode;
10557      const nextState = reducer(state, action);
10558  
10559      // An exception is needed here to still recompute the block editing modes when
10560      // the editor mode changes since the editor mode isn't stored within the
10561      // block editor state and changing it won't trigger an altered new state.
10562      if (action.type !== 'SET_EDITOR_MODE' && nextState === state) {
10563        return state;
10564      }
10565      switch (action.type) {
10566        case 'REMOVE_BLOCKS':
10567          {
10568            const nextDerivedBlockEditingModes = getDerivedBlockEditingModesUpdates({
10569              prevState: state,
10570              nextState,
10571              removedClientIds: action.clientIds,
10572              isNavMode: false
10573            });
10574            const nextDerivedNavModeBlockEditingModes = getDerivedBlockEditingModesUpdates({
10575              prevState: state,
10576              nextState,
10577              removedClientIds: action.clientIds,
10578              isNavMode: true
10579            });
10580            if (nextDerivedBlockEditingModes || nextDerivedNavModeBlockEditingModes) {
10581              return {
10582                ...nextState,
10583                derivedBlockEditingModes: nextDerivedBlockEditingModes !== null && nextDerivedBlockEditingModes !== void 0 ? nextDerivedBlockEditingModes : state.derivedBlockEditingModes,
10584                derivedNavModeBlockEditingModes: nextDerivedNavModeBlockEditingModes !== null && nextDerivedNavModeBlockEditingModes !== void 0 ? nextDerivedNavModeBlockEditingModes : state.derivedNavModeBlockEditingModes
10585              };
10586            }
10587            break;
10588          }
10589        case 'RECEIVE_BLOCKS':
10590        case 'INSERT_BLOCKS':
10591          {
10592            const nextDerivedBlockEditingModes = getDerivedBlockEditingModesUpdates({
10593              prevState: state,
10594              nextState,
10595              addedBlocks: action.blocks,
10596              isNavMode: false
10597            });
10598            const nextDerivedNavModeBlockEditingModes = getDerivedBlockEditingModesUpdates({
10599              prevState: state,
10600              nextState,
10601              addedBlocks: action.blocks,
10602              isNavMode: true
10603            });
10604            if (nextDerivedBlockEditingModes || nextDerivedNavModeBlockEditingModes) {
10605              return {
10606                ...nextState,
10607                derivedBlockEditingModes: nextDerivedBlockEditingModes !== null && nextDerivedBlockEditingModes !== void 0 ? nextDerivedBlockEditingModes : state.derivedBlockEditingModes,
10608                derivedNavModeBlockEditingModes: nextDerivedNavModeBlockEditingModes !== null && nextDerivedNavModeBlockEditingModes !== void 0 ? nextDerivedNavModeBlockEditingModes : state.derivedNavModeBlockEditingModes
10609              };
10610            }
10611            break;
10612          }
10613        case 'SET_BLOCK_EDITING_MODE':
10614        case 'UNSET_BLOCK_EDITING_MODE':
10615        case 'SET_HAS_CONTROLLED_INNER_BLOCKS':
10616          {
10617            const updatedBlock = getBlockTreeBlock(nextState, action.clientId);
10618  
10619            // The block might have been removed in which case it'll be
10620            // handled by the `REMOVE_BLOCKS` action.
10621            if (!updatedBlock) {
10622              break;
10623            }
10624            const nextDerivedBlockEditingModes = getDerivedBlockEditingModesUpdates({
10625              prevState: state,
10626              nextState,
10627              removedClientIds: [action.clientId],
10628              addedBlocks: [updatedBlock],
10629              isNavMode: false
10630            });
10631            const nextDerivedNavModeBlockEditingModes = getDerivedBlockEditingModesUpdates({
10632              prevState: state,
10633              nextState,
10634              removedClientIds: [action.clientId],
10635              addedBlocks: [updatedBlock],
10636              isNavMode: true
10637            });
10638            if (nextDerivedBlockEditingModes || nextDerivedNavModeBlockEditingModes) {
10639              return {
10640                ...nextState,
10641                derivedBlockEditingModes: nextDerivedBlockEditingModes !== null && nextDerivedBlockEditingModes !== void 0 ? nextDerivedBlockEditingModes : state.derivedBlockEditingModes,
10642                derivedNavModeBlockEditingModes: nextDerivedNavModeBlockEditingModes !== null && nextDerivedNavModeBlockEditingModes !== void 0 ? nextDerivedNavModeBlockEditingModes : state.derivedNavModeBlockEditingModes
10643              };
10644            }
10645            break;
10646          }
10647        case 'REPLACE_BLOCKS':
10648          {
10649            const nextDerivedBlockEditingModes = getDerivedBlockEditingModesUpdates({
10650              prevState: state,
10651              nextState,
10652              addedBlocks: action.blocks,
10653              removedClientIds: action.clientIds,
10654              isNavMode: false
10655            });
10656            const nextDerivedNavModeBlockEditingModes = getDerivedBlockEditingModesUpdates({
10657              prevState: state,
10658              nextState,
10659              addedBlocks: action.blocks,
10660              removedClientIds: action.clientIds,
10661              isNavMode: true
10662            });
10663            if (nextDerivedBlockEditingModes || nextDerivedNavModeBlockEditingModes) {
10664              return {
10665                ...nextState,
10666                derivedBlockEditingModes: nextDerivedBlockEditingModes !== null && nextDerivedBlockEditingModes !== void 0 ? nextDerivedBlockEditingModes : state.derivedBlockEditingModes,
10667                derivedNavModeBlockEditingModes: nextDerivedNavModeBlockEditingModes !== null && nextDerivedNavModeBlockEditingModes !== void 0 ? nextDerivedNavModeBlockEditingModes : state.derivedNavModeBlockEditingModes
10668              };
10669            }
10670            break;
10671          }
10672        case 'REPLACE_INNER_BLOCKS':
10673          {
10674            // Get the clientIds of the blocks that are being replaced
10675            // from the old state, before they were removed.
10676            const removedClientIds = state.blocks.order.get(action.rootClientId);
10677            const nextDerivedBlockEditingModes = getDerivedBlockEditingModesUpdates({
10678              prevState: state,
10679              nextState,
10680              addedBlocks: action.blocks,
10681              removedClientIds,
10682              isNavMode: false
10683            });
10684            const nextDerivedNavModeBlockEditingModes = getDerivedBlockEditingModesUpdates({
10685              prevState: state,
10686              nextState,
10687              addedBlocks: action.blocks,
10688              removedClientIds,
10689              isNavMode: true
10690            });
10691            if (nextDerivedBlockEditingModes || nextDerivedNavModeBlockEditingModes) {
10692              return {
10693                ...nextState,
10694                derivedBlockEditingModes: nextDerivedBlockEditingModes !== null && nextDerivedBlockEditingModes !== void 0 ? nextDerivedBlockEditingModes : state.derivedBlockEditingModes,
10695                derivedNavModeBlockEditingModes: nextDerivedNavModeBlockEditingModes !== null && nextDerivedNavModeBlockEditingModes !== void 0 ? nextDerivedNavModeBlockEditingModes : state.derivedNavModeBlockEditingModes
10696              };
10697            }
10698            break;
10699          }
10700        case 'MOVE_BLOCKS_TO_POSITION':
10701          {
10702            const addedBlocks = action.clientIds.map(clientId => {
10703              return nextState.blocks.byClientId.get(clientId);
10704            });
10705            const nextDerivedBlockEditingModes = getDerivedBlockEditingModesUpdates({
10706              prevState: state,
10707              nextState,
10708              addedBlocks,
10709              removedClientIds: action.clientIds,
10710              isNavMode: false
10711            });
10712            const nextDerivedNavModeBlockEditingModes = getDerivedBlockEditingModesUpdates({
10713              prevState: state,
10714              nextState,
10715              addedBlocks,
10716              removedClientIds: action.clientIds,
10717              isNavMode: true
10718            });
10719            if (nextDerivedBlockEditingModes || nextDerivedNavModeBlockEditingModes) {
10720              return {
10721                ...nextState,
10722                derivedBlockEditingModes: nextDerivedBlockEditingModes !== null && nextDerivedBlockEditingModes !== void 0 ? nextDerivedBlockEditingModes : state.derivedBlockEditingModes,
10723                derivedNavModeBlockEditingModes: nextDerivedNavModeBlockEditingModes !== null && nextDerivedNavModeBlockEditingModes !== void 0 ? nextDerivedNavModeBlockEditingModes : state.derivedNavModeBlockEditingModes
10724              };
10725            }
10726            break;
10727          }
10728        case 'UPDATE_SETTINGS':
10729          {
10730            // Recompute the entire tree if the section root changes.
10731            if (state?.settings?.[sectionRootClientIdKey] !== nextState?.settings?.[sectionRootClientIdKey]) {
10732              return {
10733                ...nextState,
10734                derivedBlockEditingModes: getDerivedBlockEditingModesForTree(nextState, false /* Nav mode off */),
10735                derivedNavModeBlockEditingModes: getDerivedBlockEditingModesForTree(nextState, true /* Nav mode on */)
10736              };
10737            }
10738            break;
10739          }
10740        case 'RESET_BLOCKS':
10741        case 'SET_EDITOR_MODE':
10742        case 'RESET_ZOOM_LEVEL':
10743        case 'SET_ZOOM_LEVEL':
10744          {
10745            // Recompute the entire tree if the editor mode or zoom level changes,
10746            // or if all the blocks are reset.
10747            return {
10748              ...nextState,
10749              derivedBlockEditingModes: getDerivedBlockEditingModesForTree(nextState, false /* Nav mode off */),
10750              derivedNavModeBlockEditingModes: getDerivedBlockEditingModesForTree(nextState, true /* Nav mode on */)
10751            };
10752          }
10753      }
10754  
10755      // If there's no change, the derivedBlockEditingModes from the previous
10756      // state need to be preserved.
10757      nextState.derivedBlockEditingModes = (_state$derivedBlockEd = state?.derivedBlockEditingModes) !== null && _state$derivedBlockEd !== void 0 ? _state$derivedBlockEd : new Map();
10758      nextState.derivedNavModeBlockEditingModes = (_state$derivedNavMode = state?.derivedNavModeBlockEditingModes) !== null && _state$derivedNavMode !== void 0 ? _state$derivedNavMode : new Map();
10759      return nextState;
10760    };
10761  }
10762  function withAutomaticChangeReset(reducer) {
10763    return (state, action) => {
10764      const nextState = reducer(state, action);
10765      if (!state) {
10766        return nextState;
10767      }
10768  
10769      // Take over the last value without creating a new reference.
10770      nextState.automaticChangeStatus = state.automaticChangeStatus;
10771      if (action.type === 'MARK_AUTOMATIC_CHANGE') {
10772        return {
10773          ...nextState,
10774          automaticChangeStatus: 'pending'
10775        };
10776      }
10777      if (action.type === 'MARK_AUTOMATIC_CHANGE_FINAL' && state.automaticChangeStatus === 'pending') {
10778        return {
10779          ...nextState,
10780          automaticChangeStatus: 'final'
10781        };
10782      }
10783  
10784      // If there's a change that doesn't affect blocks or selection, maintain
10785      // the current status.
10786      if (nextState.blocks === state.blocks && nextState.selection === state.selection) {
10787        return nextState;
10788      }
10789  
10790      // As long as the state is not final, ignore any selection changes.
10791      if (nextState.automaticChangeStatus !== 'final' && nextState.selection !== state.selection) {
10792        return nextState;
10793      }
10794  
10795      // Reset the status if blocks change or selection changes (when status is final).
10796      return {
10797        ...nextState,
10798        automaticChangeStatus: undefined
10799      };
10800    };
10801  }
10802  /* harmony default export */ const reducer = ((0,external_wp_compose_namespaceObject.pipe)(withDerivedBlockEditingModes, withAutomaticChangeReset)(combinedReducers));
10803  
10804  ;// external ["wp","primitives"]
10805  const external_wp_primitives_namespaceObject = window["wp"]["primitives"];
10806  ;// external "ReactJSXRuntime"
10807  const external_ReactJSXRuntime_namespaceObject = window["ReactJSXRuntime"];
10808  ;// ./node_modules/@wordpress/icons/build-module/library/symbol.js
10809  /**
10810   * WordPress dependencies
10811   */
10812  
10813  
10814  const symbol = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
10815    xmlns: "http://www.w3.org/2000/svg",
10816    viewBox: "0 0 24 24",
10817    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
10818      d: "M21.3 10.8l-5.6-5.6c-.7-.7-1.8-.7-2.5 0l-5.6 5.6c-.7.7-.7 1.8 0 2.5l5.6 5.6c.3.3.8.5 1.2.5s.9-.2 1.2-.5l5.6-5.6c.8-.7.8-1.9.1-2.5zm-1 1.4l-5.6 5.6c-.1.1-.3.1-.4 0l-5.6-5.6c-.1-.1-.1-.3 0-.4l5.6-5.6s.1-.1.2-.1.1 0 .2.1l5.6 5.6c.1.1.1.3 0 .4zm-16.6-.4L10 5.5l-1-1-6.3 6.3c-.7.7-.7 1.8 0 2.5L9 19.5l1.1-1.1-6.3-6.3c-.2 0-.2-.2-.1-.3z"
10819    })
10820  });
10821  /* harmony default export */ const library_symbol = (symbol);
10822  
10823  ;// external ["wp","richText"]
10824  const external_wp_richText_namespaceObject = window["wp"]["richText"];
10825  ;// external ["wp","preferences"]
10826  const external_wp_preferences_namespaceObject = window["wp"]["preferences"];
10827  ;// external ["wp","blockSerializationDefaultParser"]
10828  const external_wp_blockSerializationDefaultParser_namespaceObject = window["wp"]["blockSerializationDefaultParser"];
10829  ;// ./node_modules/@wordpress/block-editor/build-module/store/constants.js
10830  const STORE_NAME = 'core/block-editor';
10831  
10832  ;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/block-patterns-tab/utils.js
10833  /**
10834   * WordPress dependencies
10835   */
10836  
10837  
10838  const INSERTER_PATTERN_TYPES = {
10839    user: 'user',
10840    theme: 'theme',
10841    directory: 'directory'
10842  };
10843  const INSERTER_SYNC_TYPES = {
10844    full: 'fully',
10845    unsynced: 'unsynced'
10846  };
10847  const allPatternsCategory = {
10848    name: 'allPatterns',
10849    label: (0,external_wp_i18n_namespaceObject._x)('All', 'patterns')
10850  };
10851  const myPatternsCategory = {
10852    name: 'myPatterns',
10853    label: (0,external_wp_i18n_namespaceObject.__)('My patterns')
10854  };
10855  const starterPatternsCategory = {
10856    name: 'core/starter-content',
10857    label: (0,external_wp_i18n_namespaceObject.__)('Starter content')
10858  };
10859  function isPatternFiltered(pattern, sourceFilter, syncFilter) {
10860    const isUserPattern = pattern.name.startsWith('core/block');
10861    const isDirectoryPattern = pattern.source === 'core' || pattern.source?.startsWith('pattern-directory');
10862  
10863    // If theme source selected, filter out user created patterns and those from
10864    // the core patterns directory.
10865    if (sourceFilter === INSERTER_PATTERN_TYPES.theme && (isUserPattern || isDirectoryPattern)) {
10866      return true;
10867    }
10868  
10869    // If the directory source is selected, filter out user created patterns
10870    // and those bundled with the theme.
10871    if (sourceFilter === INSERTER_PATTERN_TYPES.directory && (isUserPattern || !isDirectoryPattern)) {
10872      return true;
10873    }
10874  
10875    // If user source selected, filter out theme patterns.
10876    if (sourceFilter === INSERTER_PATTERN_TYPES.user && pattern.type !== INSERTER_PATTERN_TYPES.user) {
10877      return true;
10878    }
10879  
10880    // Filter by sync status.
10881    if (syncFilter === INSERTER_SYNC_TYPES.full && pattern.syncStatus !== '') {
10882      return true;
10883    }
10884    if (syncFilter === INSERTER_SYNC_TYPES.unsynced && pattern.syncStatus !== 'unsynced' && isUserPattern) {
10885      return true;
10886    }
10887    return false;
10888  }
10889  
10890  ;// ./node_modules/@wordpress/block-editor/build-module/utils/object.js
10891  /**
10892   * Immutably sets a value inside an object. Like `lodash#set`, but returning a
10893   * new object. Treats nullish initial values as empty objects. Clones any
10894   * nested objects. Supports arrays, too.
10895   *
10896   * @param {Object}              object Object to set a value in.
10897   * @param {number|string|Array} path   Path in the object to modify.
10898   * @param {*}                   value  New value to set.
10899   * @return {Object} Cloned object with the new value set.
10900   */
10901  function setImmutably(object, path, value) {
10902    // Normalize path
10903    path = Array.isArray(path) ? [...path] : [path];
10904  
10905    // Shallowly clone the base of the object
10906    object = Array.isArray(object) ? [...object] : {
10907      ...object
10908    };
10909    const leaf = path.pop();
10910  
10911    // Traverse object from root to leaf, shallowly cloning at each level
10912    let prev = object;
10913    for (const key of path) {
10914      const lvl = prev[key];
10915      prev = prev[key] = Array.isArray(lvl) ? [...lvl] : {
10916        ...lvl
10917      };
10918    }
10919    prev[leaf] = value;
10920    return object;
10921  }
10922  
10923  /**
10924   * Helper util to return a value from a certain path of the object.
10925   * Path is specified as either:
10926   * - a string of properties, separated by dots, for example: "x.y".
10927   * - an array of properties, for example `[ 'x', 'y' ]`.
10928   * You can also specify a default value in case the result is nullish.
10929   *
10930   * @param {Object}       object       Input object.
10931   * @param {string|Array} path         Path to the object property.
10932   * @param {*}            defaultValue Default value if the value at the specified path is nullish.
10933   * @return {*} Value of the object property at the specified path.
10934   */
10935  const getValueFromObjectPath = (object, path, defaultValue) => {
10936    var _value;
10937    const arrayPath = Array.isArray(path) ? path : path.split('.');
10938    let value = object;
10939    arrayPath.forEach(fieldName => {
10940      value = value?.[fieldName];
10941    });
10942    return (_value = value) !== null && _value !== void 0 ? _value : defaultValue;
10943  };
10944  
10945  /**
10946   * Helper util to filter out objects with duplicate values for a given property.
10947   *
10948   * @param {Object[]} array    Array of objects to filter.
10949   * @param {string}   property Property to filter unique values by.
10950   *
10951   * @return {Object[]} Array of objects with unique values for the specified property.
10952   */
10953  function uniqByProperty(array, property) {
10954    const seen = new Set();
10955    return array.filter(item => {
10956      const value = item[property];
10957      return seen.has(value) ? false : seen.add(value);
10958    });
10959  }
10960  
10961  ;// ./node_modules/@wordpress/block-editor/build-module/store/get-block-settings.js
10962  /**
10963   * WordPress dependencies
10964   */
10965  
10966  
10967  
10968  /**
10969   * Internal dependencies
10970   */
10971  
10972  
10973  const blockedPaths = ['color', 'border', 'dimensions', 'typography', 'spacing'];
10974  const deprecatedFlags = {
10975    'color.palette': settings => settings.colors,
10976    'color.gradients': settings => settings.gradients,
10977    'color.custom': settings => settings.disableCustomColors === undefined ? undefined : !settings.disableCustomColors,
10978    'color.customGradient': settings => settings.disableCustomGradients === undefined ? undefined : !settings.disableCustomGradients,
10979    'typography.fontSizes': settings => settings.fontSizes,
10980    'typography.customFontSize': settings => settings.disableCustomFontSizes === undefined ? undefined : !settings.disableCustomFontSizes,
10981    'typography.lineHeight': settings => settings.enableCustomLineHeight,
10982    'spacing.units': settings => {
10983      if (settings.enableCustomUnits === undefined) {
10984        return;
10985      }
10986      if (settings.enableCustomUnits === true) {
10987        return ['px', 'em', 'rem', 'vh', 'vw', '%'];
10988      }
10989      return settings.enableCustomUnits;
10990    },
10991    'spacing.padding': settings => settings.enableCustomSpacing
10992  };
10993  const prefixedFlags = {
10994    /*
10995     * These were only available in the plugin
10996     * and can be removed when the minimum WordPress version
10997     * for the plugin is 5.9.
10998     */
10999    'border.customColor': 'border.color',
11000    'border.customStyle': 'border.style',
11001    'border.customWidth': 'border.width',
11002    'typography.customFontStyle': 'typography.fontStyle',
11003    'typography.customFontWeight': 'typography.fontWeight',
11004    'typography.customLetterSpacing': 'typography.letterSpacing',
11005    'typography.customTextDecorations': 'typography.textDecoration',
11006    'typography.customTextTransforms': 'typography.textTransform',
11007    /*
11008     * These were part of WordPress 5.8 and we need to keep them.
11009     */
11010    'border.customRadius': 'border.radius',
11011    'spacing.customMargin': 'spacing.margin',
11012    'spacing.customPadding': 'spacing.padding',
11013    'typography.customLineHeight': 'typography.lineHeight'
11014  };
11015  
11016  /**
11017   * Remove `custom` prefixes for flags that did not land in 5.8.
11018   *
11019   * This provides continued support for `custom` prefixed properties. It will
11020   * be removed once third party devs have had sufficient time to update themes,
11021   * plugins, etc.
11022   *
11023   * @see https://github.com/WordPress/gutenberg/pull/34485
11024   *
11025   * @param {string} path Path to desired value in settings.
11026   * @return {string}     The value for defined setting.
11027   */
11028  const removeCustomPrefixes = path => {
11029    return prefixedFlags[path] || path;
11030  };
11031  function getBlockSettings(state, clientId, ...paths) {
11032    const blockName = getBlockName(state, clientId);
11033    const candidates = [];
11034    if (clientId) {
11035      let id = clientId;
11036      do {
11037        const name = getBlockName(state, id);
11038        if ((0,external_wp_blocks_namespaceObject.hasBlockSupport)(name, '__experimentalSettings', false)) {
11039          candidates.push(id);
11040        }
11041      } while (id = state.blocks.parents.get(id));
11042    }
11043    return paths.map(path => {
11044      if (blockedPaths.includes(path)) {
11045        // eslint-disable-next-line no-console
11046        console.warn('Top level useSetting paths are disabled. Please use a subpath to query the information needed.');
11047        return undefined;
11048      }
11049  
11050      // 0. Allow third parties to filter the block's settings at runtime.
11051      let result = (0,external_wp_hooks_namespaceObject.applyFilters)('blockEditor.useSetting.before', undefined, path, clientId, blockName);
11052      if (undefined !== result) {
11053        return result;
11054      }
11055      const normalizedPath = removeCustomPrefixes(path);
11056  
11057      // 1. Take settings from the block instance or its ancestors.
11058      // Start from the current block and work our way up the ancestors.
11059      for (const candidateClientId of candidates) {
11060        var _getValueFromObjectPa;
11061        const candidateAtts = getBlockAttributes(state, candidateClientId);
11062        result = (_getValueFromObjectPa = getValueFromObjectPath(candidateAtts.settings?.blocks?.[blockName], normalizedPath)) !== null && _getValueFromObjectPa !== void 0 ? _getValueFromObjectPa : getValueFromObjectPath(candidateAtts.settings, normalizedPath);
11063        if (result !== undefined) {
11064          // Stop the search for more distant ancestors and move on.
11065          break;
11066        }
11067      }
11068  
11069      // 2. Fall back to the settings from the block editor store (__experimentalFeatures).
11070      const settings = getSettings(state);
11071      if (result === undefined && blockName) {
11072        result = getValueFromObjectPath(settings.__experimentalFeatures?.blocks?.[blockName], normalizedPath);
11073      }
11074      if (result === undefined) {
11075        result = getValueFromObjectPath(settings.__experimentalFeatures, normalizedPath);
11076      }
11077  
11078      // Return if the setting was found in either the block instance or the store.
11079      if (result !== undefined) {
11080        if (external_wp_blocks_namespaceObject.__EXPERIMENTAL_PATHS_WITH_OVERRIDE[normalizedPath]) {
11081          var _ref, _result$custom;
11082          return (_ref = (_result$custom = result.custom) !== null && _result$custom !== void 0 ? _result$custom : result.theme) !== null && _ref !== void 0 ? _ref : result.default;
11083        }
11084        return result;
11085      }
11086  
11087      // 3. Otherwise, use deprecated settings.
11088      const deprecatedSettingsValue = deprecatedFlags[normalizedPath]?.(settings);
11089      if (deprecatedSettingsValue !== undefined) {
11090        return deprecatedSettingsValue;
11091      }
11092  
11093      // 4. Fallback for typography.dropCap:
11094      // This is only necessary to support typography.dropCap.
11095      // when __experimentalFeatures are not present (core without plugin).
11096      // To remove when __experimentalFeatures are ported to core.
11097      return normalizedPath === 'typography.dropCap' ? true : undefined;
11098    });
11099  }
11100  
11101  ;// ./node_modules/@wordpress/block-editor/build-module/store/private-selectors.js
11102  /**
11103   * WordPress dependencies
11104   */
11105  
11106  
11107  /**
11108   * Internal dependencies
11109   */
11110  
11111  
11112  
11113  
11114  
11115  
11116  
11117  
11118  /**
11119   * Returns true if the block interface is hidden, or false otherwise.
11120   *
11121   * @param {Object} state Global application state.
11122   *
11123   * @return {boolean} Whether the block toolbar is hidden.
11124   */
11125  function private_selectors_isBlockInterfaceHidden(state) {
11126    return state.isBlockInterfaceHidden;
11127  }
11128  
11129  /**
11130   * Gets the client ids of the last inserted blocks.
11131   *
11132   * @param {Object} state Global application state.
11133   * @return {Array|undefined} Client Ids of the last inserted block(s).
11134   */
11135  function getLastInsertedBlocksClientIds(state) {
11136    return state?.lastBlockInserted?.clientIds;
11137  }
11138  function getBlockWithoutAttributes(state, clientId) {
11139    return state.blocks.byClientId.get(clientId);
11140  }
11141  
11142  /**
11143   * Returns true if all of the descendants of a block with the given client ID
11144   * have an editing mode of 'disabled', or false otherwise.
11145   *
11146   * @param {Object} state    Global application state.
11147   * @param {string} clientId The block client ID.
11148   *
11149   * @return {boolean} Whether the block descendants are disabled.
11150   */
11151  const isBlockSubtreeDisabled = (state, clientId) => {
11152    const isChildSubtreeDisabled = childClientId => {
11153      return getBlockEditingMode(state, childClientId) === 'disabled' && getBlockOrder(state, childClientId).every(isChildSubtreeDisabled);
11154    };
11155    return getBlockOrder(state, clientId).every(isChildSubtreeDisabled);
11156  };
11157  function getEnabledClientIdsTreeUnmemoized(state, rootClientId) {
11158    const blockOrder = getBlockOrder(state, rootClientId);
11159    const result = [];
11160    for (const clientId of blockOrder) {
11161      const innerBlocks = getEnabledClientIdsTreeUnmemoized(state, clientId);
11162      if (getBlockEditingMode(state, clientId) !== 'disabled') {
11163        result.push({
11164          clientId,
11165          innerBlocks
11166        });
11167      } else {
11168        result.push(...innerBlocks);
11169      }
11170    }
11171    return result;
11172  }
11173  
11174  /**
11175   * Returns a tree of block objects with only clientID and innerBlocks set.
11176   * Blocks with a 'disabled' editing mode are not included.
11177   *
11178   * @param {Object}  state        Global application state.
11179   * @param {?string} rootClientId Optional root client ID of block list.
11180   *
11181   * @return {Object[]} Tree of block objects with only clientID and innerBlocks set.
11182   */
11183  const getEnabledClientIdsTree = (0,external_wp_data_namespaceObject.createRegistrySelector)(select => (0,external_wp_data_namespaceObject.createSelector)(getEnabledClientIdsTreeUnmemoized, state => [state.blocks.order, state.derivedBlockEditingModes, state.derivedNavModeBlockEditingModes, state.blockEditingModes, state.settings.templateLock, state.blockListSettings, select(STORE_NAME).__unstableGetEditorMode(state)]));
11184  
11185  /**
11186   * Returns a list of a given block's ancestors, from top to bottom. Blocks with
11187   * a 'disabled' editing mode are excluded.
11188   *
11189   * @see getBlockParents
11190   *
11191   * @param {Object}  state     Global application state.
11192   * @param {string}  clientId  The block client ID.
11193   * @param {boolean} ascending Order results from bottom to top (true) or top
11194   *                            to bottom (false).
11195   */
11196  const getEnabledBlockParents = (0,external_wp_data_namespaceObject.createSelector)((state, clientId, ascending = false) => {
11197    return getBlockParents(state, clientId, ascending).filter(parent => getBlockEditingMode(state, parent) !== 'disabled');
11198  }, state => [state.blocks.parents, state.blockEditingModes, state.settings.templateLock, state.blockListSettings]);
11199  
11200  /**
11201   * Selector that returns the data needed to display a prompt when certain
11202   * blocks are removed, or `false` if no such prompt is requested.
11203   *
11204   * @param {Object} state Global application state.
11205   *
11206   * @return {Object|false} Data for removal prompt display, if any.
11207   */
11208  function getRemovalPromptData(state) {
11209    return state.removalPromptData;
11210  }
11211  
11212  /**
11213   * Returns true if removal prompt exists, or false otherwise.
11214   *
11215   * @param {Object} state Global application state.
11216   *
11217   * @return {boolean} Whether removal prompt exists.
11218   */
11219  function getBlockRemovalRules(state) {
11220    return state.blockRemovalRules;
11221  }
11222  
11223  /**
11224   * Returns the client ID of the block settings menu that is currently open.
11225   *
11226   * @param {Object} state Global application state.
11227   * @return {string|null} The client ID of the block menu that is currently open.
11228   */
11229  function getOpenedBlockSettingsMenu(state) {
11230    return state.openedBlockSettingsMenu;
11231  }
11232  
11233  /**
11234   * Returns all style overrides, intended to be merged with global editor styles.
11235   *
11236   * Overrides are sorted to match the order of the blocks they relate to. This
11237   * is useful to maintain correct CSS cascade order.
11238   *
11239   * @param {Object} state Global application state.
11240   *
11241   * @return {Array} An array of style ID to style override pairs.
11242   */
11243  const getStyleOverrides = (0,external_wp_data_namespaceObject.createSelector)(state => {
11244    const clientIds = getClientIdsWithDescendants(state);
11245    const clientIdMap = clientIds.reduce((acc, clientId, index) => {
11246      acc[clientId] = index;
11247      return acc;
11248    }, {});
11249    return [...state.styleOverrides].sort((overrideA, overrideB) => {
11250      var _clientIdMap$clientId, _clientIdMap$clientId2;
11251      // Once the overrides Map is spread to an array, the first element
11252      // is the key, while the second is the override itself including
11253      // the clientId to sort by.
11254      const [, {
11255        clientId: clientIdA
11256      }] = overrideA;
11257      const [, {
11258        clientId: clientIdB
11259      }] = overrideB;
11260      const aIndex = (_clientIdMap$clientId = clientIdMap[clientIdA]) !== null && _clientIdMap$clientId !== void 0 ? _clientIdMap$clientId : -1;
11261      const bIndex = (_clientIdMap$clientId2 = clientIdMap[clientIdB]) !== null && _clientIdMap$clientId2 !== void 0 ? _clientIdMap$clientId2 : -1;
11262      return aIndex - bIndex;
11263    });
11264  }, state => [state.blocks.order, state.styleOverrides]);
11265  
11266  /** @typedef {import('./actions').InserterMediaCategory} InserterMediaCategory */
11267  /**
11268   * Returns the registered inserter media categories through the public API.
11269   *
11270   * @param {Object} state Editor state.
11271   *
11272   * @return {InserterMediaCategory[]} Inserter media categories.
11273   */
11274  function getRegisteredInserterMediaCategories(state) {
11275    return state.registeredInserterMediaCategories;
11276  }
11277  
11278  /**
11279   * Returns an array containing the allowed inserter media categories.
11280   * It merges the registered media categories from extenders with the
11281   * core ones. It also takes into account the allowed `mime_types`, which
11282   * can be altered by `upload_mimes` filter and restrict some of them.
11283   *
11284   * @param {Object} state Global application state.
11285   *
11286   * @return {InserterMediaCategory[]} Client IDs of descendants.
11287   */
11288  const getInserterMediaCategories = (0,external_wp_data_namespaceObject.createSelector)(state => {
11289    const {
11290      settings: {
11291        inserterMediaCategories,
11292        allowedMimeTypes,
11293        enableOpenverseMediaCategory
11294      },
11295      registeredInserterMediaCategories
11296    } = state;
11297    // The allowed `mime_types` can be altered by `upload_mimes` filter and restrict
11298    // some of them. In this case we shouldn't add the category to the available media
11299    // categories list in the inserter.
11300    if (!inserterMediaCategories && !registeredInserterMediaCategories.length || !allowedMimeTypes) {
11301      return;
11302    }
11303    const coreInserterMediaCategoriesNames = inserterMediaCategories?.map(({
11304      name
11305    }) => name) || [];
11306    const mergedCategories = [...(inserterMediaCategories || []), ...(registeredInserterMediaCategories || []).filter(({
11307      name
11308    }) => !coreInserterMediaCategoriesNames.includes(name))];
11309    return mergedCategories.filter(category => {
11310      // Check if Openverse category is enabled.
11311      if (!enableOpenverseMediaCategory && category.name === 'openverse') {
11312        return false;
11313      }
11314      return Object.values(allowedMimeTypes).some(mimeType => mimeType.startsWith(`$category.mediaType}/`));
11315    });
11316  }, state => [state.settings.inserterMediaCategories, state.settings.allowedMimeTypes, state.settings.enableOpenverseMediaCategory, state.registeredInserterMediaCategories]);
11317  
11318  /**
11319   * Returns whether there is at least one allowed pattern for inner blocks children.
11320   * This is useful for deferring the parsing of all patterns until needed.
11321   *
11322   * @param {Object} state               Editor state.
11323   * @param {string} [rootClientId=null] Target root client ID.
11324   *
11325   * @return {boolean} If there is at least one allowed pattern.
11326   */
11327  const hasAllowedPatterns = (0,external_wp_data_namespaceObject.createRegistrySelector)(select => (0,external_wp_data_namespaceObject.createSelector)((state, rootClientId = null) => {
11328    const {
11329      getAllPatterns
11330    } = unlock(select(STORE_NAME));
11331    const patterns = getAllPatterns();
11332    const {
11333      allowedBlockTypes
11334    } = getSettings(state);
11335    return patterns.some(pattern => {
11336      const {
11337        inserter = true
11338      } = pattern;
11339      if (!inserter) {
11340        return false;
11341      }
11342      const grammar = getGrammar(pattern);
11343      return checkAllowListRecursive(grammar, allowedBlockTypes) && grammar.every(({
11344        name: blockName
11345      }) => canInsertBlockType(state, blockName, rootClientId));
11346    });
11347  }, (state, rootClientId) => [...getAllPatternsDependants(select)(state), ...getInsertBlockTypeDependants(select)(state, rootClientId)]));
11348  function mapUserPattern(userPattern, __experimentalUserPatternCategories = []) {
11349    return {
11350      name: `core/block/$userPattern.id}`,
11351      id: userPattern.id,
11352      type: INSERTER_PATTERN_TYPES.user,
11353      title: userPattern.title.raw,
11354      categories: userPattern.wp_pattern_category?.map(catId => {
11355        const category = __experimentalUserPatternCategories.find(({
11356          id
11357        }) => id === catId);
11358        return category ? category.slug : catId;
11359      }),
11360      content: userPattern.content.raw,
11361      syncStatus: userPattern.wp_pattern_sync_status
11362    };
11363  }
11364  const getPatternBySlug = (0,external_wp_data_namespaceObject.createRegistrySelector)(select => (0,external_wp_data_namespaceObject.createSelector)((state, patternName) => {
11365    var _state$settings$__exp, _state$settings$selec;
11366    // Only fetch reusable blocks if we know we need them. To do: maybe
11367    // use the entity record API to retrieve the block by slug.
11368    if (patternName?.startsWith('core/block/')) {
11369      const _id = parseInt(patternName.slice('core/block/'.length), 10);
11370      const block = unlock(select(STORE_NAME)).getReusableBlocks().find(({
11371        id
11372      }) => id === _id);
11373      if (!block) {
11374        return null;
11375      }
11376      return mapUserPattern(block, state.settings.__experimentalUserPatternCategories);
11377    }
11378    return [
11379    // This setting is left for back compat.
11380    ...((_state$settings$__exp = state.settings.__experimentalBlockPatterns) !== null && _state$settings$__exp !== void 0 ? _state$settings$__exp : []), ...((_state$settings$selec = state.settings[selectBlockPatternsKey]?.(select)) !== null && _state$settings$selec !== void 0 ? _state$settings$selec : [])].find(({
11381      name
11382    }) => name === patternName);
11383  }, (state, patternName) => patternName?.startsWith('core/block/') ? [unlock(select(STORE_NAME)).getReusableBlocks(), state.settings.__experimentalReusableBlocks] : [state.settings.__experimentalBlockPatterns, state.settings[selectBlockPatternsKey]?.(select)]));
11384  const getAllPatterns = (0,external_wp_data_namespaceObject.createRegistrySelector)(select => (0,external_wp_data_namespaceObject.createSelector)(state => {
11385    var _state$settings$__exp2, _state$settings$selec2;
11386    return [...unlock(select(STORE_NAME)).getReusableBlocks().map(userPattern => mapUserPattern(userPattern, state.settings.__experimentalUserPatternCategories)),
11387    // This setting is left for back compat.
11388    ...((_state$settings$__exp2 = state.settings.__experimentalBlockPatterns) !== null && _state$settings$__exp2 !== void 0 ? _state$settings$__exp2 : []), ...((_state$settings$selec2 = state.settings[selectBlockPatternsKey]?.(select)) !== null && _state$settings$selec2 !== void 0 ? _state$settings$selec2 : [])].filter((x, index, arr) => index === arr.findIndex(y => x.name === y.name));
11389  }, getAllPatternsDependants(select)));
11390  const EMPTY_ARRAY = [];
11391  const getReusableBlocks = (0,external_wp_data_namespaceObject.createRegistrySelector)(select => state => {
11392    var _ref;
11393    const reusableBlocksSelect = state.settings[reusableBlocksSelectKey];
11394    return (_ref = reusableBlocksSelect ? reusableBlocksSelect(select) : state.settings.__experimentalReusableBlocks) !== null && _ref !== void 0 ? _ref : EMPTY_ARRAY;
11395  });
11396  
11397  /**
11398   * Returns the element of the last element that had focus when focus left the editor canvas.
11399   *
11400   * @param {Object} state Block editor state.
11401   *
11402   * @return {Object} Element.
11403   */
11404  function getLastFocus(state) {
11405    return state.lastFocus;
11406  }
11407  
11408  /**
11409   * Returns true if the user is dragging anything, or false otherwise. It is possible for a
11410   * user to be dragging data from outside of the editor, so this selector is separate from
11411   * the `isDraggingBlocks` selector which only returns true if the user is dragging blocks.
11412   *
11413   * @param {Object} state Global application state.
11414   *
11415   * @return {boolean} Whether user is dragging.
11416   */
11417  function private_selectors_isDragging(state) {
11418    return state.isDragging;
11419  }
11420  
11421  /**
11422   * Retrieves the expanded block from the state.
11423   *
11424   * @param {Object} state Block editor state.
11425   *
11426   * @return {string|null} The client ID of the expanded block, if set.
11427   */
11428  function getExpandedBlock(state) {
11429    return state.expandedBlock;
11430  }
11431  
11432  /**
11433   * Retrieves the client ID of the ancestor block that is content locking the block
11434   * with the provided client ID.
11435   *
11436   * @param {Object} state    Global application state.
11437   * @param {string} clientId Client Id of the block.
11438   *
11439   * @return {?string} Client ID of the ancestor block that is content locking the block.
11440   */
11441  const getContentLockingParent = (state, clientId) => {
11442    let current = clientId;
11443    let result;
11444    while (!result && (current = state.blocks.parents.get(current))) {
11445      if (getTemplateLock(state, current) === 'contentOnly') {
11446        result = current;
11447      }
11448    }
11449    return result;
11450  };
11451  
11452  /**
11453   * Retrieves the client ID of the parent section block.
11454   *
11455   * @param {Object} state    Global application state.
11456   * @param {string} clientId Client Id of the block.
11457   *
11458   * @return {?string} Client ID of the ancestor block that is content locking the block.
11459   */
11460  const getParentSectionBlock = (state, clientId) => {
11461    let current = clientId;
11462    let result;
11463    while (!result && (current = state.blocks.parents.get(current))) {
11464      if (isSectionBlock(state, current)) {
11465        result = current;
11466      }
11467    }
11468    return result;
11469  };
11470  
11471  /**
11472   * Retrieves the client ID is a content locking parent
11473   *
11474   * @param {Object} state    Global application state.
11475   * @param {string} clientId Client Id of the block.
11476   *
11477   * @return {boolean} Whether the block is a content locking parent.
11478   */
11479  function isSectionBlock(state, clientId) {
11480    const blockName = getBlockName(state, clientId);
11481    if (blockName === 'core/block' || getTemplateLock(state, clientId) === 'contentOnly') {
11482      return true;
11483    }
11484  
11485    // Template parts become sections in navigation mode.
11486    const _isNavigationMode = isNavigationMode(state);
11487    if (_isNavigationMode && blockName === 'core/template-part') {
11488      return true;
11489    }
11490    const sectionRootClientId = getSectionRootClientId(state);
11491    const sectionClientIds = getBlockOrder(state, sectionRootClientId);
11492    return _isNavigationMode && sectionClientIds.includes(clientId);
11493  }
11494  
11495  /**
11496   * Retrieves the client ID of the block that is content locked but is
11497   * currently being temporarily edited as a non-locked block.
11498   *
11499   * @param {Object} state Global application state.
11500   *
11501   * @return {?string} The client ID of the block being temporarily edited as a non-locked block.
11502   */
11503  function getTemporarilyEditingAsBlocks(state) {
11504    return state.temporarilyEditingAsBlocks;
11505  }
11506  
11507  /**
11508   * Returns the focus mode that should be reapplied when the user stops editing
11509   * a content locked blocks as a block without locking.
11510   *
11511   * @param {Object} state Global application state.
11512   *
11513   * @return {?string} The focus mode that should be re-set when temporarily editing as blocks stops.
11514   */
11515  function getTemporarilyEditingFocusModeToRevert(state) {
11516    return state.temporarilyEditingFocusModeRevert;
11517  }
11518  
11519  /**
11520   * Returns the style attributes of multiple blocks.
11521   *
11522   * @param {Object}   state     Global application state.
11523   * @param {string[]} clientIds An array of block client IDs.
11524   *
11525   * @return {Object} An object where keys are client IDs and values are the corresponding block styles or undefined.
11526   */
11527  const getBlockStyles = (0,external_wp_data_namespaceObject.createSelector)((state, clientIds) => clientIds.reduce((styles, clientId) => {
11528    styles[clientId] = state.blocks.attributes.get(clientId)?.style;
11529    return styles;
11530  }, {}), (state, clientIds) => [...clientIds.map(clientId => state.blocks.attributes.get(clientId)?.style)]);
11531  
11532  /**
11533   * Retrieves the client ID of the block which contains the blocks
11534   * acting as "sections" in the editor. This is typically the "main content"
11535   * of the template/post.
11536   *
11537   * @param {Object} state Editor state.
11538   *
11539   * @return {string|undefined} The section root client ID or undefined if not set.
11540   */
11541  function getSectionRootClientId(state) {
11542    return state.settings?.[sectionRootClientIdKey];
11543  }
11544  
11545  /**
11546   * Returns whether the editor is considered zoomed out.
11547   *
11548   * @param {Object} state Global application state.
11549   * @return {boolean} Whether the editor is zoomed.
11550   */
11551  function isZoomOut(state) {
11552    return state.zoomLevel === 'auto-scaled' || state.zoomLevel < 100;
11553  }
11554  
11555  /**
11556   * Returns whether the zoom level.
11557   *
11558   * @param {Object} state Global application state.
11559   * @return {number|"auto-scaled"} Zoom level.
11560   */
11561  function getZoomLevel(state) {
11562    return state.zoomLevel;
11563  }
11564  
11565  /**
11566   * Finds the closest block where the block is allowed to be inserted.
11567   *
11568   * @param {Object}            state    Editor state.
11569   * @param {string[] | string} name     Block name or names.
11570   * @param {string}            clientId Default insertion point.
11571   *
11572   * @return {string} clientID of the closest container when the block name can be inserted.
11573   */
11574  function getClosestAllowedInsertionPoint(state, name, clientId = '') {
11575    const blockNames = Array.isArray(name) ? name : [name];
11576    const areBlockNamesAllowedInClientId = id => blockNames.every(currentName => canInsertBlockType(state, currentName, id));
11577  
11578    // If we're trying to insert at the root level and it's not allowed
11579    // Try the section root instead.
11580    if (!clientId) {
11581      if (areBlockNamesAllowedInClientId(clientId)) {
11582        return clientId;
11583      }
11584      const sectionRootClientId = getSectionRootClientId(state);
11585      if (sectionRootClientId && areBlockNamesAllowedInClientId(sectionRootClientId)) {
11586        return sectionRootClientId;
11587      }
11588      return null;
11589    }
11590  
11591    // Traverse the block tree up until we find a place where we can insert.
11592    let current = clientId;
11593    while (current !== null && !areBlockNamesAllowedInClientId(current)) {
11594      const parentClientId = getBlockRootClientId(state, current);
11595      current = parentClientId;
11596    }
11597    return current;
11598  }
11599  function getClosestAllowedInsertionPointForPattern(state, pattern, clientId) {
11600    const {
11601      allowedBlockTypes
11602    } = getSettings(state);
11603    const isAllowed = checkAllowListRecursive(getGrammar(pattern), allowedBlockTypes);
11604    if (!isAllowed) {
11605      return null;
11606    }
11607    const names = getGrammar(pattern).map(({
11608      blockName: name
11609    }) => name);
11610    return getClosestAllowedInsertionPoint(state, names, clientId);
11611  }
11612  
11613  /**
11614   * Where the point where the next block will be inserted into.
11615   *
11616   * @param {Object} state
11617   * @return {Object} where the insertion point in the block editor is or null if none is set.
11618   */
11619  function getInsertionPoint(state) {
11620    return state.insertionPoint;
11621  }
11622  
11623  ;// ./node_modules/@wordpress/block-editor/build-module/store/utils.js
11624  /**
11625   * WordPress dependencies
11626   */
11627  
11628  
11629  
11630  /**
11631   * Internal dependencies
11632   */
11633  
11634  
11635  
11636  
11637  const isFiltered = Symbol('isFiltered');
11638  const parsedPatternCache = new WeakMap();
11639  const grammarMapCache = new WeakMap();
11640  function parsePattern(pattern) {
11641    const blocks = (0,external_wp_blocks_namespaceObject.parse)(pattern.content, {
11642      __unstableSkipMigrationLogs: true
11643    });
11644    if (blocks.length === 1) {
11645      blocks[0].attributes = {
11646        ...blocks[0].attributes,
11647        metadata: {
11648          ...(blocks[0].attributes.metadata || {}),
11649          categories: pattern.categories,
11650          patternName: pattern.name,
11651          name: blocks[0].attributes.metadata?.name || pattern.title
11652        }
11653      };
11654    }
11655    return {
11656      ...pattern,
11657      blocks
11658    };
11659  }
11660  function getParsedPattern(pattern) {
11661    let parsedPattern = parsedPatternCache.get(pattern);
11662    if (!parsedPattern) {
11663      parsedPattern = parsePattern(pattern);
11664      parsedPatternCache.set(pattern, parsedPattern);
11665    }
11666    return parsedPattern;
11667  }
11668  function getGrammar(pattern) {
11669    let grammarMap = grammarMapCache.get(pattern);
11670    if (!grammarMap) {
11671      grammarMap = (0,external_wp_blockSerializationDefaultParser_namespaceObject.parse)(pattern.content);
11672      // Block names are null only at the top level for whitespace.
11673      grammarMap = grammarMap.filter(block => block.blockName !== null);
11674      grammarMapCache.set(pattern, grammarMap);
11675    }
11676    return grammarMap;
11677  }
11678  const checkAllowList = (list, item, defaultResult = null) => {
11679    if (typeof list === 'boolean') {
11680      return list;
11681    }
11682    if (Array.isArray(list)) {
11683      // TODO: when there is a canonical way to detect that we are editing a post
11684      // the following check should be changed to something like:
11685      // if ( list.includes( 'core/post-content' ) && getEditorMode() === 'post-content' && item === null )
11686      if (list.includes('core/post-content') && item === null) {
11687        return true;
11688      }
11689      return list.includes(item);
11690    }
11691    return defaultResult;
11692  };
11693  const checkAllowListRecursive = (blocks, allowedBlockTypes) => {
11694    if (typeof allowedBlockTypes === 'boolean') {
11695      return allowedBlockTypes;
11696    }
11697    const blocksQueue = [...blocks];
11698    while (blocksQueue.length > 0) {
11699      const block = blocksQueue.shift();
11700      const isAllowed = checkAllowList(allowedBlockTypes, block.name || block.blockName, true);
11701      if (!isAllowed) {
11702        return false;
11703      }
11704      block.innerBlocks?.forEach(innerBlock => {
11705        blocksQueue.push(innerBlock);
11706      });
11707    }
11708    return true;
11709  };
11710  const getAllPatternsDependants = select => state => {
11711    return [state.settings.__experimentalBlockPatterns, state.settings.__experimentalUserPatternCategories, state.settings.__experimentalReusableBlocks, state.settings[selectBlockPatternsKey]?.(select), state.blockPatterns, unlock(select(STORE_NAME)).getReusableBlocks()];
11712  };
11713  const getInsertBlockTypeDependants = select => (state, rootClientId) => {
11714    return [state.blockListSettings[rootClientId], state.blocks.byClientId.get(rootClientId), state.settings.allowedBlockTypes, state.settings.templateLock, state.blockEditingModes, select(STORE_NAME).__unstableGetEditorMode(state), getSectionRootClientId(state)];
11715  };
11716  
11717  ;// ./node_modules/@wordpress/block-editor/build-module/utils/sorting.js
11718  /**
11719   * Recursive stable sorting comparator function.
11720   *
11721   * @param {string|Function} field Field to sort by.
11722   * @param {Array}           items Items to sort.
11723   * @param {string}          order Order, 'asc' or 'desc'.
11724   * @return {Function} Comparison function to be used in a `.sort()`.
11725   */
11726  const comparator = (field, items, order) => {
11727    return (a, b) => {
11728      let cmpA, cmpB;
11729      if (typeof field === 'function') {
11730        cmpA = field(a);
11731        cmpB = field(b);
11732      } else {
11733        cmpA = a[field];
11734        cmpB = b[field];
11735      }
11736      if (cmpA > cmpB) {
11737        return order === 'asc' ? 1 : -1;
11738      } else if (cmpB > cmpA) {
11739        return order === 'asc' ? -1 : 1;
11740      }
11741      const orderA = items.findIndex(item => item === a);
11742      const orderB = items.findIndex(item => item === b);
11743  
11744      // Stable sort: maintaining original array order
11745      if (orderA > orderB) {
11746        return 1;
11747      } else if (orderB > orderA) {
11748        return -1;
11749      }
11750      return 0;
11751    };
11752  };
11753  
11754  /**
11755   * Order items by a certain key.
11756   * Supports decorator functions that allow complex picking of a comparison field.
11757   * Sorts in ascending order by default, but supports descending as well.
11758   * Stable sort - maintains original order of equal items.
11759   *
11760   * @param {Array}           items Items to order.
11761   * @param {string|Function} field Field to order by.
11762   * @param {string}          order Sorting order, `asc` or `desc`.
11763   * @return {Array} Sorted items.
11764   */
11765  function orderBy(items, field, order = 'asc') {
11766    return items.concat().sort(comparator(field, items, order));
11767  }
11768  
11769  ;// ./node_modules/@wordpress/block-editor/build-module/store/selectors.js
11770  /**
11771   * WordPress dependencies
11772   */
11773  
11774  
11775  
11776  
11777  
11778  
11779  
11780  
11781  
11782  /**
11783   * Internal dependencies
11784   */
11785  
11786  
11787  
11788  
11789  
11790  
11791  /**
11792   * A block selection object.
11793   *
11794   * @typedef {Object} WPBlockSelection
11795   *
11796   * @property {string} clientId     A block client ID.
11797   * @property {string} attributeKey A block attribute key.
11798   * @property {number} offset       An attribute value offset, based on the rich
11799   *                                 text value. See `wp.richText.create`.
11800   */
11801  
11802  // Module constants.
11803  const MILLISECONDS_PER_HOUR = 3600 * 1000;
11804  const MILLISECONDS_PER_DAY = 24 * 3600 * 1000;
11805  const MILLISECONDS_PER_WEEK = 7 * 24 * 3600 * 1000;
11806  
11807  /**
11808   * Shared reference to an empty array for cases where it is important to avoid
11809   * returning a new array reference on every invocation, as in a connected or
11810   * other pure component which performs `shouldComponentUpdate` check on props.
11811   * This should be used as a last resort, since the normalized data should be
11812   * maintained by the reducer result in state.
11813   *
11814   * @type {Array}
11815   */
11816  const selectors_EMPTY_ARRAY = [];
11817  
11818  /**
11819   * Shared reference to an empty Set for cases where it is important to avoid
11820   * returning a new Set reference on every invocation, as in a connected or
11821   * other pure component which performs `shouldComponentUpdate` check on props.
11822   * This should be used as a last resort, since the normalized data should be
11823   * maintained by the reducer result in state.
11824   *
11825   * @type {Set}
11826   */
11827  const EMPTY_SET = new Set();
11828  const DEFAULT_INSERTER_OPTIONS = {
11829    [isFiltered]: true
11830  };
11831  
11832  /**
11833   * Returns a block's name given its client ID, or null if no block exists with
11834   * the client ID.
11835   *
11836   * @param {Object} state    Editor state.
11837   * @param {string} clientId Block client ID.
11838   *
11839   * @return {string} Block name.
11840   */
11841  function getBlockName(state, clientId) {
11842    const block = state.blocks.byClientId.get(clientId);
11843    const socialLinkName = 'core/social-link';
11844    if (external_wp_element_namespaceObject.Platform.OS !== 'web' && block?.name === socialLinkName) {
11845      const attributes = state.blocks.attributes.get(clientId);
11846      const {
11847        service
11848      } = attributes !== null && attributes !== void 0 ? attributes : {};
11849      return service ? `$socialLinkName}-$service}` : socialLinkName;
11850    }
11851    return block ? block.name : null;
11852  }
11853  
11854  /**
11855   * Returns whether a block is valid or not.
11856   *
11857   * @param {Object} state    Editor state.
11858   * @param {string} clientId Block client ID.
11859   *
11860   * @return {boolean} Is Valid.
11861   */
11862  function isBlockValid(state, clientId) {
11863    const block = state.blocks.byClientId.get(clientId);
11864    return !!block && block.isValid;
11865  }
11866  
11867  /**
11868   * Returns a block's attributes given its client ID, or null if no block exists with
11869   * the client ID.
11870   *
11871   * @param {Object} state    Editor state.
11872   * @param {string} clientId Block client ID.
11873   *
11874   * @return {?Object} Block attributes.
11875   */
11876  function getBlockAttributes(state, clientId) {
11877    const block = state.blocks.byClientId.get(clientId);
11878    if (!block) {
11879      return null;
11880    }
11881    return state.blocks.attributes.get(clientId);
11882  }
11883  
11884  /**
11885   * Returns a block given its client ID. This is a parsed copy of the block,
11886   * containing its `blockName`, `clientId`, and current `attributes` state. This
11887   * is not the block's registration settings, which must be retrieved from the
11888   * blocks module registration store.
11889   *
11890   * getBlock recurses through its inner blocks until all its children blocks have
11891   * been retrieved. Note that getBlock will not return the child inner blocks of
11892   * an inner block controller. This is because an inner block controller syncs
11893   * itself with its own entity, and should therefore not be included with the
11894   * blocks of a different entity. For example, say you call `getBlocks( TP )` to
11895   * get the blocks of a template part. If another template part is a child of TP,
11896   * then the nested template part's child blocks will not be returned. This way,
11897   * the template block itself is considered part of the parent, but the children
11898   * are not.
11899   *
11900   * @param {Object} state    Editor state.
11901   * @param {string} clientId Block client ID.
11902   *
11903   * @return {Object} Parsed block object.
11904   */
11905  function getBlock(state, clientId) {
11906    if (!state.blocks.byClientId.has(clientId)) {
11907      return null;
11908    }
11909    return state.blocks.tree.get(clientId);
11910  }
11911  const __unstableGetBlockWithoutInnerBlocks = (0,external_wp_data_namespaceObject.createSelector)((state, clientId) => {
11912    const block = state.blocks.byClientId.get(clientId);
11913    if (!block) {
11914      return null;
11915    }
11916    return {
11917      ...block,
11918      attributes: getBlockAttributes(state, clientId)
11919    };
11920  }, (state, clientId) => [state.blocks.byClientId.get(clientId), state.blocks.attributes.get(clientId)]);
11921  
11922  /**
11923   * Returns all block objects for the current post being edited as an array in
11924   * the order they appear in the post. Note that this will exclude child blocks
11925   * of nested inner block controllers.
11926   *
11927   * @param {Object}  state        Editor state.
11928   * @param {?string} rootClientId Optional root client ID of block list.
11929   *
11930   * @return {Object[]} Post blocks.
11931   */
11932  function getBlocks(state, rootClientId) {
11933    const treeKey = !rootClientId || !areInnerBlocksControlled(state, rootClientId) ? rootClientId || '' : 'controlled||' + rootClientId;
11934    return state.blocks.tree.get(treeKey)?.innerBlocks || selectors_EMPTY_ARRAY;
11935  }
11936  
11937  /**
11938   * Returns a stripped down block object containing only its client ID,
11939   * and its inner blocks' client IDs.
11940   *
11941   * @deprecated
11942   *
11943   * @param {Object} state    Editor state.
11944   * @param {string} clientId Client ID of the block to get.
11945   *
11946   * @return {Object} Client IDs of the post blocks.
11947   */
11948  const __unstableGetClientIdWithClientIdsTree = (0,external_wp_data_namespaceObject.createSelector)((state, clientId) => {
11949    external_wp_deprecated_default()("wp.data.select( 'core/block-editor' ).__unstableGetClientIdWithClientIdsTree", {
11950      since: '6.3',
11951      version: '6.5'
11952    });
11953    return {
11954      clientId,
11955      innerBlocks: __unstableGetClientIdsTree(state, clientId)
11956    };
11957  }, state => [state.blocks.order]);
11958  
11959  /**
11960   * Returns the block tree represented in the block-editor store from the
11961   * given root, consisting of stripped down block objects containing only
11962   * their client IDs, and their inner blocks' client IDs.
11963   *
11964   * @deprecated
11965   *
11966   * @param {Object}  state        Editor state.
11967   * @param {?string} rootClientId Optional root client ID of block list.
11968   *
11969   * @return {Object[]} Client IDs of the post blocks.
11970   */
11971  const __unstableGetClientIdsTree = (0,external_wp_data_namespaceObject.createSelector)((state, rootClientId = '') => {
11972    external_wp_deprecated_default()("wp.data.select( 'core/block-editor' ).__unstableGetClientIdsTree", {
11973      since: '6.3',
11974      version: '6.5'
11975    });
11976    return getBlockOrder(state, rootClientId).map(clientId => __unstableGetClientIdWithClientIdsTree(state, clientId));
11977  }, state => [state.blocks.order]);
11978  
11979  /**
11980   * Returns an array containing the clientIds of all descendants of the blocks
11981   * given. Returned ids are ordered first by the order of the ids given, then
11982   * by the order that they appear in the editor.
11983   *
11984   * @param {Object}          state   Global application state.
11985   * @param {string|string[]} rootIds Client ID(s) for which descendant blocks are to be returned.
11986   *
11987   * @return {Array} Client IDs of descendants.
11988   */
11989  const getClientIdsOfDescendants = (0,external_wp_data_namespaceObject.createSelector)((state, rootIds) => {
11990    rootIds = Array.isArray(rootIds) ? [...rootIds] : [rootIds];
11991    const ids = [];
11992  
11993    // Add the descendants of the root blocks first.
11994    for (const rootId of rootIds) {
11995      const order = state.blocks.order.get(rootId);
11996      if (order) {
11997        ids.push(...order);
11998      }
11999    }
12000    let index = 0;
12001  
12002    // Add the descendants of the descendants, recursively.
12003    while (index < ids.length) {
12004      const id = ids[index];
12005      const order = state.blocks.order.get(id);
12006      if (order) {
12007        ids.splice(index + 1, 0, ...order);
12008      }
12009      index++;
12010    }
12011    return ids;
12012  }, state => [state.blocks.order]);
12013  
12014  /**
12015   * Returns an array containing the clientIds of the top-level blocks and
12016   * their descendants of any depth (for nested blocks). Ids are returned
12017   * in the same order that they appear in the editor.
12018   *
12019   * @param {Object} state Global application state.
12020   *
12021   * @return {Array} ids of top-level and descendant blocks.
12022   */
12023  const getClientIdsWithDescendants = state => getClientIdsOfDescendants(state, '');
12024  
12025  /**
12026   * Returns the total number of blocks, or the total number of blocks with a specific name in a post.
12027   * The number returned includes nested blocks.
12028   *
12029   * @param {Object}  state     Global application state.
12030   * @param {?string} blockName Optional block name, if specified only blocks of that type will be counted.
12031   *
12032   * @return {number} Number of blocks in the post, or number of blocks with name equal to blockName.
12033   */
12034  const getGlobalBlockCount = (0,external_wp_data_namespaceObject.createSelector)((state, blockName) => {
12035    const clientIds = getClientIdsWithDescendants(state);
12036    if (!blockName) {
12037      return clientIds.length;
12038    }
12039    let count = 0;
12040    for (const clientId of clientIds) {
12041      const block = state.blocks.byClientId.get(clientId);
12042      if (block.name === blockName) {
12043        count++;
12044      }
12045    }
12046    return count;
12047  }, state => [state.blocks.order, state.blocks.byClientId]);
12048  
12049  /**
12050   * Returns all blocks that match a blockName. Results include nested blocks.
12051   *
12052   * @param {Object}   state     Global application state.
12053   * @param {string[]} blockName Block name(s) for which clientIds are to be returned.
12054   *
12055   * @return {Array} Array of clientIds of blocks with name equal to blockName.
12056   */
12057  const getBlocksByName = (0,external_wp_data_namespaceObject.createSelector)((state, blockName) => {
12058    if (!blockName) {
12059      return selectors_EMPTY_ARRAY;
12060    }
12061    const blockNames = Array.isArray(blockName) ? blockName : [blockName];
12062    const clientIds = getClientIdsWithDescendants(state);
12063    const foundBlocks = clientIds.filter(clientId => {
12064      const block = state.blocks.byClientId.get(clientId);
12065      return blockNames.includes(block.name);
12066    });
12067    return foundBlocks.length > 0 ? foundBlocks : selectors_EMPTY_ARRAY;
12068  }, state => [state.blocks.order, state.blocks.byClientId]);
12069  
12070  /**
12071   * Returns all global blocks that match a blockName. Results include nested blocks.
12072   *
12073   * @deprecated
12074   *
12075   * @param {Object}   state     Global application state.
12076   * @param {string[]} blockName Block name(s) for which clientIds are to be returned.
12077   *
12078   * @return {Array} Array of clientIds of blocks with name equal to blockName.
12079   */
12080  function __experimentalGetGlobalBlocksByName(state, blockName) {
12081    external_wp_deprecated_default()("wp.data.select( 'core/block-editor' ).__experimentalGetGlobalBlocksByName", {
12082      since: '6.5',
12083      alternative: `wp.data.select( 'core/block-editor' ).getBlocksByName`
12084    });
12085    return getBlocksByName(state, blockName);
12086  }
12087  
12088  /**
12089   * Given an array of block client IDs, returns the corresponding array of block
12090   * objects.
12091   *
12092   * @param {Object}   state     Editor state.
12093   * @param {string[]} clientIds Client IDs for which blocks are to be returned.
12094   *
12095   * @return {WPBlock[]} Block objects.
12096   */
12097  const getBlocksByClientId = (0,external_wp_data_namespaceObject.createSelector)((state, clientIds) => (Array.isArray(clientIds) ? clientIds : [clientIds]).map(clientId => getBlock(state, clientId)), (state, clientIds) => (Array.isArray(clientIds) ? clientIds : [clientIds]).map(clientId => state.blocks.tree.get(clientId)));
12098  
12099  /**
12100   * Given an array of block client IDs, returns the corresponding array of block
12101   * names.
12102   *
12103   * @param {Object}   state     Editor state.
12104   * @param {string[]} clientIds Client IDs for which block names are to be returned.
12105   *
12106   * @return {string[]} Block names.
12107   */
12108  const getBlockNamesByClientId = (0,external_wp_data_namespaceObject.createSelector)((state, clientIds) => getBlocksByClientId(state, clientIds).filter(Boolean).map(block => block.name), (state, clientIds) => getBlocksByClientId(state, clientIds));
12109  
12110  /**
12111   * Returns the number of blocks currently present in the post.
12112   *
12113   * @param {Object}  state        Editor state.
12114   * @param {?string} rootClientId Optional root client ID of block list.
12115   *
12116   * @return {number} Number of blocks in the post.
12117   */
12118  function getBlockCount(state, rootClientId) {
12119    return getBlockOrder(state, rootClientId).length;
12120  }
12121  
12122  /**
12123   * Returns the current selection start block client ID, attribute key and text
12124   * offset.
12125   *
12126   * @param {Object} state Block editor state.
12127   *
12128   * @return {WPBlockSelection} Selection start information.
12129   */
12130  function getSelectionStart(state) {
12131    return state.selection.selectionStart;
12132  }
12133  
12134  /**
12135   * Returns the current selection end block client ID, attribute key and text
12136   * offset.
12137   *
12138   * @param {Object} state Block editor state.
12139   *
12140   * @return {WPBlockSelection} Selection end information.
12141   */
12142  function getSelectionEnd(state) {
12143    return state.selection.selectionEnd;
12144  }
12145  
12146  /**
12147   * Returns the current block selection start. This value may be null, and it
12148   * may represent either a singular block selection or multi-selection start.
12149   * A selection is singular if its start and end match.
12150   *
12151   * @param {Object} state Global application state.
12152   *
12153   * @return {?string} Client ID of block selection start.
12154   */
12155  function getBlockSelectionStart(state) {
12156    return state.selection.selectionStart.clientId;
12157  }
12158  
12159  /**
12160   * Returns the current block selection end. This value may be null, and it
12161   * may represent either a singular block selection or multi-selection end.
12162   * A selection is singular if its start and end match.
12163   *
12164   * @param {Object} state Global application state.
12165   *
12166   * @return {?string} Client ID of block selection end.
12167   */
12168  function getBlockSelectionEnd(state) {
12169    return state.selection.selectionEnd.clientId;
12170  }
12171  
12172  /**
12173   * Returns the number of blocks currently selected in the post.
12174   *
12175   * @param {Object} state Global application state.
12176   *
12177   * @return {number} Number of blocks selected in the post.
12178   */
12179  function getSelectedBlockCount(state) {
12180    const multiSelectedBlockCount = getMultiSelectedBlockClientIds(state).length;
12181    if (multiSelectedBlockCount) {
12182      return multiSelectedBlockCount;
12183    }
12184    return state.selection.selectionStart.clientId ? 1 : 0;
12185  }
12186  
12187  /**
12188   * Returns true if there is a single selected block, or false otherwise.
12189   *
12190   * @param {Object} state Editor state.
12191   *
12192   * @return {boolean} Whether a single block is selected.
12193   */
12194  function hasSelectedBlock(state) {
12195    const {
12196      selectionStart,
12197      selectionEnd
12198    } = state.selection;
12199    return !!selectionStart.clientId && selectionStart.clientId === selectionEnd.clientId;
12200  }
12201  
12202  /**
12203   * Returns the currently selected block client ID, or null if there is no
12204   * selected block.
12205   *
12206   * @param {Object} state Editor state.
12207   *
12208   * @return {?string} Selected block client ID.
12209   */
12210  function getSelectedBlockClientId(state) {
12211    const {
12212      selectionStart,
12213      selectionEnd
12214    } = state.selection;
12215    const {
12216      clientId
12217    } = selectionStart;
12218    if (!clientId || clientId !== selectionEnd.clientId) {
12219      return null;
12220    }
12221    return clientId;
12222  }
12223  
12224  /**
12225   * Returns the currently selected block, or null if there is no selected block.
12226   *
12227   * @param {Object} state Global application state.
12228   *
12229   * @example
12230   *
12231   *```js
12232   * import { select } from '@wordpress/data'
12233   * import { store as blockEditorStore } from '@wordpress/block-editor'
12234   *
12235   * // Set initial active block client ID
12236   * let activeBlockClientId = null
12237   *
12238   * const getActiveBlockData = () => {
12239   *     const activeBlock = select(blockEditorStore).getSelectedBlock()
12240   *
12241   *     if (activeBlock && activeBlock.clientId !== activeBlockClientId) {
12242   *         activeBlockClientId = activeBlock.clientId
12243   *
12244   *         // Get active block name and attributes
12245   *         const activeBlockName = activeBlock.name
12246   *         const activeBlockAttributes = activeBlock.attributes
12247   *
12248   *         // Log active block name and attributes
12249   *         console.log(activeBlockName, activeBlockAttributes)
12250   *         }
12251   *     }
12252   *
12253   *     // Subscribe to changes in the editor
12254   *     // wp.data.subscribe(() => {
12255   *         // getActiveBlockData()
12256   *     // })
12257   *
12258   *     // Update active block data on click
12259   *     // onclick="getActiveBlockData()"
12260   *```
12261   *
12262   * @return {?Object} Selected block.
12263   */
12264  function getSelectedBlock(state) {
12265    const clientId = getSelectedBlockClientId(state);
12266    return clientId ? getBlock(state, clientId) : null;
12267  }
12268  
12269  /**
12270   * Given a block client ID, returns the root block from which the block is
12271   * nested, an empty string for top-level blocks, or null if the block does not
12272   * exist.
12273   *
12274   * @param {Object} state    Editor state.
12275   * @param {string} clientId Block from which to find root client ID.
12276   *
12277   * @return {?string} Root client ID, if exists
12278   */
12279  function getBlockRootClientId(state, clientId) {
12280    var _state$blocks$parents;
12281    return (_state$blocks$parents = state.blocks.parents.get(clientId)) !== null && _state$blocks$parents !== void 0 ? _state$blocks$parents : null;
12282  }
12283  
12284  /**
12285   * Given a block client ID, returns the list of all its parents from top to bottom.
12286   *
12287   * @param {Object}  state     Editor state.
12288   * @param {string}  clientId  Block from which to find root client ID.
12289   * @param {boolean} ascending Order results from bottom to top (true) or top to bottom (false).
12290   *
12291   * @return {Array} ClientIDs of the parent blocks.
12292   */
12293  const getBlockParents = (0,external_wp_data_namespaceObject.createSelector)((state, clientId, ascending = false) => {
12294    const parents = [];
12295    let current = clientId;
12296    while (current = state.blocks.parents.get(current)) {
12297      parents.push(current);
12298    }
12299    if (!parents.length) {
12300      return selectors_EMPTY_ARRAY;
12301    }
12302    return ascending ? parents : parents.reverse();
12303  }, state => [state.blocks.parents]);
12304  
12305  /**
12306   * Given a block client ID and a block name, returns the list of all its parents
12307   * from top to bottom, filtered by the given name(s). For example, if passed
12308   * 'core/group' as the blockName, it will only return parents which are group
12309   * blocks. If passed `[ 'core/group', 'core/cover']`, as the blockName, it will
12310   * return parents which are group blocks and parents which are cover blocks.
12311   *
12312   * @param {Object}          state     Editor state.
12313   * @param {string}          clientId  Block from which to find root client ID.
12314   * @param {string|string[]} blockName Block name(s) to filter.
12315   * @param {boolean}         ascending Order results from bottom to top (true) or top to bottom (false).
12316   *
12317   * @return {Array} ClientIDs of the parent blocks.
12318   */
12319  const getBlockParentsByBlockName = (0,external_wp_data_namespaceObject.createSelector)((state, clientId, blockName, ascending = false) => {
12320    const parents = getBlockParents(state, clientId, ascending);
12321    const hasName = Array.isArray(blockName) ? name => blockName.includes(name) : name => blockName === name;
12322    return parents.filter(id => hasName(getBlockName(state, id)));
12323  }, state => [state.blocks.parents]);
12324  /**
12325   * Given a block client ID, returns the root of the hierarchy from which the block is nested, return the block itself for root level blocks.
12326   *
12327   * @param {Object} state    Editor state.
12328   * @param {string} clientId Block from which to find root client ID.
12329   *
12330   * @return {string} Root client ID
12331   */
12332  function getBlockHierarchyRootClientId(state, clientId) {
12333    let current = clientId;
12334    let parent;
12335    do {
12336      parent = current;
12337      current = state.blocks.parents.get(current);
12338    } while (current);
12339    return parent;
12340  }
12341  
12342  /**
12343   * Given a block client ID, returns the lowest common ancestor with selected client ID.
12344   *
12345   * @param {Object} state    Editor state.
12346   * @param {string} clientId Block from which to find common ancestor client ID.
12347   *
12348   * @return {string} Common ancestor client ID or undefined
12349   */
12350  function getLowestCommonAncestorWithSelectedBlock(state, clientId) {
12351    const selectedId = getSelectedBlockClientId(state);
12352    const clientParents = [...getBlockParents(state, clientId), clientId];
12353    const selectedParents = [...getBlockParents(state, selectedId), selectedId];
12354    let lowestCommonAncestor;
12355    const maxDepth = Math.min(clientParents.length, selectedParents.length);
12356    for (let index = 0; index < maxDepth; index++) {
12357      if (clientParents[index] === selectedParents[index]) {
12358        lowestCommonAncestor = clientParents[index];
12359      } else {
12360        break;
12361      }
12362    }
12363    return lowestCommonAncestor;
12364  }
12365  
12366  /**
12367   * Returns the client ID of the block adjacent one at the given reference
12368   * startClientId and modifier directionality. Defaults start startClientId to
12369   * the selected block, and direction as next block. Returns null if there is no
12370   * adjacent block.
12371   *
12372   * @param {Object}  state         Editor state.
12373   * @param {?string} startClientId Optional client ID of block from which to
12374   *                                search.
12375   * @param {?number} modifier      Directionality multiplier (1 next, -1
12376   *                                previous).
12377   *
12378   * @return {?string} Return the client ID of the block, or null if none exists.
12379   */
12380  function getAdjacentBlockClientId(state, startClientId, modifier = 1) {
12381    // Default to selected block.
12382    if (startClientId === undefined) {
12383      startClientId = getSelectedBlockClientId(state);
12384    }
12385  
12386    // Try multi-selection starting at extent based on modifier.
12387    if (startClientId === undefined) {
12388      if (modifier < 0) {
12389        startClientId = getFirstMultiSelectedBlockClientId(state);
12390      } else {
12391        startClientId = getLastMultiSelectedBlockClientId(state);
12392      }
12393    }
12394  
12395    // Validate working start client ID.
12396    if (!startClientId) {
12397      return null;
12398    }
12399  
12400    // Retrieve start block root client ID, being careful to allow the falsey
12401    // empty string top-level root by explicitly testing against null.
12402    const rootClientId = getBlockRootClientId(state, startClientId);
12403    if (rootClientId === null) {
12404      return null;
12405    }
12406    const {
12407      order
12408    } = state.blocks;
12409    const orderSet = order.get(rootClientId);
12410    const index = orderSet.indexOf(startClientId);
12411    const nextIndex = index + 1 * modifier;
12412  
12413    // Block was first in set and we're attempting to get previous.
12414    if (nextIndex < 0) {
12415      return null;
12416    }
12417  
12418    // Block was last in set and we're attempting to get next.
12419    if (nextIndex === orderSet.length) {
12420      return null;
12421    }
12422  
12423    // Assume incremented index is within the set.
12424    return orderSet[nextIndex];
12425  }
12426  
12427  /**
12428   * Returns the previous block's client ID from the given reference start ID.
12429   * Defaults start to the selected block. Returns null if there is no previous
12430   * block.
12431   *
12432   * @param {Object}  state         Editor state.
12433   * @param {?string} startClientId Optional client ID of block from which to
12434   *                                search.
12435   *
12436   * @return {?string} Adjacent block's client ID, or null if none exists.
12437   */
12438  function getPreviousBlockClientId(state, startClientId) {
12439    return getAdjacentBlockClientId(state, startClientId, -1);
12440  }
12441  
12442  /**
12443   * Returns the next block's client ID from the given reference start ID.
12444   * Defaults start to the selected block. Returns null if there is no next
12445   * block.
12446   *
12447   * @param {Object}  state         Editor state.
12448   * @param {?string} startClientId Optional client ID of block from which to
12449   *                                search.
12450   *
12451   * @return {?string} Adjacent block's client ID, or null if none exists.
12452   */
12453  function getNextBlockClientId(state, startClientId) {
12454    return getAdjacentBlockClientId(state, startClientId, 1);
12455  }
12456  
12457  /* eslint-disable jsdoc/valid-types */
12458  /**
12459   * Returns the initial caret position for the selected block.
12460   * This position is to used to position the caret properly when the selected block changes.
12461   * If the current block is not a RichText, having initial position set to 0 means "focus block"
12462   *
12463   * @param {Object} state Global application state.
12464   *
12465   * @return {0|-1|null} Initial position.
12466   */
12467  function getSelectedBlocksInitialCaretPosition(state) {
12468    /* eslint-enable jsdoc/valid-types */
12469    return state.initialPosition;
12470  }
12471  
12472  /**
12473   * Returns the current selection set of block client IDs (multiselection or single selection).
12474   *
12475   * @param {Object} state Editor state.
12476   *
12477   * @return {Array} Multi-selected block client IDs.
12478   */
12479  const getSelectedBlockClientIds = (0,external_wp_data_namespaceObject.createSelector)(state => {
12480    const {
12481      selectionStart,
12482      selectionEnd
12483    } = state.selection;
12484    if (!selectionStart.clientId || !selectionEnd.clientId) {
12485      return selectors_EMPTY_ARRAY;
12486    }
12487    if (selectionStart.clientId === selectionEnd.clientId) {
12488      return [selectionStart.clientId];
12489    }
12490  
12491    // Retrieve root client ID to aid in retrieving relevant nested block
12492    // order, being careful to allow the falsey empty string top-level root
12493    // by explicitly testing against null.
12494    const rootClientId = getBlockRootClientId(state, selectionStart.clientId);
12495    if (rootClientId === null) {
12496      return selectors_EMPTY_ARRAY;
12497    }
12498    const blockOrder = getBlockOrder(state, rootClientId);
12499    const startIndex = blockOrder.indexOf(selectionStart.clientId);
12500    const endIndex = blockOrder.indexOf(selectionEnd.clientId);
12501    if (startIndex > endIndex) {
12502      return blockOrder.slice(endIndex, startIndex + 1);
12503    }
12504    return blockOrder.slice(startIndex, endIndex + 1);
12505  }, state => [state.blocks.order, state.selection.selectionStart.clientId, state.selection.selectionEnd.clientId]);
12506  
12507  /**
12508   * Returns the current multi-selection set of block client IDs, or an empty
12509   * array if there is no multi-selection.
12510   *
12511   * @param {Object} state Editor state.
12512   *
12513   * @return {Array} Multi-selected block client IDs.
12514   */
12515  function getMultiSelectedBlockClientIds(state) {
12516    const {
12517      selectionStart,
12518      selectionEnd
12519    } = state.selection;
12520    if (selectionStart.clientId === selectionEnd.clientId) {
12521      return selectors_EMPTY_ARRAY;
12522    }
12523    return getSelectedBlockClientIds(state);
12524  }
12525  
12526  /**
12527   * Returns the current multi-selection set of blocks, or an empty array if
12528   * there is no multi-selection.
12529   *
12530   * @param {Object} state Editor state.
12531   *
12532   * @return {Array} Multi-selected block objects.
12533   */
12534  const getMultiSelectedBlocks = (0,external_wp_data_namespaceObject.createSelector)(state => {
12535    const multiSelectedBlockClientIds = getMultiSelectedBlockClientIds(state);
12536    if (!multiSelectedBlockClientIds.length) {
12537      return selectors_EMPTY_ARRAY;
12538    }
12539    return multiSelectedBlockClientIds.map(clientId => getBlock(state, clientId));
12540  }, state => [...getSelectedBlockClientIds.getDependants(state), state.blocks.byClientId, state.blocks.order, state.blocks.attributes]);
12541  
12542  /**
12543   * Returns the client ID of the first block in the multi-selection set, or null
12544   * if there is no multi-selection.
12545   *
12546   * @param {Object} state Editor state.
12547   *
12548   * @return {?string} First block client ID in the multi-selection set.
12549   */
12550  function getFirstMultiSelectedBlockClientId(state) {
12551    return getMultiSelectedBlockClientIds(state)[0] || null;
12552  }
12553  
12554  /**
12555   * Returns the client ID of the last block in the multi-selection set, or null
12556   * if there is no multi-selection.
12557   *
12558   * @param {Object} state Editor state.
12559   *
12560   * @return {?string} Last block client ID in the multi-selection set.
12561   */
12562  function getLastMultiSelectedBlockClientId(state) {
12563    const selectedClientIds = getMultiSelectedBlockClientIds(state);
12564    return selectedClientIds[selectedClientIds.length - 1] || null;
12565  }
12566  
12567  /**
12568   * Returns true if a multi-selection exists, and the block corresponding to the
12569   * specified client ID is the first block of the multi-selection set, or false
12570   * otherwise.
12571   *
12572   * @param {Object} state    Editor state.
12573   * @param {string} clientId Block client ID.
12574   *
12575   * @return {boolean} Whether block is first in multi-selection.
12576   */
12577  function isFirstMultiSelectedBlock(state, clientId) {
12578    return getFirstMultiSelectedBlockClientId(state) === clientId;
12579  }
12580  
12581  /**
12582   * Returns true if the client ID occurs within the block multi-selection, or
12583   * false otherwise.
12584   *
12585   * @param {Object} state    Editor state.
12586   * @param {string} clientId Block client ID.
12587   *
12588   * @return {boolean} Whether block is in multi-selection set.
12589   */
12590  function isBlockMultiSelected(state, clientId) {
12591    return getMultiSelectedBlockClientIds(state).indexOf(clientId) !== -1;
12592  }
12593  
12594  /**
12595   * Returns true if an ancestor of the block is multi-selected, or false
12596   * otherwise.
12597   *
12598   * @param {Object} state    Editor state.
12599   * @param {string} clientId Block client ID.
12600   *
12601   * @return {boolean} Whether an ancestor of the block is in multi-selection
12602   *                   set.
12603   */
12604  const isAncestorMultiSelected = (0,external_wp_data_namespaceObject.createSelector)((state, clientId) => {
12605    let ancestorClientId = clientId;
12606    let isMultiSelected = false;
12607    while (ancestorClientId && !isMultiSelected) {
12608      ancestorClientId = getBlockRootClientId(state, ancestorClientId);
12609      isMultiSelected = isBlockMultiSelected(state, ancestorClientId);
12610    }
12611    return isMultiSelected;
12612  }, state => [state.blocks.order, state.selection.selectionStart.clientId, state.selection.selectionEnd.clientId]);
12613  
12614  /**
12615   * Returns the client ID of the block which begins the multi-selection set, or
12616   * null if there is no multi-selection.
12617   *
12618   * This is not necessarily the first client ID in the selection.
12619   *
12620   * @see getFirstMultiSelectedBlockClientId
12621   *
12622   * @param {Object} state Editor state.
12623   *
12624   * @return {?string} Client ID of block beginning multi-selection.
12625   */
12626  function getMultiSelectedBlocksStartClientId(state) {
12627    const {
12628      selectionStart,
12629      selectionEnd
12630    } = state.selection;
12631    if (selectionStart.clientId === selectionEnd.clientId) {
12632      return null;
12633    }
12634    return selectionStart.clientId || null;
12635  }
12636  
12637  /**
12638   * Returns the client ID of the block which ends the multi-selection set, or
12639   * null if there is no multi-selection.
12640   *
12641   * This is not necessarily the last client ID in the selection.
12642   *
12643   * @see getLastMultiSelectedBlockClientId
12644   *
12645   * @param {Object} state Editor state.
12646   *
12647   * @return {?string} Client ID of block ending multi-selection.
12648   */
12649  function getMultiSelectedBlocksEndClientId(state) {
12650    const {
12651      selectionStart,
12652      selectionEnd
12653    } = state.selection;
12654    if (selectionStart.clientId === selectionEnd.clientId) {
12655      return null;
12656    }
12657    return selectionEnd.clientId || null;
12658  }
12659  
12660  /**
12661   * Returns true if the selection is not partial.
12662   *
12663   * @param {Object} state Editor state.
12664   *
12665   * @return {boolean} Whether the selection is mergeable.
12666   */
12667  function __unstableIsFullySelected(state) {
12668    const selectionAnchor = getSelectionStart(state);
12669    const selectionFocus = getSelectionEnd(state);
12670    return !selectionAnchor.attributeKey && !selectionFocus.attributeKey && typeof selectionAnchor.offset === 'undefined' && typeof selectionFocus.offset === 'undefined';
12671  }
12672  
12673  /**
12674   * Returns true if the selection is collapsed.
12675   *
12676   * @param {Object} state Editor state.
12677   *
12678   * @return {boolean} Whether the selection is collapsed.
12679   */
12680  function __unstableIsSelectionCollapsed(state) {
12681    const selectionAnchor = getSelectionStart(state);
12682    const selectionFocus = getSelectionEnd(state);
12683    return !!selectionAnchor && !!selectionFocus && selectionAnchor.clientId === selectionFocus.clientId && selectionAnchor.attributeKey === selectionFocus.attributeKey && selectionAnchor.offset === selectionFocus.offset;
12684  }
12685  function __unstableSelectionHasUnmergeableBlock(state) {
12686    return getSelectedBlockClientIds(state).some(clientId => {
12687      const blockName = getBlockName(state, clientId);
12688      const blockType = (0,external_wp_blocks_namespaceObject.getBlockType)(blockName);
12689      return !blockType.merge;
12690    });
12691  }
12692  
12693  /**
12694   * Check whether the selection is mergeable.
12695   *
12696   * @param {Object}  state     Editor state.
12697   * @param {boolean} isForward Whether to merge forwards.
12698   *
12699   * @return {boolean} Whether the selection is mergeable.
12700   */
12701  function __unstableIsSelectionMergeable(state, isForward) {
12702    const selectionAnchor = getSelectionStart(state);
12703    const selectionFocus = getSelectionEnd(state);
12704  
12705    // It's not mergeable if the start and end are within the same block.
12706    if (selectionAnchor.clientId === selectionFocus.clientId) {
12707      return false;
12708    }
12709  
12710    // It's not mergeable if there's no rich text selection.
12711    if (!selectionAnchor.attributeKey || !selectionFocus.attributeKey || typeof selectionAnchor.offset === 'undefined' || typeof selectionFocus.offset === 'undefined') {
12712      return false;
12713    }
12714    const anchorRootClientId = getBlockRootClientId(state, selectionAnchor.clientId);
12715    const focusRootClientId = getBlockRootClientId(state, selectionFocus.clientId);
12716  
12717    // It's not mergeable if the selection doesn't start and end in the same
12718    // block list. Maybe in the future it should be allowed.
12719    if (anchorRootClientId !== focusRootClientId) {
12720      return false;
12721    }
12722    const blockOrder = getBlockOrder(state, anchorRootClientId);
12723    const anchorIndex = blockOrder.indexOf(selectionAnchor.clientId);
12724    const focusIndex = blockOrder.indexOf(selectionFocus.clientId);
12725  
12726    // Reassign selection start and end based on order.
12727    let selectionStart, selectionEnd;
12728    if (anchorIndex > focusIndex) {
12729      selectionStart = selectionFocus;
12730      selectionEnd = selectionAnchor;
12731    } else {
12732      selectionStart = selectionAnchor;
12733      selectionEnd = selectionFocus;
12734    }
12735    const targetBlockClientId = isForward ? selectionEnd.clientId : selectionStart.clientId;
12736    const blockToMergeClientId = isForward ? selectionStart.clientId : selectionEnd.clientId;
12737    const targetBlockName = getBlockName(state, targetBlockClientId);
12738    const targetBlockType = (0,external_wp_blocks_namespaceObject.getBlockType)(targetBlockName);
12739    if (!targetBlockType.merge) {
12740      return false;
12741    }
12742    const blockToMerge = getBlock(state, blockToMergeClientId);
12743  
12744    // It's mergeable if the blocks are of the same type.
12745    if (blockToMerge.name === targetBlockName) {
12746      return true;
12747    }
12748  
12749    // If the blocks are of a different type, try to transform the block being
12750    // merged into the same type of block.
12751    const blocksToMerge = (0,external_wp_blocks_namespaceObject.switchToBlockType)(blockToMerge, targetBlockName);
12752    return blocksToMerge && blocksToMerge.length;
12753  }
12754  
12755  /**
12756   * Get partial selected blocks with their content updated
12757   * based on the selection.
12758   *
12759   * @param {Object} state Editor state.
12760   *
12761   * @return {Object[]} Updated partial selected blocks.
12762   */
12763  const __unstableGetSelectedBlocksWithPartialSelection = state => {
12764    const selectionAnchor = getSelectionStart(state);
12765    const selectionFocus = getSelectionEnd(state);
12766    if (selectionAnchor.clientId === selectionFocus.clientId) {
12767      return selectors_EMPTY_ARRAY;
12768    }
12769  
12770    // Can't split if the selection is not set.
12771    if (!selectionAnchor.attributeKey || !selectionFocus.attributeKey || typeof selectionAnchor.offset === 'undefined' || typeof selectionFocus.offset === 'undefined') {
12772      return selectors_EMPTY_ARRAY;
12773    }
12774    const anchorRootClientId = getBlockRootClientId(state, selectionAnchor.clientId);
12775    const focusRootClientId = getBlockRootClientId(state, selectionFocus.clientId);
12776  
12777    // It's not splittable if the selection doesn't start and end in the same
12778    // block list. Maybe in the future it should be allowed.
12779    if (anchorRootClientId !== focusRootClientId) {
12780      return selectors_EMPTY_ARRAY;
12781    }
12782    const blockOrder = getBlockOrder(state, anchorRootClientId);
12783    const anchorIndex = blockOrder.indexOf(selectionAnchor.clientId);
12784    const focusIndex = blockOrder.indexOf(selectionFocus.clientId);
12785  
12786    // Reassign selection start and end based on order.
12787    const [selectionStart, selectionEnd] = anchorIndex > focusIndex ? [selectionFocus, selectionAnchor] : [selectionAnchor, selectionFocus];
12788    const blockA = getBlock(state, selectionStart.clientId);
12789    const blockB = getBlock(state, selectionEnd.clientId);
12790    const htmlA = blockA.attributes[selectionStart.attributeKey];
12791    const htmlB = blockB.attributes[selectionEnd.attributeKey];
12792    let valueA = (0,external_wp_richText_namespaceObject.create)({
12793      html: htmlA
12794    });
12795    let valueB = (0,external_wp_richText_namespaceObject.create)({
12796      html: htmlB
12797    });
12798    valueA = (0,external_wp_richText_namespaceObject.remove)(valueA, 0, selectionStart.offset);
12799    valueB = (0,external_wp_richText_namespaceObject.remove)(valueB, selectionEnd.offset, valueB.text.length);
12800    return [{
12801      ...blockA,
12802      attributes: {
12803        ...blockA.attributes,
12804        [selectionStart.attributeKey]: (0,external_wp_richText_namespaceObject.toHTMLString)({
12805          value: valueA
12806        })
12807      }
12808    }, {
12809      ...blockB,
12810      attributes: {
12811        ...blockB.attributes,
12812        [selectionEnd.attributeKey]: (0,external_wp_richText_namespaceObject.toHTMLString)({
12813          value: valueB
12814        })
12815      }
12816    }];
12817  };
12818  
12819  /**
12820   * Returns an array containing all block client IDs in the editor in the order
12821   * they appear. Optionally accepts a root client ID of the block list for which
12822   * the order should be returned, defaulting to the top-level block order.
12823   *
12824   * @param {Object}  state        Editor state.
12825   * @param {?string} rootClientId Optional root client ID of block list.
12826   *
12827   * @return {Array} Ordered client IDs of editor blocks.
12828   */
12829  function getBlockOrder(state, rootClientId) {
12830    return state.blocks.order.get(rootClientId || '') || selectors_EMPTY_ARRAY;
12831  }
12832  
12833  /**
12834   * Returns the index at which the block corresponding to the specified client
12835   * ID occurs within the block order, or `-1` if the block does not exist.
12836   *
12837   * @param {Object} state    Editor state.
12838   * @param {string} clientId Block client ID.
12839   *
12840   * @return {number} Index at which block exists in order.
12841   */
12842  function getBlockIndex(state, clientId) {
12843    const rootClientId = getBlockRootClientId(state, clientId);
12844    return getBlockOrder(state, rootClientId).indexOf(clientId);
12845  }
12846  
12847  /**
12848   * Returns true if the block corresponding to the specified client ID is
12849   * currently selected and no multi-selection exists, or false otherwise.
12850   *
12851   * @param {Object} state    Editor state.
12852   * @param {string} clientId Block client ID.
12853   *
12854   * @return {boolean} Whether block is selected and multi-selection exists.
12855   */
12856  function isBlockSelected(state, clientId) {
12857    const {
12858      selectionStart,
12859      selectionEnd
12860    } = state.selection;
12861    if (selectionStart.clientId !== selectionEnd.clientId) {
12862      return false;
12863    }
12864    return selectionStart.clientId === clientId;
12865  }
12866  
12867  /**
12868   * Returns true if one of the block's inner blocks is selected.
12869   *
12870   * @param {Object}  state    Editor state.
12871   * @param {string}  clientId Block client ID.
12872   * @param {boolean} deep     Perform a deep check.
12873   *
12874   * @return {boolean} Whether the block has an inner block selected
12875   */
12876  function hasSelectedInnerBlock(state, clientId, deep = false) {
12877    const selectedBlockClientIds = getSelectedBlockClientIds(state);
12878    if (!selectedBlockClientIds.length) {
12879      return false;
12880    }
12881    if (deep) {
12882      return selectedBlockClientIds.some(id =>
12883      // Pass true because we don't care about order and it's more
12884      // performant.
12885      getBlockParents(state, id, true).includes(clientId));
12886    }
12887    return selectedBlockClientIds.some(id => getBlockRootClientId(state, id) === clientId);
12888  }
12889  
12890  /**
12891   * Returns true if one of the block's inner blocks is dragged.
12892   *
12893   * @param {Object}  state    Editor state.
12894   * @param {string}  clientId Block client ID.
12895   * @param {boolean} deep     Perform a deep check.
12896   *
12897   * @return {boolean} Whether the block has an inner block dragged
12898   */
12899  function hasDraggedInnerBlock(state, clientId, deep = false) {
12900    return getBlockOrder(state, clientId).some(innerClientId => isBlockBeingDragged(state, innerClientId) || deep && hasDraggedInnerBlock(state, innerClientId, deep));
12901  }
12902  
12903  /**
12904   * Returns true if the block corresponding to the specified client ID is
12905   * currently selected but isn't the last of the selected blocks. Here "last"
12906   * refers to the block sequence in the document, _not_ the sequence of
12907   * multi-selection, which is why `state.selectionEnd` isn't used.
12908   *
12909   * @param {Object} state    Editor state.
12910   * @param {string} clientId Block client ID.
12911   *
12912   * @return {boolean} Whether block is selected and not the last in the
12913   *                   selection.
12914   */
12915  function isBlockWithinSelection(state, clientId) {
12916    if (!clientId) {
12917      return false;
12918    }
12919    const clientIds = getMultiSelectedBlockClientIds(state);
12920    const index = clientIds.indexOf(clientId);
12921    return index > -1 && index < clientIds.length - 1;
12922  }
12923  
12924  /**
12925   * Returns true if a multi-selection has been made, or false otherwise.
12926   *
12927   * @param {Object} state Editor state.
12928   *
12929   * @return {boolean} Whether multi-selection has been made.
12930   */
12931  function hasMultiSelection(state) {
12932    const {
12933      selectionStart,
12934      selectionEnd
12935    } = state.selection;
12936    return selectionStart.clientId !== selectionEnd.clientId;
12937  }
12938  
12939  /**
12940   * Whether in the process of multi-selecting or not. This flag is only true
12941   * while the multi-selection is being selected (by mouse move), and is false
12942   * once the multi-selection has been settled.
12943   *
12944   * @see hasMultiSelection
12945   *
12946   * @param {Object} state Global application state.
12947   *
12948   * @return {boolean} True if multi-selecting, false if not.
12949   */
12950  function selectors_isMultiSelecting(state) {
12951    return state.isMultiSelecting;
12952  }
12953  
12954  /**
12955   * Selector that returns if multi-selection is enabled or not.
12956   *
12957   * @param {Object} state Global application state.
12958   *
12959   * @return {boolean} True if it should be possible to multi-select blocks, false if multi-selection is disabled.
12960   */
12961  function selectors_isSelectionEnabled(state) {
12962    return state.isSelectionEnabled;
12963  }
12964  
12965  /**
12966   * Returns the block's editing mode, defaulting to "visual" if not explicitly
12967   * assigned.
12968   *
12969   * @param {Object} state    Editor state.
12970   * @param {string} clientId Block client ID.
12971   *
12972   * @return {Object} Block editing mode.
12973   */
12974  function getBlockMode(state, clientId) {
12975    return state.blocksMode[clientId] || 'visual';
12976  }
12977  
12978  /**
12979   * Returns true if the user is typing, or false otherwise.
12980   *
12981   * @param {Object} state Global application state.
12982   *
12983   * @return {boolean} Whether user is typing.
12984   */
12985  function selectors_isTyping(state) {
12986    return state.isTyping;
12987  }
12988  
12989  /**
12990   * Returns true if the user is dragging blocks, or false otherwise.
12991   *
12992   * @param {Object} state Global application state.
12993   *
12994   * @return {boolean} Whether user is dragging blocks.
12995   */
12996  function isDraggingBlocks(state) {
12997    return !!state.draggedBlocks.length;
12998  }
12999  
13000  /**
13001   * Returns the client ids of any blocks being directly dragged.
13002   *
13003   * This does not include children of a parent being dragged.
13004   *
13005   * @param {Object} state Global application state.
13006   *
13007   * @return {string[]} Array of dragged block client ids.
13008   */
13009  function getDraggedBlockClientIds(state) {
13010    return state.draggedBlocks;
13011  }
13012  
13013  /**
13014   * Returns whether the block is being dragged.
13015   *
13016   * Only returns true if the block is being directly dragged,
13017   * not if the block is a child of a parent being dragged.
13018   * See `isAncestorBeingDragged` for child blocks.
13019   *
13020   * @param {Object} state    Global application state.
13021   * @param {string} clientId Client id for block to check.
13022   *
13023   * @return {boolean} Whether the block is being dragged.
13024   */
13025  function isBlockBeingDragged(state, clientId) {
13026    return state.draggedBlocks.includes(clientId);
13027  }
13028  
13029  /**
13030   * Returns whether a parent/ancestor of the block is being dragged.
13031   *
13032   * @param {Object} state    Global application state.
13033   * @param {string} clientId Client id for block to check.
13034   *
13035   * @return {boolean} Whether the block's ancestor is being dragged.
13036   */
13037  function isAncestorBeingDragged(state, clientId) {
13038    // Return early if no blocks are being dragged rather than
13039    // the more expensive check for parents.
13040    if (!isDraggingBlocks(state)) {
13041      return false;
13042    }
13043    const parents = getBlockParents(state, clientId);
13044    return parents.some(parentClientId => isBlockBeingDragged(state, parentClientId));
13045  }
13046  
13047  /**
13048   * Returns true if the caret is within formatted text, or false otherwise.
13049   *
13050   * @deprecated
13051   *
13052   * @return {boolean} Whether the caret is within formatted text.
13053   */
13054  function isCaretWithinFormattedText() {
13055    external_wp_deprecated_default()('wp.data.select( "core/block-editor" ).isCaretWithinFormattedText', {
13056      since: '6.1',
13057      version: '6.3'
13058    });
13059    return false;
13060  }
13061  
13062  /**
13063   * Returns the location of the insertion cue. Defaults to the last index.
13064   *
13065   * @param {Object} state Editor state.
13066   *
13067   * @return {Object} Insertion point object with `rootClientId`, `index`.
13068   */
13069  const getBlockInsertionPoint = (0,external_wp_data_namespaceObject.createSelector)(state => {
13070    let rootClientId, index;
13071    const {
13072      insertionCue,
13073      selection: {
13074        selectionEnd
13075      }
13076    } = state;
13077    if (insertionCue !== null) {
13078      return insertionCue;
13079    }
13080    const {
13081      clientId
13082    } = selectionEnd;
13083    if (clientId) {
13084      rootClientId = getBlockRootClientId(state, clientId) || undefined;
13085      index = getBlockIndex(state, selectionEnd.clientId) + 1;
13086    } else {
13087      index = getBlockOrder(state).length;
13088    }
13089    return {
13090      rootClientId,
13091      index
13092    };
13093  }, state => [state.insertionCue, state.selection.selectionEnd.clientId, state.blocks.parents, state.blocks.order]);
13094  
13095  /**
13096   * Returns true if the block insertion point is visible.
13097   *
13098   * @param {Object} state Global application state.
13099   *
13100   * @return {?boolean} Whether the insertion point is visible or not.
13101   */
13102  function isBlockInsertionPointVisible(state) {
13103    return state.insertionCue !== null;
13104  }
13105  
13106  /**
13107   * Returns whether the blocks matches the template or not.
13108   *
13109   * @param {boolean} state
13110   * @return {?boolean} Whether the template is valid or not.
13111   */
13112  function isValidTemplate(state) {
13113    return state.template.isValid;
13114  }
13115  
13116  /**
13117   * Returns the defined block template
13118   *
13119   * @param {boolean} state
13120   *
13121   * @return {?Array} Block Template.
13122   */
13123  function getTemplate(state) {
13124    return state.settings.template;
13125  }
13126  
13127  /**
13128   * Returns the defined block template lock. Optionally accepts a root block
13129   * client ID as context, otherwise defaulting to the global context.
13130   *
13131   * @param {Object}  state        Editor state.
13132   * @param {?string} rootClientId Optional block root client ID.
13133   *
13134   * @return {string|false} Block Template Lock
13135   */
13136  function getTemplateLock(state, rootClientId) {
13137    var _getBlockListSettings;
13138    if (!rootClientId) {
13139      var _state$settings$templ;
13140      return (_state$settings$templ = state.settings.templateLock) !== null && _state$settings$templ !== void 0 ? _state$settings$templ : false;
13141    }
13142    return (_getBlockListSettings = getBlockListSettings(state, rootClientId)?.templateLock) !== null && _getBlockListSettings !== void 0 ? _getBlockListSettings : false;
13143  }
13144  
13145  /**
13146   * Determines if the given block type is visible in the inserter.
13147   * Note that this is different than whether a block is allowed to be inserted.
13148   * In some cases, the block is not allowed in a given position but
13149   * it should still be visible in the inserter to be able to add it
13150   * to a different position.
13151   *
13152   * @param {Object}        state           Editor state.
13153   * @param {string|Object} blockNameOrType The block type object, e.g., the response
13154   *                                        from the block directory; or a string name of
13155   *                                        an installed block type, e.g.' core/paragraph'.
13156   * @param {?string}       rootClientId    Optional root client ID of block list.
13157   *
13158   * @return {boolean} Whether the given block type is allowed to be inserted.
13159   */
13160  const isBlockVisibleInTheInserter = (state, blockNameOrType, rootClientId = null) => {
13161    let blockType;
13162    let blockName;
13163    if (blockNameOrType && 'object' === typeof blockNameOrType) {
13164      blockType = blockNameOrType;
13165      blockName = blockNameOrType.name;
13166    } else {
13167      blockType = (0,external_wp_blocks_namespaceObject.getBlockType)(blockNameOrType);
13168      blockName = blockNameOrType;
13169    }
13170    if (!blockType) {
13171      return false;
13172    }
13173    const {
13174      allowedBlockTypes
13175    } = getSettings(state);
13176    const isBlockAllowedInEditor = checkAllowList(allowedBlockTypes, blockName, true);
13177    if (!isBlockAllowedInEditor) {
13178      return false;
13179    }
13180  
13181    // If parent blocks are not visible, child blocks should be hidden too.
13182    const parents = (Array.isArray(blockType.parent) ? blockType.parent : []).concat(Array.isArray(blockType.ancestor) ? blockType.ancestor : []);
13183    if (parents.length > 0) {
13184      // This is an exception to the rule that says that all blocks are visible in the inserter.
13185      // Blocks that require a given parent or ancestor are only visible if we're within that parent.
13186      if (parents.includes('core/post-content')) {
13187        return true;
13188      }
13189      let current = rootClientId;
13190      let hasParent = false;
13191      do {
13192        if (parents.includes(getBlockName(state, current))) {
13193          hasParent = true;
13194          break;
13195        }
13196        current = state.blocks.parents.get(current);
13197      } while (current);
13198      return hasParent;
13199    }
13200    return true;
13201  };
13202  
13203  /**
13204   * Determines if the given block type is allowed to be inserted into the block list.
13205   * This function is not exported and not memoized because using a memoized selector
13206   * inside another memoized selector is just a waste of time.
13207   *
13208   * @param {Object}        state        Editor state.
13209   * @param {string|Object} blockName    The block type object, e.g., the response
13210   *                                     from the block directory; or a string name of
13211   *                                     an installed block type, e.g.' core/paragraph'.
13212   * @param {?string}       rootClientId Optional root client ID of block list.
13213   *
13214   * @return {boolean} Whether the given block type is allowed to be inserted.
13215   */
13216  const canInsertBlockTypeUnmemoized = (state, blockName, rootClientId = null) => {
13217    if (!isBlockVisibleInTheInserter(state, blockName, rootClientId)) {
13218      return false;
13219    }
13220    let blockType;
13221    if (blockName && 'object' === typeof blockName) {
13222      blockType = blockName;
13223      blockName = blockType.name;
13224    } else {
13225      blockType = (0,external_wp_blocks_namespaceObject.getBlockType)(blockName);
13226    }
13227    const isLocked = !!getTemplateLock(state, rootClientId);
13228    if (isLocked) {
13229      return false;
13230    }
13231    const _isSectionBlock = !!isSectionBlock(state, rootClientId);
13232    if (_isSectionBlock) {
13233      return false;
13234    }
13235    if (getBlockEditingMode(state, rootClientId !== null && rootClientId !== void 0 ? rootClientId : '') === 'disabled') {
13236      return false;
13237    }
13238    const parentBlockListSettings = getBlockListSettings(state, rootClientId);
13239  
13240    // The parent block doesn't have settings indicating it doesn't support
13241    // inner blocks, return false.
13242    if (rootClientId && parentBlockListSettings === undefined) {
13243      return false;
13244    }
13245    const parentName = getBlockName(state, rootClientId);
13246    const parentBlockType = (0,external_wp_blocks_namespaceObject.getBlockType)(parentName);
13247  
13248    // Look at the `blockType.allowedBlocks` field to determine whether this is an allowed child block.
13249    const parentAllowedChildBlocks = parentBlockType?.allowedBlocks;
13250    let hasParentAllowedBlock = checkAllowList(parentAllowedChildBlocks, blockName);
13251  
13252    // The `allowedBlocks` block list setting can further limit which blocks are allowed children.
13253    if (hasParentAllowedBlock !== false) {
13254      const parentAllowedBlocks = parentBlockListSettings?.allowedBlocks;
13255      const hasParentListAllowedBlock = checkAllowList(parentAllowedBlocks, blockName);
13256      // Never downgrade the result from `true` to `null`
13257      if (hasParentListAllowedBlock !== null) {
13258        hasParentAllowedBlock = hasParentListAllowedBlock;
13259      }
13260    }
13261    const blockAllowedParentBlocks = blockType.parent;
13262    const hasBlockAllowedParent = checkAllowList(blockAllowedParentBlocks, parentName);
13263    let hasBlockAllowedAncestor = true;
13264    const blockAllowedAncestorBlocks = blockType.ancestor;
13265    if (blockAllowedAncestorBlocks) {
13266      const ancestors = [rootClientId, ...getBlockParents(state, rootClientId)];
13267      hasBlockAllowedAncestor = ancestors.some(ancestorClientId => checkAllowList(blockAllowedAncestorBlocks, getBlockName(state, ancestorClientId)));
13268    }
13269    const canInsert = hasBlockAllowedAncestor && (hasParentAllowedBlock === null && hasBlockAllowedParent === null || hasParentAllowedBlock === true || hasBlockAllowedParent === true);
13270    if (!canInsert) {
13271      return canInsert;
13272    }
13273  
13274    /**
13275     * This filter is an ad-hoc solution to prevent adding template parts inside post content.
13276     * Conceptually, having a filter inside a selector is bad pattern so this code will be
13277     * replaced by a declarative API that doesn't the following drawbacks:
13278     *
13279     * Filters are not reactive: Upon switching between "template mode" and non "template mode",
13280     * the filter and selector won't necessarily be executed again. For now, it doesn't matter much
13281     * because you can't switch between the two modes while the inserter stays open.
13282     *
13283     * Filters are global: Once they're defined, they will affect all editor instances and all registries.
13284     * An ideal API would only affect specific editor instances.
13285     */
13286    return (0,external_wp_hooks_namespaceObject.applyFilters)('blockEditor.__unstableCanInsertBlockType', canInsert, blockType, rootClientId, {
13287      // Pass bound selectors of the current registry. If we're in a nested
13288      // context, the data will differ from the one selected from the root
13289      // registry.
13290      getBlock: getBlock.bind(null, state),
13291      getBlockParentsByBlockName: getBlockParentsByBlockName.bind(null, state)
13292    });
13293  };
13294  
13295  /**
13296   * Determines if the given block type is allowed to be inserted into the block list.
13297   *
13298   * @param {Object}  state        Editor state.
13299   * @param {string}  blockName    The name of the block type, e.g.' core/paragraph'.
13300   * @param {?string} rootClientId Optional root client ID of block list.
13301   *
13302   * @return {boolean} Whether the given block type is allowed to be inserted.
13303   */
13304  const canInsertBlockType = (0,external_wp_data_namespaceObject.createRegistrySelector)(select => (0,external_wp_data_namespaceObject.createSelector)(canInsertBlockTypeUnmemoized, (state, blockName, rootClientId) => getInsertBlockTypeDependants(select)(state, rootClientId)));
13305  
13306  /**
13307   * Determines if the given blocks are allowed to be inserted into the block
13308   * list.
13309   *
13310   * @param {Object}  state        Editor state.
13311   * @param {string}  clientIds    The block client IDs to be inserted.
13312   * @param {?string} rootClientId Optional root client ID of block list.
13313   *
13314   * @return {boolean} Whether the given blocks are allowed to be inserted.
13315   */
13316  function canInsertBlocks(state, clientIds, rootClientId = null) {
13317    return clientIds.every(id => canInsertBlockType(state, getBlockName(state, id), rootClientId));
13318  }
13319  
13320  /**
13321   * Determines if the given block is allowed to be deleted.
13322   *
13323   * @param {Object} state    Editor state.
13324   * @param {string} clientId The block client Id.
13325   *
13326   * @return {boolean} Whether the given block is allowed to be removed.
13327   */
13328  function canRemoveBlock(state, clientId) {
13329    const attributes = getBlockAttributes(state, clientId);
13330    if (attributes === null) {
13331      return true;
13332    }
13333    if (attributes.lock?.remove !== undefined) {
13334      return !attributes.lock.remove;
13335    }
13336    const rootClientId = getBlockRootClientId(state, clientId);
13337    if (getTemplateLock(state, rootClientId)) {
13338      return false;
13339    }
13340    const isBlockWithinSection = !!getParentSectionBlock(state, clientId);
13341    if (isBlockWithinSection) {
13342      return false;
13343    }
13344    return getBlockEditingMode(state, rootClientId) !== 'disabled';
13345  }
13346  
13347  /**
13348   * Determines if the given blocks are allowed to be removed.
13349   *
13350   * @param {Object} state     Editor state.
13351   * @param {string} clientIds The block client IDs to be removed.
13352   *
13353   * @return {boolean} Whether the given blocks are allowed to be removed.
13354   */
13355  function canRemoveBlocks(state, clientIds) {
13356    return clientIds.every(clientId => canRemoveBlock(state, clientId));
13357  }
13358  
13359  /**
13360   * Determines if the given block is allowed to be moved.
13361   *
13362   * @param {Object} state    Editor state.
13363   * @param {string} clientId The block client Id.
13364   *
13365   * @return {boolean} Whether the given block is allowed to be moved.
13366   */
13367  function canMoveBlock(state, clientId) {
13368    const attributes = getBlockAttributes(state, clientId);
13369    if (attributes === null) {
13370      return true;
13371    }
13372    if (attributes.lock?.move !== undefined) {
13373      return !attributes.lock.move;
13374    }
13375    const rootClientId = getBlockRootClientId(state, clientId);
13376    if (getTemplateLock(state, rootClientId) === 'all') {
13377      return false;
13378    }
13379    return getBlockEditingMode(state, rootClientId) !== 'disabled';
13380  }
13381  
13382  /**
13383   * Determines if the given blocks are allowed to be moved.
13384   *
13385   * @param {Object} state     Editor state.
13386   * @param {string} clientIds The block client IDs to be moved.
13387   *
13388   * @return {boolean} Whether the given blocks are allowed to be moved.
13389   */
13390  function canMoveBlocks(state, clientIds) {
13391    return clientIds.every(clientId => canMoveBlock(state, clientId));
13392  }
13393  
13394  /**
13395   * Determines if the given block is allowed to be edited.
13396   *
13397   * @param {Object} state    Editor state.
13398   * @param {string} clientId The block client Id.
13399   *
13400   * @return {boolean} Whether the given block is allowed to be edited.
13401   */
13402  function canEditBlock(state, clientId) {
13403    const attributes = getBlockAttributes(state, clientId);
13404    if (attributes === null) {
13405      return true;
13406    }
13407    const {
13408      lock
13409    } = attributes;
13410  
13411    // When the edit is true, we cannot edit the block.
13412    return !lock?.edit;
13413  }
13414  
13415  /**
13416   * Determines if the given block type can be locked/unlocked by a user.
13417   *
13418   * @param {Object}          state      Editor state.
13419   * @param {(string|Object)} nameOrType Block name or type object.
13420   *
13421   * @return {boolean} Whether a given block type can be locked/unlocked.
13422   */
13423  function canLockBlockType(state, nameOrType) {
13424    if (!(0,external_wp_blocks_namespaceObject.hasBlockSupport)(nameOrType, 'lock', true)) {
13425      return false;
13426    }
13427  
13428    // Use block editor settings as the default value.
13429    return !!state.settings?.canLockBlocks;
13430  }
13431  
13432  /**
13433   * Returns information about how recently and frequently a block has been inserted.
13434   *
13435   * @param {Object} state Global application state.
13436   * @param {string} id    A string which identifies the insert, e.g. 'core/block/12'
13437   *
13438   * @return {?{ time: number, count: number }} An object containing `time` which is when the last
13439   *                                            insert occurred as a UNIX epoch, and `count` which is
13440   *                                            the number of inserts that have occurred.
13441   */
13442  function getInsertUsage(state, id) {
13443    var _state$preferences$in;
13444    return (_state$preferences$in = state.preferences.insertUsage?.[id]) !== null && _state$preferences$in !== void 0 ? _state$preferences$in : null;
13445  }
13446  
13447  /**
13448   * Returns whether we can show a block type in the inserter
13449   *
13450   * @param {Object}  state        Global State
13451   * @param {Object}  blockType    BlockType
13452   * @param {?string} rootClientId Optional root client ID of block list.
13453   *
13454   * @return {boolean} Whether the given block type is allowed to be shown in the inserter.
13455   */
13456  const canIncludeBlockTypeInInserter = (state, blockType, rootClientId) => {
13457    if (!(0,external_wp_blocks_namespaceObject.hasBlockSupport)(blockType, 'inserter', true)) {
13458      return false;
13459    }
13460    return canInsertBlockTypeUnmemoized(state, blockType.name, rootClientId);
13461  };
13462  
13463  /**
13464   * Return a function to be used to transform a block variation to an inserter item
13465   *
13466   * @param {Object} state Global State
13467   * @param {Object} item  Denormalized inserter item
13468   * @return {Function} Function to transform a block variation to inserter item
13469   */
13470  const getItemFromVariation = (state, item) => variation => {
13471    const variationId = `$item.id}/$variation.name}`;
13472    const {
13473      time,
13474      count = 0
13475    } = getInsertUsage(state, variationId) || {};
13476    return {
13477      ...item,
13478      id: variationId,
13479      icon: variation.icon || item.icon,
13480      title: variation.title || item.title,
13481      description: variation.description || item.description,
13482      category: variation.category || item.category,
13483      // If `example` is explicitly undefined for the variation, the preview will not be shown.
13484      example: variation.hasOwnProperty('example') ? variation.example : item.example,
13485      initialAttributes: {
13486        ...item.initialAttributes,
13487        ...variation.attributes
13488      },
13489      innerBlocks: variation.innerBlocks,
13490      keywords: variation.keywords || item.keywords,
13491      frecency: calculateFrecency(time, count)
13492    };
13493  };
13494  
13495  /**
13496   * Returns the calculated frecency.
13497   *
13498   * 'frecency' is a heuristic (https://en.wikipedia.org/wiki/Frecency)
13499   * that combines block usage frequency and recency.
13500   *
13501   * @param {number} time  When the last insert occurred as a UNIX epoch
13502   * @param {number} count The number of inserts that have occurred.
13503   *
13504   * @return {number} The calculated frecency.
13505   */
13506  const calculateFrecency = (time, count) => {
13507    if (!time) {
13508      return count;
13509    }
13510    // The selector is cached, which means Date.now() is the last time that the
13511    // relevant state changed. This suits our needs.
13512    const duration = Date.now() - time;
13513    switch (true) {
13514      case duration < MILLISECONDS_PER_HOUR:
13515        return count * 4;
13516      case duration < MILLISECONDS_PER_DAY:
13517        return count * 2;
13518      case duration < MILLISECONDS_PER_WEEK:
13519        return count / 2;
13520      default:
13521        return count / 4;
13522    }
13523  };
13524  
13525  /**
13526   * Returns a function that accepts a block type and builds an item to be shown
13527   * in a specific context. It's used for building items for Inserter and available
13528   * block Transforms list.
13529   *
13530   * @param {Object} state              Editor state.
13531   * @param {Object} options            Options object for handling the building of a block type.
13532   * @param {string} options.buildScope The scope for which the item is going to be used.
13533   * @return {Function} Function returns an item to be shown in a specific context (Inserter|Transforms list).
13534   */
13535  const buildBlockTypeItem = (state, {
13536    buildScope = 'inserter'
13537  }) => blockType => {
13538    const id = blockType.name;
13539    let isDisabled = false;
13540    if (!(0,external_wp_blocks_namespaceObject.hasBlockSupport)(blockType.name, 'multiple', true)) {
13541      isDisabled = getBlocksByClientId(state, getClientIdsWithDescendants(state)).some(({
13542        name
13543      }) => name === blockType.name);
13544    }
13545    const {
13546      time,
13547      count = 0
13548    } = getInsertUsage(state, id) || {};
13549    const blockItemBase = {
13550      id,
13551      name: blockType.name,
13552      title: blockType.title,
13553      icon: blockType.icon,
13554      isDisabled,
13555      frecency: calculateFrecency(time, count)
13556    };
13557    if (buildScope === 'transform') {
13558      return blockItemBase;
13559    }
13560    const inserterVariations = (0,external_wp_blocks_namespaceObject.getBlockVariations)(blockType.name, 'inserter');
13561    return {
13562      ...blockItemBase,
13563      initialAttributes: {},
13564      description: blockType.description,
13565      category: blockType.category,
13566      keywords: blockType.keywords,
13567      parent: blockType.parent,
13568      ancestor: blockType.ancestor,
13569      variations: inserterVariations,
13570      example: blockType.example,
13571      utility: 1 // Deprecated.
13572    };
13573  };
13574  
13575  /**
13576   * Determines the items that appear in the inserter. Includes both static
13577   * items (e.g. a regular block type) and dynamic items (e.g. a reusable block).
13578   *
13579   * Each item object contains what's necessary to display a button in the
13580   * inserter and handle its selection.
13581   *
13582   * The 'frecency' property is a heuristic (https://en.wikipedia.org/wiki/Frecency)
13583   * that combines block usage frequency and recency.
13584   *
13585   * Items are returned ordered descendingly by their 'utility' and 'frecency'.
13586   *
13587   * @param    {Object}   state             Editor state.
13588   * @param    {?string}  rootClientId      Optional root client ID of block list.
13589   *
13590   * @return {WPEditorInserterItem[]} Items that appear in inserter.
13591   *
13592   * @typedef {Object} WPEditorInserterItem
13593   * @property {string}   id                Unique identifier for the item.
13594   * @property {string}   name              The type of block to create.
13595   * @property {Object}   initialAttributes Attributes to pass to the newly created block.
13596   * @property {string}   title             Title of the item, as it appears in the inserter.
13597   * @property {string}   icon              Dashicon for the item, as it appears in the inserter.
13598   * @property {string}   category          Block category that the item is associated with.
13599   * @property {string[]} keywords          Keywords that can be searched to find this item.
13600   * @property {boolean}  isDisabled        Whether or not the user should be prevented from inserting
13601   *                                        this item.
13602   * @property {number}   frecency          Heuristic that combines frequency and recency.
13603   */
13604  const getInserterItems = (0,external_wp_data_namespaceObject.createRegistrySelector)(select => (0,external_wp_data_namespaceObject.createSelector)((state, rootClientId = null, options = DEFAULT_INSERTER_OPTIONS) => {
13605    const buildReusableBlockInserterItem = reusableBlock => {
13606      const icon = !reusableBlock.wp_pattern_sync_status ? {
13607        src: library_symbol,
13608        foreground: 'var(--wp-block-synced-color)'
13609      } : library_symbol;
13610      const id = `core/block/$reusableBlock.id}`;
13611      const {
13612        time,
13613        count = 0
13614      } = getInsertUsage(state, id) || {};
13615      const frecency = calculateFrecency(time, count);
13616      return {
13617        id,
13618        name: 'core/block',
13619        initialAttributes: {
13620          ref: reusableBlock.id
13621        },
13622        title: reusableBlock.title?.raw,
13623        icon,
13624        category: 'reusable',
13625        keywords: ['reusable'],
13626        isDisabled: false,
13627        utility: 1,
13628        // Deprecated.
13629        frecency,
13630        content: reusableBlock.content?.raw,
13631        syncStatus: reusableBlock.wp_pattern_sync_status
13632      };
13633    };
13634    const syncedPatternInserterItems = canInsertBlockTypeUnmemoized(state, 'core/block', rootClientId) ? unlock(select(STORE_NAME)).getReusableBlocks().map(buildReusableBlockInserterItem) : [];
13635    const buildBlockTypeInserterItem = buildBlockTypeItem(state, {
13636      buildScope: 'inserter'
13637    });
13638    let blockTypeInserterItems = (0,external_wp_blocks_namespaceObject.getBlockTypes)().filter(blockType => (0,external_wp_blocks_namespaceObject.hasBlockSupport)(blockType, 'inserter', true)).map(buildBlockTypeInserterItem);
13639    if (options[isFiltered] !== false) {
13640      blockTypeInserterItems = blockTypeInserterItems.filter(blockType => canIncludeBlockTypeInInserter(state, blockType, rootClientId));
13641    } else {
13642      blockTypeInserterItems = blockTypeInserterItems.filter(blockType => isBlockVisibleInTheInserter(state, blockType, rootClientId)).map(blockType => ({
13643        ...blockType,
13644        isAllowedInCurrentRoot: canIncludeBlockTypeInInserter(state, blockType, rootClientId)
13645      }));
13646    }
13647    const items = blockTypeInserterItems.reduce((accumulator, item) => {
13648      const {
13649        variations = []
13650      } = item;
13651      // Exclude any block type item that is to be replaced by a default variation.
13652      if (!variations.some(({
13653        isDefault
13654      }) => isDefault)) {
13655        accumulator.push(item);
13656      }
13657      if (variations.length) {
13658        const variationMapper = getItemFromVariation(state, item);
13659        accumulator.push(...variations.map(variationMapper));
13660      }
13661      return accumulator;
13662    }, []);
13663  
13664    // Ensure core blocks are prioritized in the returned results,
13665    // because third party blocks can be registered earlier than
13666    // the core blocks (usually by using the `init` action),
13667    // thus affecting the display order.
13668    // We don't sort reusable blocks as they are handled differently.
13669    const groupByType = (blocks, block) => {
13670      const {
13671        core,
13672        noncore
13673      } = blocks;
13674      const type = block.name.startsWith('core/') ? core : noncore;
13675      type.push(block);
13676      return blocks;
13677    };
13678    const {
13679      core: coreItems,
13680      noncore: nonCoreItems
13681    } = items.reduce(groupByType, {
13682      core: [],
13683      noncore: []
13684    });
13685    const sortedBlockTypes = [...coreItems, ...nonCoreItems];
13686    return [...sortedBlockTypes, ...syncedPatternInserterItems];
13687  }, (state, rootClientId) => [(0,external_wp_blocks_namespaceObject.getBlockTypes)(), unlock(select(STORE_NAME)).getReusableBlocks(), state.blocks.order, state.preferences.insertUsage, ...getInsertBlockTypeDependants(select)(state, rootClientId)]));
13688  
13689  /**
13690   * Determines the items that appear in the available block transforms list.
13691   *
13692   * Each item object contains what's necessary to display a menu item in the
13693   * transform list and handle its selection.
13694   *
13695   * The 'frecency' property is a heuristic (https://en.wikipedia.org/wiki/Frecency)
13696   * that combines block usage frequency and recency.
13697   *
13698   * Items are returned ordered descendingly by their 'frecency'.
13699   *
13700   * @param    {Object}          state        Editor state.
13701   * @param    {Object|Object[]} blocks       Block object or array objects.
13702   * @param    {?string}         rootClientId Optional root client ID of block list.
13703   *
13704   * @return {WPEditorTransformItem[]} Items that appear in inserter.
13705   *
13706   * @typedef {Object} WPEditorTransformItem
13707   * @property {string}          id           Unique identifier for the item.
13708   * @property {string}          name         The type of block to create.
13709   * @property {string}          title        Title of the item, as it appears in the inserter.
13710   * @property {string}          icon         Dashicon for the item, as it appears in the inserter.
13711   * @property {boolean}         isDisabled   Whether or not the user should be prevented from inserting
13712   *                                          this item.
13713   * @property {number}          frecency     Heuristic that combines frequency and recency.
13714   */
13715  const getBlockTransformItems = (0,external_wp_data_namespaceObject.createRegistrySelector)(select => (0,external_wp_data_namespaceObject.createSelector)((state, blocks, rootClientId = null) => {
13716    const normalizedBlocks = Array.isArray(blocks) ? blocks : [blocks];
13717    const buildBlockTypeTransformItem = buildBlockTypeItem(state, {
13718      buildScope: 'transform'
13719    });
13720    const blockTypeTransformItems = (0,external_wp_blocks_namespaceObject.getBlockTypes)().filter(blockType => canIncludeBlockTypeInInserter(state, blockType, rootClientId)).map(buildBlockTypeTransformItem);
13721    const itemsByName = Object.fromEntries(Object.entries(blockTypeTransformItems).map(([, value]) => [value.name, value]));
13722    const possibleTransforms = (0,external_wp_blocks_namespaceObject.getPossibleBlockTransformations)(normalizedBlocks).reduce((accumulator, block) => {
13723      if (itemsByName[block?.name]) {
13724        accumulator.push(itemsByName[block.name]);
13725      }
13726      return accumulator;
13727    }, []);
13728    return orderBy(possibleTransforms, block => itemsByName[block.name].frecency, 'desc');
13729  }, (state, blocks, rootClientId) => [(0,external_wp_blocks_namespaceObject.getBlockTypes)(), state.preferences.insertUsage, ...getInsertBlockTypeDependants(select)(state, rootClientId)]));
13730  
13731  /**
13732   * Determines whether there are items to show in the inserter.
13733   *
13734   * @param {Object}  state        Editor state.
13735   * @param {?string} rootClientId Optional root client ID of block list.
13736   *
13737   * @return {boolean} Items that appear in inserter.
13738   */
13739  const hasInserterItems = (0,external_wp_data_namespaceObject.createRegistrySelector)(select => (state, rootClientId = null) => {
13740    const hasBlockType = (0,external_wp_blocks_namespaceObject.getBlockTypes)().some(blockType => canIncludeBlockTypeInInserter(state, blockType, rootClientId));
13741    if (hasBlockType) {
13742      return true;
13743    }
13744    const hasReusableBlock = canInsertBlockTypeUnmemoized(state, 'core/block', rootClientId) && unlock(select(STORE_NAME)).getReusableBlocks().length > 0;
13745    return hasReusableBlock;
13746  });
13747  
13748  /**
13749   * Returns the list of allowed inserter blocks for inner blocks children.
13750   *
13751   * @param {Object}  state        Editor state.
13752   * @param {?string} rootClientId Optional root client ID of block list.
13753   *
13754   * @return {Array?} The list of allowed block types.
13755   */
13756  const getAllowedBlocks = (0,external_wp_data_namespaceObject.createRegistrySelector)(select => (0,external_wp_data_namespaceObject.createSelector)((state, rootClientId = null) => {
13757    if (!rootClientId) {
13758      return;
13759    }
13760    const blockTypes = (0,external_wp_blocks_namespaceObject.getBlockTypes)().filter(blockType => canIncludeBlockTypeInInserter(state, blockType, rootClientId));
13761    const hasReusableBlock = canInsertBlockTypeUnmemoized(state, 'core/block', rootClientId) && unlock(select(STORE_NAME)).getReusableBlocks().length > 0;
13762    if (hasReusableBlock) {
13763      blockTypes.push('core/block');
13764    }
13765    return blockTypes;
13766  }, (state, rootClientId) => [(0,external_wp_blocks_namespaceObject.getBlockTypes)(), unlock(select(STORE_NAME)).getReusableBlocks(), ...getInsertBlockTypeDependants(select)(state, rootClientId)]));
13767  const __experimentalGetAllowedBlocks = (0,external_wp_data_namespaceObject.createSelector)((state, rootClientId = null) => {
13768    external_wp_deprecated_default()('wp.data.select( "core/block-editor" ).__experimentalGetAllowedBlocks', {
13769      alternative: 'wp.data.select( "core/block-editor" ).getAllowedBlocks',
13770      since: '6.2',
13771      version: '6.4'
13772    });
13773    return getAllowedBlocks(state, rootClientId);
13774  }, (state, rootClientId) => getAllowedBlocks.getDependants(state, rootClientId));
13775  
13776  /**
13777   * Returns the block to be directly inserted by the block appender.
13778   *
13779   * @param    {Object}         state            Editor state.
13780   * @param    {?string}        rootClientId     Optional root client ID of block list.
13781   *
13782   * @return {WPDirectInsertBlock|undefined}              The block type to be directly inserted.
13783   *
13784   * @typedef {Object} WPDirectInsertBlock
13785   * @property {string}         name             The type of block.
13786   * @property {?Object}        attributes       Attributes to pass to the newly created block.
13787   * @property {?Array<string>} attributesToCopy Attributes to be copied from adjacent blocks when inserted.
13788   */
13789  function getDirectInsertBlock(state, rootClientId = null) {
13790    var _state$blockListSetti;
13791    if (!rootClientId) {
13792      return;
13793    }
13794    const {
13795      defaultBlock,
13796      directInsert
13797    } = (_state$blockListSetti = state.blockListSettings[rootClientId]) !== null && _state$blockListSetti !== void 0 ? _state$blockListSetti : {};
13798    if (!defaultBlock || !directInsert) {
13799      return;
13800    }
13801    return defaultBlock;
13802  }
13803  function __experimentalGetDirectInsertBlock(state, rootClientId = null) {
13804    external_wp_deprecated_default()('wp.data.select( "core/block-editor" ).__experimentalGetDirectInsertBlock', {
13805      alternative: 'wp.data.select( "core/block-editor" ).getDirectInsertBlock',
13806      since: '6.3',
13807      version: '6.4'
13808    });
13809    return getDirectInsertBlock(state, rootClientId);
13810  }
13811  const __experimentalGetParsedPattern = (0,external_wp_data_namespaceObject.createRegistrySelector)(select => (state, patternName) => {
13812    const pattern = unlock(select(STORE_NAME)).getPatternBySlug(patternName);
13813    return pattern ? getParsedPattern(pattern) : null;
13814  });
13815  const getAllowedPatternsDependants = select => (state, rootClientId) => [...getAllPatternsDependants(select)(state), ...getInsertBlockTypeDependants(select)(state, rootClientId)];
13816  const patternsWithParsedBlocks = new WeakMap();
13817  function enhancePatternWithParsedBlocks(pattern) {
13818    let enhancedPattern = patternsWithParsedBlocks.get(pattern);
13819    if (!enhancedPattern) {
13820      enhancedPattern = {
13821        ...pattern,
13822        get blocks() {
13823          return getParsedPattern(pattern).blocks;
13824        }
13825      };
13826      patternsWithParsedBlocks.set(pattern, enhancedPattern);
13827    }
13828    return enhancedPattern;
13829  }
13830  
13831  /**
13832   * Returns the list of allowed patterns for inner blocks children.
13833   *
13834   * @param {Object}  state        Editor state.
13835   * @param {?string} rootClientId Optional target root client ID.
13836   *
13837   * @return {Array?} The list of allowed patterns.
13838   */
13839  const __experimentalGetAllowedPatterns = (0,external_wp_data_namespaceObject.createRegistrySelector)(select => {
13840    return (0,external_wp_data_namespaceObject.createSelector)((state, rootClientId = null, options = DEFAULT_INSERTER_OPTIONS) => {
13841      const {
13842        getAllPatterns
13843      } = unlock(select(STORE_NAME));
13844      const patterns = getAllPatterns();
13845      const {
13846        allowedBlockTypes
13847      } = getSettings(state);
13848      const parsedPatterns = patterns.filter(({
13849        inserter = true
13850      }) => !!inserter).map(enhancePatternWithParsedBlocks);
13851      const availableParsedPatterns = parsedPatterns.filter(pattern => checkAllowListRecursive(getGrammar(pattern), allowedBlockTypes));
13852      const patternsAllowed = availableParsedPatterns.filter(pattern => getGrammar(pattern).every(({
13853        blockName: name
13854      }) => options[isFiltered] !== false ? canInsertBlockType(state, name, rootClientId) : isBlockVisibleInTheInserter(state, name, rootClientId)));
13855      return patternsAllowed;
13856    }, getAllowedPatternsDependants(select));
13857  });
13858  
13859  /**
13860   * Returns the list of patterns based on their declared `blockTypes`
13861   * and a block's name.
13862   * Patterns can use `blockTypes` to integrate in work flows like
13863   * suggesting appropriate patterns in a Placeholder state(during insertion)
13864   * or blocks transformations.
13865   *
13866   * @param {Object}          state        Editor state.
13867   * @param {string|string[]} blockNames   Block's name or array of block names to find matching patterns.
13868   * @param {?string}         rootClientId Optional target root client ID.
13869   *
13870   * @return {Array} The list of matched block patterns based on declared `blockTypes` and block name.
13871   */
13872  const getPatternsByBlockTypes = (0,external_wp_data_namespaceObject.createRegistrySelector)(select => (0,external_wp_data_namespaceObject.createSelector)((state, blockNames, rootClientId = null) => {
13873    if (!blockNames) {
13874      return selectors_EMPTY_ARRAY;
13875    }
13876    const patterns = select(STORE_NAME).__experimentalGetAllowedPatterns(rootClientId);
13877    const normalizedBlockNames = Array.isArray(blockNames) ? blockNames : [blockNames];
13878    const filteredPatterns = patterns.filter(pattern => pattern?.blockTypes?.some?.(blockName => normalizedBlockNames.includes(blockName)));
13879    if (filteredPatterns.length === 0) {
13880      return selectors_EMPTY_ARRAY;
13881    }
13882    return filteredPatterns;
13883  }, (state, blockNames, rootClientId) => getAllowedPatternsDependants(select)(state, rootClientId)));
13884  const __experimentalGetPatternsByBlockTypes = (0,external_wp_data_namespaceObject.createRegistrySelector)(select => {
13885    external_wp_deprecated_default()('wp.data.select( "core/block-editor" ).__experimentalGetPatternsByBlockTypes', {
13886      alternative: 'wp.data.select( "core/block-editor" ).getPatternsByBlockTypes',
13887      since: '6.2',
13888      version: '6.4'
13889    });
13890    return select(STORE_NAME).getPatternsByBlockTypes;
13891  });
13892  
13893  /**
13894   * Determines the items that appear in the available pattern transforms list.
13895   *
13896   * For now we only handle blocks without InnerBlocks and take into account
13897   * the `role` property of blocks' attributes for the transformation.
13898   *
13899   * We return the first set of possible eligible block patterns,
13900   * by checking the `blockTypes` property. We still have to recurse through
13901   * block pattern's blocks and try to find matches from the selected blocks.
13902   * Now this happens in the consumer to avoid heavy operations in the selector.
13903   *
13904   * @param {Object}   state        Editor state.
13905   * @param {Object[]} blocks       The selected blocks.
13906   * @param {?string}  rootClientId Optional root client ID of block list.
13907   *
13908   * @return {WPBlockPattern[]} Items that are eligible for a pattern transformation.
13909   */
13910  const __experimentalGetPatternTransformItems = (0,external_wp_data_namespaceObject.createRegistrySelector)(select => (0,external_wp_data_namespaceObject.createSelector)((state, blocks, rootClientId = null) => {
13911    if (!blocks) {
13912      return selectors_EMPTY_ARRAY;
13913    }
13914    /**
13915     * For now we only handle blocks without InnerBlocks and take into account
13916     * the `role` property of blocks' attributes for the transformation.
13917     * Note that the blocks have been retrieved through `getBlock`, which doesn't
13918     * return the inner blocks of an inner block controller, so we still need
13919     * to check for this case too.
13920     */
13921    if (blocks.some(({
13922      clientId,
13923      innerBlocks
13924    }) => innerBlocks.length || areInnerBlocksControlled(state, clientId))) {
13925      return selectors_EMPTY_ARRAY;
13926    }
13927  
13928    // Create a Set of the selected block names that is used in patterns filtering.
13929    const selectedBlockNames = Array.from(new Set(blocks.map(({
13930      name
13931    }) => name)));
13932    /**
13933     * Here we will return first set of possible eligible block patterns,
13934     * by checking the `blockTypes` property. We still have to recurse through
13935     * block pattern's blocks and try to find matches from the selected blocks.
13936     * Now this happens in the consumer to avoid heavy operations in the selector.
13937     */
13938    return select(STORE_NAME).getPatternsByBlockTypes(selectedBlockNames, rootClientId);
13939  }, (state, blocks, rootClientId) => getAllowedPatternsDependants(select)(state, rootClientId)));
13940  
13941  /**
13942   * Returns the Block List settings of a block, if any exist.
13943   *
13944   * @param {Object}  state    Editor state.
13945   * @param {?string} clientId Block client ID.
13946   *
13947   * @return {?Object} Block settings of the block if set.
13948   */
13949  function getBlockListSettings(state, clientId) {
13950    return state.blockListSettings[clientId];
13951  }
13952  
13953  /**
13954   * Returns the editor settings.
13955   *
13956   * @param {Object} state Editor state.
13957   *
13958   * @return {Object} The editor settings object.
13959   */
13960  function getSettings(state) {
13961    return state.settings;
13962  }
13963  
13964  /**
13965   * Returns true if the most recent block change is be considered persistent, or
13966   * false otherwise. A persistent change is one committed by BlockEditorProvider
13967   * via its `onChange` callback, in addition to `onInput`.
13968   *
13969   * @param {Object} state Block editor state.
13970   *
13971   * @return {boolean} Whether the most recent block change was persistent.
13972   */
13973  function isLastBlockChangePersistent(state) {
13974    return state.blocks.isPersistentChange;
13975  }
13976  
13977  /**
13978   * Returns the block list settings for an array of blocks, if any exist.
13979   *
13980   * @param {Object} state     Editor state.
13981   * @param {Array}  clientIds Block client IDs.
13982   *
13983   * @return {Object} An object where the keys are client ids and the values are
13984   *                  a block list setting object.
13985   */
13986  const __experimentalGetBlockListSettingsForBlocks = (0,external_wp_data_namespaceObject.createSelector)((state, clientIds = []) => {
13987    return clientIds.reduce((blockListSettingsForBlocks, clientId) => {
13988      if (!state.blockListSettings[clientId]) {
13989        return blockListSettingsForBlocks;
13990      }
13991      return {
13992        ...blockListSettingsForBlocks,
13993        [clientId]: state.blockListSettings[clientId]
13994      };
13995    }, {});
13996  }, state => [state.blockListSettings]);
13997  
13998  /**
13999   * Returns the title of a given reusable block
14000   *
14001   * @param {Object}        state Global application state.
14002   * @param {number|string} ref   The shared block's ID.
14003   *
14004   * @return {string} The reusable block saved title.
14005   */
14006  const __experimentalGetReusableBlockTitle = (0,external_wp_data_namespaceObject.createRegistrySelector)(select => (0,external_wp_data_namespaceObject.createSelector)((state, ref) => {
14007    external_wp_deprecated_default()("wp.data.select( 'core/block-editor' ).__experimentalGetReusableBlockTitle", {
14008      since: '6.6',
14009      version: '6.8'
14010    });
14011    const reusableBlock = unlock(select(STORE_NAME)).getReusableBlocks().find(block => block.id === ref);
14012    if (!reusableBlock) {
14013      return null;
14014    }
14015    return reusableBlock.title?.raw;
14016  }, () => [unlock(select(STORE_NAME)).getReusableBlocks()]));
14017  
14018  /**
14019   * Returns true if the most recent block change is be considered ignored, or
14020   * false otherwise. An ignored change is one not to be committed by
14021   * BlockEditorProvider, neither via `onChange` nor `onInput`.
14022   *
14023   * @param {Object} state Block editor state.
14024   *
14025   * @return {boolean} Whether the most recent block change was ignored.
14026   */
14027  function __unstableIsLastBlockChangeIgnored(state) {
14028    // TODO: Removal Plan: Changes incurred by RECEIVE_BLOCKS should not be
14029    // ignored if in-fact they result in a change in blocks state. The current
14030    // need to ignore changes not a result of user interaction should be
14031    // accounted for in the refactoring of reusable blocks as occurring within
14032    // their own separate block editor / state (#7119).
14033    return state.blocks.isIgnoredChange;
14034  }
14035  
14036  /**
14037   * Returns the block attributes changed as a result of the last dispatched
14038   * action.
14039   *
14040   * @param {Object} state Block editor state.
14041   *
14042   * @return {Object<string,Object>} Subsets of block attributes changed, keyed
14043   *                                 by block client ID.
14044   */
14045  function __experimentalGetLastBlockAttributeChanges(state) {
14046    return state.lastBlockAttributesChange;
14047  }
14048  
14049  /**
14050   * Returns whether the navigation mode is enabled.
14051   *
14052   * @param {Object} state Editor state.
14053   *
14054   * @return {boolean} Is navigation mode enabled.
14055   */
14056  function isNavigationMode(state) {
14057    return __unstableGetEditorMode(state) === 'navigation';
14058  }
14059  
14060  /**
14061   * Returns the current editor mode.
14062   *
14063   * @param {Object} state Editor state.
14064   *
14065   * @return {string} the editor mode.
14066   */
14067  const __unstableGetEditorMode = (0,external_wp_data_namespaceObject.createRegistrySelector)(select => state => {
14068    var _state$settings$edito;
14069    if (!window?.__experimentalEditorWriteMode) {
14070      return 'edit';
14071    }
14072    return (_state$settings$edito = state.settings.editorTool) !== null && _state$settings$edito !== void 0 ? _state$settings$edito : select(external_wp_preferences_namespaceObject.store).get('core', 'editorTool');
14073  });
14074  
14075  /**
14076   * Returns whether block moving mode is enabled.
14077   *
14078   * @deprecated
14079   */
14080  function hasBlockMovingClientId() {
14081    external_wp_deprecated_default()('wp.data.select( "core/block-editor" ).hasBlockMovingClientId', {
14082      since: '6.7',
14083      hint: 'Block moving mode feature has been removed'
14084    });
14085    return false;
14086  }
14087  
14088  /**
14089   * Returns true if the last change was an automatic change, false otherwise.
14090   *
14091   * @param {Object} state Global application state.
14092   *
14093   * @return {boolean} Whether the last change was automatic.
14094   */
14095  function didAutomaticChange(state) {
14096    return !!state.automaticChangeStatus;
14097  }
14098  
14099  /**
14100   * Returns true if the current highlighted block matches the block clientId.
14101   *
14102   * @param {Object} state    Global application state.
14103   * @param {string} clientId The block to check.
14104   *
14105   * @return {boolean} Whether the block is currently highlighted.
14106   */
14107  function isBlockHighlighted(state, clientId) {
14108    return state.highlightedBlock === clientId;
14109  }
14110  
14111  /**
14112   * Checks if a given block has controlled inner blocks.
14113   *
14114   * @param {Object} state    Global application state.
14115   * @param {string} clientId The block to check.
14116   *
14117   * @return {boolean} True if the block has controlled inner blocks.
14118   */
14119  function areInnerBlocksControlled(state, clientId) {
14120    return !!state.blocks.controlledInnerBlocks[clientId];
14121  }
14122  
14123  /**
14124   * Returns the clientId for the first 'active' block of a given array of block names.
14125   * A block is 'active' if it (or a child) is the selected block.
14126   * Returns the first match moving up the DOM from the selected block.
14127   *
14128   * @param {Object}   state            Global application state.
14129   * @param {string[]} validBlocksNames The names of block types to check for.
14130   *
14131   * @return {string} The matching block's clientId.
14132   */
14133  const __experimentalGetActiveBlockIdByBlockNames = (0,external_wp_data_namespaceObject.createSelector)((state, validBlockNames) => {
14134    if (!validBlockNames.length) {
14135      return null;
14136    }
14137    // Check if selected block is a valid entity area.
14138    const selectedBlockClientId = getSelectedBlockClientId(state);
14139    if (validBlockNames.includes(getBlockName(state, selectedBlockClientId))) {
14140      return selectedBlockClientId;
14141    }
14142    // Check if first selected block is a child of a valid entity area.
14143    const multiSelectedBlockClientIds = getMultiSelectedBlockClientIds(state);
14144    const entityAreaParents = getBlockParentsByBlockName(state, selectedBlockClientId || multiSelectedBlockClientIds[0], validBlockNames);
14145    if (entityAreaParents) {
14146      // Last parent closest/most interior.
14147      return entityAreaParents[entityAreaParents.length - 1];
14148    }
14149    return null;
14150  }, (state, validBlockNames) => [state.selection.selectionStart.clientId, state.selection.selectionEnd.clientId, validBlockNames]);
14151  
14152  /**
14153   * Tells if the block with the passed clientId was just inserted.
14154   *
14155   * @param {Object}  state    Global application state.
14156   * @param {Object}  clientId Client Id of the block.
14157   * @param {?string} source   Optional insertion source of the block.
14158   * @return {boolean} True if the block matches the last block inserted from the specified source.
14159   */
14160  function wasBlockJustInserted(state, clientId, source) {
14161    const {
14162      lastBlockInserted
14163    } = state;
14164    return lastBlockInserted.clientIds?.includes(clientId) && lastBlockInserted.source === source;
14165  }
14166  
14167  /**
14168   * Tells if the block is visible on the canvas or not.
14169   *
14170   * @param {Object} state    Global application state.
14171   * @param {Object} clientId Client Id of the block.
14172   * @return {boolean} True if the block is visible.
14173   */
14174  function isBlockVisible(state, clientId) {
14175    var _state$blockVisibilit;
14176    return (_state$blockVisibilit = state.blockVisibility?.[clientId]) !== null && _state$blockVisibilit !== void 0 ? _state$blockVisibilit : true;
14177  }
14178  
14179  /**
14180   * Returns the currently hovered block.
14181   *
14182   * @param {Object} state Global application state.
14183   * @return {Object} Client Id of the hovered block.
14184   */
14185  function getHoveredBlockClientId(state) {
14186    return state.hoveredBlockClientId;
14187  }
14188  
14189  /**
14190   * Returns the list of all hidden blocks.
14191   *
14192   * @param {Object} state Global application state.
14193   * @return {[string]} List of hidden blocks.
14194   */
14195  const __unstableGetVisibleBlocks = (0,external_wp_data_namespaceObject.createSelector)(state => {
14196    const visibleBlocks = new Set(Object.keys(state.blockVisibility).filter(key => state.blockVisibility[key]));
14197    if (visibleBlocks.size === 0) {
14198      return EMPTY_SET;
14199    }
14200    return visibleBlocks;
14201  }, state => [state.blockVisibility]);
14202  function __unstableHasActiveBlockOverlayActive(state, clientId) {
14203    // Prevent overlay on blocks with a non-default editing mode. If the mode is
14204    // 'disabled' then the overlay is redundant since the block can't be
14205    // selected. If the mode is 'contentOnly' then the overlay is redundant
14206    // since there will be no controls to interact with once selected.
14207    if (getBlockEditingMode(state, clientId) !== 'default') {
14208      return false;
14209    }
14210  
14211    // If the block editing is locked, the block overlay is always active.
14212    if (!canEditBlock(state, clientId)) {
14213      return true;
14214    }
14215  
14216    // In zoom-out mode, the block overlay is always active for section level blocks.
14217    if (isZoomOut(state)) {
14218      const sectionRootClientId = getSectionRootClientId(state);
14219      if (sectionRootClientId) {
14220        const sectionClientIds = getBlockOrder(state, sectionRootClientId);
14221        if (sectionClientIds?.includes(clientId)) {
14222          return true;
14223        }
14224      } else if (clientId && !getBlockRootClientId(state, clientId)) {
14225        return true;
14226      }
14227    }
14228  
14229    // In navigation mode, the block overlay is active when the block is not
14230    // selected (and doesn't contain a selected child). The same behavior is
14231    // also enabled in all modes for blocks that have controlled children
14232    // (reusable block, template part, navigation), unless explicitly disabled
14233    // with `supports.__experimentalDisableBlockOverlay`.
14234    const blockSupportDisable = (0,external_wp_blocks_namespaceObject.hasBlockSupport)(getBlockName(state, clientId), '__experimentalDisableBlockOverlay', false);
14235    const shouldEnableIfUnselected = blockSupportDisable ? false : areInnerBlocksControlled(state, clientId);
14236    return shouldEnableIfUnselected && !isBlockSelected(state, clientId) && !hasSelectedInnerBlock(state, clientId, true);
14237  }
14238  function __unstableIsWithinBlockOverlay(state, clientId) {
14239    let parent = state.blocks.parents.get(clientId);
14240    while (!!parent) {
14241      if (__unstableHasActiveBlockOverlayActive(state, parent)) {
14242        return true;
14243      }
14244      parent = state.blocks.parents.get(parent);
14245    }
14246    return false;
14247  }
14248  
14249  /**
14250   * @typedef {import('../components/block-editing-mode').BlockEditingMode} BlockEditingMode
14251   */
14252  
14253  /**
14254   * Returns the block editing mode for a given block.
14255   *
14256   * The mode can be one of three options:
14257   *
14258   * - `'disabled'`: Prevents editing the block entirely, i.e. it cannot be
14259   *   selected.
14260   * - `'contentOnly'`: Hides all non-content UI, e.g. auxiliary controls in the
14261   *   toolbar, the block movers, block settings.
14262   * - `'default'`: Allows editing the block as normal.
14263   *
14264   * Blocks can set a mode using the `useBlockEditingMode` hook.
14265   *
14266   * The mode is inherited by all of the block's inner blocks, unless they have
14267   * their own mode.
14268   *
14269   * A template lock can also set a mode. If the template lock is `'contentOnly'`,
14270   * the block's mode is overridden to `'contentOnly'` if the block has a content
14271   * role attribute, or `'disabled'` otherwise.
14272   *
14273   * @see useBlockEditingMode
14274   *
14275   * @param {Object} state    Global application state.
14276   * @param {string} clientId The block client ID, or `''` for the root container.
14277   *
14278   * @return {BlockEditingMode} The block editing mode. One of `'disabled'`,
14279   *                            `'contentOnly'`, or `'default'`.
14280   */
14281  const getBlockEditingMode = (0,external_wp_data_namespaceObject.createRegistrySelector)(select => (state, clientId = '') => {
14282    // Some selectors that call this provide `null` as the default
14283    // rootClientId, but the default rootClientId is actually `''`.
14284    if (clientId === null) {
14285      clientId = '';
14286    }
14287    const isNavMode = isNavigationMode(state);
14288  
14289    // If the editor is currently not in navigation mode, check if the clientId
14290    // has an editing mode set in the regular derived map.
14291    // There may be an editing mode set here for synced patterns or in zoomed out
14292    // mode.
14293    if (!isNavMode && state.derivedBlockEditingModes?.has(clientId)) {
14294      return state.derivedBlockEditingModes.get(clientId);
14295    }
14296  
14297    // If the editor *is* in navigation mode, the block editing mode states
14298    // are stored in the derivedNavModeBlockEditingModes map.
14299    if (isNavMode && state.derivedNavModeBlockEditingModes?.has(clientId)) {
14300      return state.derivedNavModeBlockEditingModes.get(clientId);
14301    }
14302  
14303    // In normal mode, consider that an explicitly set editing mode takes over.
14304    const blockEditingMode = state.blockEditingModes.get(clientId);
14305    if (blockEditingMode) {
14306      return blockEditingMode;
14307    }
14308  
14309    // In normal mode, top level is default mode.
14310    if (clientId === '') {
14311      return 'default';
14312    }
14313    const rootClientId = getBlockRootClientId(state, clientId);
14314    const templateLock = getTemplateLock(state, rootClientId);
14315    // If the parent of the block is contentOnly locked, check whether it's a content block.
14316    if (templateLock === 'contentOnly') {
14317      const name = getBlockName(state, clientId);
14318      const {
14319        hasContentRoleAttribute
14320      } = unlock(select(external_wp_blocks_namespaceObject.store));
14321      const isContent = hasContentRoleAttribute(name);
14322      return isContent ? 'contentOnly' : 'disabled';
14323    }
14324    return 'default';
14325  });
14326  
14327  /**
14328   * Indicates if a block is ungroupable.
14329   * A block is ungroupable if it is a single grouping block with inner blocks.
14330   * If a block has an `ungroup` transform, it is also ungroupable, without the
14331   * requirement of being the default grouping block.
14332   * Additionally a block can only be ungrouped if it has inner blocks and can
14333   * be removed.
14334   *
14335   * @param {Object} state    Global application state.
14336   * @param {string} clientId Client Id of the block. If not passed the selected block's client id will be used.
14337   * @return {boolean} True if the block is ungroupable.
14338   */
14339  const isUngroupable = (0,external_wp_data_namespaceObject.createRegistrySelector)(select => (state, clientId = '') => {
14340    const _clientId = clientId || getSelectedBlockClientId(state);
14341    if (!_clientId) {
14342      return false;
14343    }
14344    const {
14345      getGroupingBlockName
14346    } = select(external_wp_blocks_namespaceObject.store);
14347    const block = getBlock(state, _clientId);
14348    const groupingBlockName = getGroupingBlockName();
14349    const _isUngroupable = block && (block.name === groupingBlockName || (0,external_wp_blocks_namespaceObject.getBlockType)(block.name)?.transforms?.ungroup) && !!block.innerBlocks.length;
14350    return _isUngroupable && canRemoveBlock(state, _clientId);
14351  });
14352  
14353  /**
14354   * Indicates if the provided blocks(by client ids) are groupable.
14355   * We need to have at least one block, have a grouping block name set and
14356   * be able to remove these blocks.
14357   *
14358   * @param {Object}   state     Global application state.
14359   * @param {string[]} clientIds Block client ids. If not passed the selected blocks client ids will be used.
14360   * @return {boolean} True if the blocks are groupable.
14361   */
14362  const isGroupable = (0,external_wp_data_namespaceObject.createRegistrySelector)(select => (state, clientIds = selectors_EMPTY_ARRAY) => {
14363    const {
14364      getGroupingBlockName
14365    } = select(external_wp_blocks_namespaceObject.store);
14366    const groupingBlockName = getGroupingBlockName();
14367    const _clientIds = clientIds?.length ? clientIds : getSelectedBlockClientIds(state);
14368    const rootClientId = _clientIds?.length ? getBlockRootClientId(state, _clientIds[0]) : undefined;
14369    const groupingBlockAvailable = canInsertBlockType(state, groupingBlockName, rootClientId);
14370    const _isGroupable = groupingBlockAvailable && _clientIds.length;
14371    return _isGroupable && canRemoveBlocks(state, _clientIds);
14372  });
14373  
14374  /**
14375   * DO-NOT-USE in production.
14376   * This selector is created for internal/experimental only usage and may be
14377   * removed anytime without any warning, causing breakage on any plugin or theme invoking it.
14378   *
14379   * @deprecated
14380   *
14381   * @param {Object} state    Global application state.
14382   * @param {Object} clientId Client Id of the block.
14383   *
14384   * @return {?string} Client ID of the ancestor block that is content locking the block.
14385   */
14386  const __unstableGetContentLockingParent = (state, clientId) => {
14387    external_wp_deprecated_default()("wp.data.select( 'core/block-editor' ).__unstableGetContentLockingParent", {
14388      since: '6.1',
14389      version: '6.7'
14390    });
14391    return getContentLockingParent(state, clientId);
14392  };
14393  
14394  /**
14395   * DO-NOT-USE in production.
14396   * This selector is created for internal/experimental only usage and may be
14397   * removed anytime without any warning, causing breakage on any plugin or theme invoking it.
14398   *
14399   * @deprecated
14400   *
14401   * @param {Object} state Global application state.
14402   */
14403  function __unstableGetTemporarilyEditingAsBlocks(state) {
14404    external_wp_deprecated_default()("wp.data.select( 'core/block-editor' ).__unstableGetTemporarilyEditingAsBlocks", {
14405      since: '6.1',
14406      version: '6.7'
14407    });
14408    return getTemporarilyEditingAsBlocks(state);
14409  }
14410  
14411  /**
14412   * DO-NOT-USE in production.
14413   * This selector is created for internal/experimental only usage and may be
14414   * removed anytime without any warning, causing breakage on any plugin or theme invoking it.
14415   *
14416   * @deprecated
14417   *
14418   * @param {Object} state Global application state.
14419   */
14420  function __unstableGetTemporarilyEditingFocusModeToRevert(state) {
14421    external_wp_deprecated_default()("wp.data.select( 'core/block-editor' ).__unstableGetTemporarilyEditingFocusModeToRevert", {
14422      since: '6.5',
14423      version: '6.7'
14424    });
14425    return getTemporarilyEditingFocusModeToRevert(state);
14426  }
14427  
14428  ;// external ["wp","a11y"]
14429  const external_wp_a11y_namespaceObject = window["wp"]["a11y"];
14430  ;// ./node_modules/@wordpress/block-editor/build-module/store/private-actions.js
14431  /**
14432   * WordPress dependencies
14433   */
14434  
14435  
14436  
14437  
14438  
14439  /**
14440   * Internal dependencies
14441   */
14442  
14443  
14444  const castArray = maybeArray => Array.isArray(maybeArray) ? maybeArray : [maybeArray];
14445  
14446  /**
14447   * A list of private/experimental block editor settings that
14448   * should not become a part of the WordPress public API.
14449   * BlockEditorProvider will remove these settings from the
14450   * settings object it receives.
14451   *
14452   * @see https://github.com/WordPress/gutenberg/pull/46131
14453   */
14454  const privateSettings = ['inserterMediaCategories', 'blockInspectorAnimation', 'mediaSideload'];
14455  
14456  /**
14457   * Action that updates the block editor settings and
14458   * conditionally preserves the experimental ones.
14459   *
14460   * @param {Object}  settings                          Updated settings
14461   * @param {Object}  options                           Options object.
14462   * @param {boolean} options.stripExperimentalSettings Whether to strip experimental settings.
14463   * @param {boolean} options.reset                     Whether to reset the settings.
14464   * @return {Object} Action object
14465   */
14466  function __experimentalUpdateSettings(settings, {
14467    stripExperimentalSettings = false,
14468    reset = false
14469  } = {}) {
14470    let incomingSettings = settings;
14471    if (Object.hasOwn(incomingSettings, '__unstableIsPreviewMode')) {
14472      external_wp_deprecated_default()("__unstableIsPreviewMode argument in wp.data.dispatch('core/block-editor').updateSettings", {
14473        since: '6.8',
14474        alternative: 'isPreviewMode'
14475      });
14476      incomingSettings = {
14477        ...incomingSettings
14478      };
14479      incomingSettings.isPreviewMode = incomingSettings.__unstableIsPreviewMode;
14480      delete incomingSettings.__unstableIsPreviewMode;
14481    }
14482    let cleanSettings = incomingSettings;
14483  
14484    // There are no plugins in the mobile apps, so there is no
14485    // need to strip the experimental settings:
14486    if (stripExperimentalSettings && external_wp_element_namespaceObject.Platform.OS === 'web') {
14487      cleanSettings = {};
14488      for (const key in incomingSettings) {
14489        if (!privateSettings.includes(key)) {
14490          cleanSettings[key] = incomingSettings[key];
14491        }
14492      }
14493    }
14494    return {
14495      type: 'UPDATE_SETTINGS',
14496      settings: cleanSettings,
14497      reset
14498    };
14499  }
14500  
14501  /**
14502   * Hides the block interface (eg. toolbar, outline, etc.)
14503   *
14504   * @return {Object} Action object.
14505   */
14506  function hideBlockInterface() {
14507    return {
14508      type: 'HIDE_BLOCK_INTERFACE'
14509    };
14510  }
14511  
14512  /**
14513   * Shows the block interface (eg. toolbar, outline, etc.)
14514   *
14515   * @return {Object} Action object.
14516   */
14517  function showBlockInterface() {
14518    return {
14519      type: 'SHOW_BLOCK_INTERFACE'
14520    };
14521  }
14522  
14523  /**
14524   * Yields action objects used in signalling that the blocks corresponding to
14525   * the set of specified client IDs are to be removed.
14526   *
14527   * Compared to `removeBlocks`, this private interface exposes an additional
14528   * parameter; see `forceRemove`.
14529   *
14530   * @param {string|string[]} clientIds      Client IDs of blocks to remove.
14531   * @param {boolean}         selectPrevious True if the previous block
14532   *                                         or the immediate parent
14533   *                                         (if no previous block exists)
14534   *                                         should be selected
14535   *                                         when a block is removed.
14536   * @param {boolean}         forceRemove    Whether to force the operation,
14537   *                                         bypassing any checks for certain
14538   *                                         block types.
14539   */
14540  const privateRemoveBlocks = (clientIds, selectPrevious = true, forceRemove = false) => ({
14541    select,
14542    dispatch,
14543    registry
14544  }) => {
14545    if (!clientIds || !clientIds.length) {
14546      return;
14547    }
14548    clientIds = castArray(clientIds);
14549    const canRemoveBlocks = select.canRemoveBlocks(clientIds);
14550    if (!canRemoveBlocks) {
14551      return;
14552    }
14553  
14554    // In certain editing contexts, we'd like to prevent accidental removal
14555    // of important blocks. For example, in the site editor, the Query Loop
14556    // block is deemed important. In such cases, we'll ask the user for
14557    // confirmation that they intended to remove such block(s). However,
14558    // the editor instance is responsible for presenting those confirmation
14559    // prompts to the user. Any instance opting into removal prompts must
14560    // register using `setBlockRemovalRules()`.
14561    //
14562    // @see https://github.com/WordPress/gutenberg/pull/51145
14563    const rules = !forceRemove && select.getBlockRemovalRules();
14564    if (rules) {
14565      function flattenBlocks(blocks) {
14566        const result = [];
14567        const stack = [...blocks];
14568        while (stack.length) {
14569          const {
14570            innerBlocks,
14571            ...block
14572          } = stack.shift();
14573          stack.push(...innerBlocks);
14574          result.push(block);
14575        }
14576        return result;
14577      }
14578      const blockList = clientIds.map(select.getBlock);
14579      const flattenedBlocks = flattenBlocks(blockList);
14580  
14581      // Find the first message and use it.
14582      let message;
14583      for (const rule of rules) {
14584        message = rule.callback(flattenedBlocks);
14585        if (message) {
14586          dispatch(displayBlockRemovalPrompt(clientIds, selectPrevious, message));
14587          return;
14588        }
14589      }
14590    }
14591    if (selectPrevious) {
14592      dispatch.selectPreviousBlock(clientIds[0], selectPrevious);
14593    }
14594  
14595    // We're batching these two actions because an extra `undo/redo` step can
14596    // be created, based on whether we insert a default block or not.
14597    registry.batch(() => {
14598      dispatch({
14599        type: 'REMOVE_BLOCKS',
14600        clientIds
14601      });
14602      // To avoid a focus loss when removing the last block, assure there is
14603      // always a default block if the last of the blocks have been removed.
14604      dispatch(ensureDefaultBlock());
14605    });
14606  };
14607  
14608  /**
14609   * Action which will insert a default block insert action if there
14610   * are no other blocks at the root of the editor. This action should be used
14611   * in actions which may result in no blocks remaining in the editor (removal,
14612   * replacement, etc).
14613   */
14614  const ensureDefaultBlock = () => ({
14615    select,
14616    dispatch
14617  }) => {
14618    // To avoid a focus loss when removing the last block, assure there is
14619    // always a default block if the last of the blocks have been removed.
14620    const count = select.getBlockCount();
14621    if (count > 0) {
14622      return;
14623    }
14624  
14625    // If there's an custom appender, don't insert default block.
14626    // We have to remember to manually move the focus elsewhere to
14627    // prevent it from being lost though.
14628    const {
14629      __unstableHasCustomAppender
14630    } = select.getSettings();
14631    if (__unstableHasCustomAppender) {
14632      return;
14633    }
14634    dispatch.insertDefaultBlock();
14635  };
14636  
14637  /**
14638   * Returns an action object used in signalling that a block removal prompt must
14639   * be displayed.
14640   *
14641   * Contrast with `setBlockRemovalRules`.
14642   *
14643   * @param {string|string[]} clientIds      Client IDs of blocks to remove.
14644   * @param {boolean}         selectPrevious True if the previous block or the
14645   *                                         immediate parent (if no previous
14646   *                                         block exists) should be selected
14647   *                                         when a block is removed.
14648   * @param {string}          message        Message to display in the prompt.
14649   *
14650   * @return {Object} Action object.
14651   */
14652  function displayBlockRemovalPrompt(clientIds, selectPrevious, message) {
14653    return {
14654      type: 'DISPLAY_BLOCK_REMOVAL_PROMPT',
14655      clientIds,
14656      selectPrevious,
14657      message
14658    };
14659  }
14660  
14661  /**
14662   * Returns an action object used in signalling that a block removal prompt must
14663   * be cleared, either be cause the user has confirmed or canceled the request
14664   * for removal.
14665   *
14666   * @return {Object} Action object.
14667   */
14668  function clearBlockRemovalPrompt() {
14669    return {
14670      type: 'CLEAR_BLOCK_REMOVAL_PROMPT'
14671    };
14672  }
14673  
14674  /**
14675   * Returns an action object used to set up any rules that a block editor may
14676   * provide in order to prevent a user from accidentally removing certain
14677   * blocks. These rules are then used to display a confirmation prompt to the
14678   * user. For instance, in the Site Editor, the Query Loop block is important
14679   * enough to warrant such confirmation.
14680   *
14681   * IMPORTANT: Registering rules implicitly signals to the `privateRemoveBlocks`
14682   * action that the editor will be responsible for displaying block removal
14683   * prompts and confirming deletions. This action is meant to be used by
14684   * component `BlockRemovalWarningModal` only.
14685   *
14686   * The data is a record whose keys are block types (e.g. 'core/query') and
14687   * whose values are the explanation to be shown to users (e.g. 'Query Loop
14688   * displays a list of posts or pages.').
14689   *
14690   * Contrast with `displayBlockRemovalPrompt`.
14691   *
14692   * @param {Record<string,string>|false} rules Block removal rules.
14693   * @return {Object} Action object.
14694   */
14695  function setBlockRemovalRules(rules = false) {
14696    return {
14697      type: 'SET_BLOCK_REMOVAL_RULES',
14698      rules
14699    };
14700  }
14701  
14702  /**
14703   * Sets the client ID of the block settings menu that is currently open.
14704   *
14705   * @param {?string} clientId The block client ID.
14706   * @return {Object} Action object.
14707   */
14708  function setOpenedBlockSettingsMenu(clientId) {
14709    return {
14710      type: 'SET_OPENED_BLOCK_SETTINGS_MENU',
14711      clientId
14712    };
14713  }
14714  function setStyleOverride(id, style) {
14715    return {
14716      type: 'SET_STYLE_OVERRIDE',
14717      id,
14718      style
14719    };
14720  }
14721  function deleteStyleOverride(id) {
14722    return {
14723      type: 'DELETE_STYLE_OVERRIDE',
14724      id
14725    };
14726  }
14727  
14728  /**
14729   * Action that sets the element that had focus when focus leaves the editor canvas.
14730   *
14731   * @param {Object} lastFocus The last focused element.
14732   *
14733   *
14734   * @return {Object} Action object.
14735   */
14736  function setLastFocus(lastFocus = null) {
14737    return {
14738      type: 'LAST_FOCUS',
14739      lastFocus
14740    };
14741  }
14742  
14743  /**
14744   * Action that stops temporarily editing as blocks.
14745   *
14746   * @param {string} clientId The block's clientId.
14747   */
14748  function stopEditingAsBlocks(clientId) {
14749    return ({
14750      select,
14751      dispatch,
14752      registry
14753    }) => {
14754      const focusModeToRevert = unlock(registry.select(store)).getTemporarilyEditingFocusModeToRevert();
14755      dispatch.__unstableMarkNextChangeAsNotPersistent();
14756      dispatch.updateBlockAttributes(clientId, {
14757        templateLock: 'contentOnly'
14758      });
14759      dispatch.updateBlockListSettings(clientId, {
14760        ...select.getBlockListSettings(clientId),
14761        templateLock: 'contentOnly'
14762      });
14763      dispatch.updateSettings({
14764        focusMode: focusModeToRevert
14765      });
14766      dispatch.__unstableSetTemporarilyEditingAsBlocks();
14767    };
14768  }
14769  
14770  /**
14771   * Returns an action object used in signalling that the user has begun to drag.
14772   *
14773   * @return {Object} Action object.
14774   */
14775  function startDragging() {
14776    return {
14777      type: 'START_DRAGGING'
14778    };
14779  }
14780  
14781  /**
14782   * Returns an action object used in signalling that the user has stopped dragging.
14783   *
14784   * @return {Object} Action object.
14785   */
14786  function stopDragging() {
14787    return {
14788      type: 'STOP_DRAGGING'
14789    };
14790  }
14791  
14792  /**
14793   * @param {string|null} clientId The block's clientId, or `null` to clear.
14794   *
14795   * @return  {Object} Action object.
14796   */
14797  function expandBlock(clientId) {
14798    return {
14799      type: 'SET_BLOCK_EXPANDED_IN_LIST_VIEW',
14800      clientId
14801    };
14802  }
14803  
14804  /**
14805   * @param {Object} value
14806   * @param {string} value.rootClientId The root client ID to insert at.
14807   * @param {number} value.index        The index to insert at.
14808   *
14809   * @return {Object} Action object.
14810   */
14811  function setInsertionPoint(value) {
14812    return {
14813      type: 'SET_INSERTION_POINT',
14814      value
14815    };
14816  }
14817  
14818  /**
14819   * Temporarily modify/unlock the content-only block for editions.
14820   *
14821   * @param {string} clientId The client id of the block.
14822   */
14823  const modifyContentLockBlock = clientId => ({
14824    select,
14825    dispatch
14826  }) => {
14827    dispatch.selectBlock(clientId);
14828    dispatch.__unstableMarkNextChangeAsNotPersistent();
14829    dispatch.updateBlockAttributes(clientId, {
14830      templateLock: undefined
14831    });
14832    dispatch.updateBlockListSettings(clientId, {
14833      ...select.getBlockListSettings(clientId),
14834      templateLock: false
14835    });
14836    const focusModeToRevert = select.getSettings().focusMode;
14837    dispatch.updateSettings({
14838      focusMode: true
14839    });
14840    dispatch.__unstableSetTemporarilyEditingAsBlocks(clientId, focusModeToRevert);
14841  };
14842  
14843  /**
14844   * Sets the zoom level.
14845   *
14846   * @param {number} zoom the new zoom level
14847   * @return {Object} Action object.
14848   */
14849  const setZoomLevel = (zoom = 100) => ({
14850    select,
14851    dispatch
14852  }) => {
14853    // When switching to zoom-out mode, we need to select the parent section
14854    if (zoom !== 100) {
14855      const firstSelectedClientId = select.getBlockSelectionStart();
14856      const sectionRootClientId = select.getSectionRootClientId();
14857      if (firstSelectedClientId) {
14858        let sectionClientId;
14859        if (sectionRootClientId) {
14860          const sectionClientIds = select.getBlockOrder(sectionRootClientId);
14861  
14862          // If the selected block is a section block, use it.
14863          if (sectionClientIds?.includes(firstSelectedClientId)) {
14864            sectionClientId = firstSelectedClientId;
14865          } else {
14866            // If the selected block is not a section block, find
14867            // the parent section that contains the selected block.
14868            sectionClientId = select.getBlockParents(firstSelectedClientId).find(parent => sectionClientIds.includes(parent));
14869          }
14870        } else {
14871          sectionClientId = select.getBlockHierarchyRootClientId(firstSelectedClientId);
14872        }
14873        if (sectionClientId) {
14874          dispatch.selectBlock(sectionClientId);
14875        } else {
14876          dispatch.clearSelectedBlock();
14877        }
14878        (0,external_wp_a11y_namespaceObject.speak)((0,external_wp_i18n_namespaceObject.__)('You are currently in zoom-out mode.'));
14879      }
14880    }
14881    dispatch({
14882      type: 'SET_ZOOM_LEVEL',
14883      zoom
14884    });
14885  };
14886  
14887  /**
14888   * Resets the Zoom state.
14889   * @return {Object} Action object.
14890   */
14891  function resetZoomLevel() {
14892    return {
14893      type: 'RESET_ZOOM_LEVEL'
14894    };
14895  }
14896  
14897  ;// external ["wp","notices"]
14898  const external_wp_notices_namespaceObject = window["wp"]["notices"];
14899  ;// ./node_modules/@wordpress/block-editor/build-module/utils/selection.js
14900  /**
14901   * WordPress dependencies
14902   */
14903  
14904  
14905  /**
14906   * A robust way to retain selection position through various
14907   * transforms is to insert a special character at the position and
14908   * then recover it.
14909   */
14910  const START_OF_SELECTED_AREA = '\u0086';
14911  
14912  /**
14913   * Retrieve the block attribute that contains the selection position.
14914   *
14915   * @param {Object} blockAttributes Block attributes.
14916   * @return {string|void} The name of the block attribute that was previously selected.
14917   */
14918  function retrieveSelectedAttribute(blockAttributes) {
14919    if (!blockAttributes) {
14920      return;
14921    }
14922    return Object.keys(blockAttributes).find(name => {
14923      const value = blockAttributes[name];
14924      return (typeof value === 'string' || value instanceof external_wp_richText_namespaceObject.RichTextData) &&
14925      // To do: refactor this to use rich text's selection instead, so we
14926      // no longer have to use on this hack inserting a special character.
14927      value.toString().indexOf(START_OF_SELECTED_AREA) !== -1;
14928    });
14929  }
14930  function findRichTextAttributeKey(blockType) {
14931    for (const [key, value] of Object.entries(blockType.attributes)) {
14932      if (value.source === 'rich-text' || value.source === 'html') {
14933        return key;
14934      }
14935    }
14936  }
14937  
14938  ;// ./node_modules/@wordpress/block-editor/build-module/store/actions.js
14939  /* eslint no-console: [ 'error', { allow: [ 'error', 'warn' ] } ] */
14940  /**
14941   * WordPress dependencies
14942   */
14943  
14944  
14945  
14946  
14947  
14948  
14949  
14950  
14951  /**
14952   * Internal dependencies
14953   */
14954  
14955  
14956  
14957  /** @typedef {import('../components/use-on-block-drop/types').WPDropOperation} WPDropOperation */
14958  
14959  const actions_castArray = maybeArray => Array.isArray(maybeArray) ? maybeArray : [maybeArray];
14960  
14961  /**
14962   * Action that resets blocks state to the specified array of blocks, taking precedence
14963   * over any other content reflected as an edit in state.
14964   *
14965   * @param {Array} blocks Array of blocks.
14966   */
14967  const resetBlocks = blocks => ({
14968    dispatch
14969  }) => {
14970    dispatch({
14971      type: 'RESET_BLOCKS',
14972      blocks
14973    });
14974    dispatch(validateBlocksToTemplate(blocks));
14975  };
14976  
14977  /**
14978   * Block validity is a function of blocks state (at the point of a
14979   * reset) and the template setting. As a compromise to its placement
14980   * across distinct parts of state, it is implemented here as a side
14981   * effect of the block reset action.
14982   *
14983   * @param {Array} blocks Array of blocks.
14984   */
14985  const validateBlocksToTemplate = blocks => ({
14986    select,
14987    dispatch
14988  }) => {
14989    const template = select.getTemplate();
14990    const templateLock = select.getTemplateLock();
14991  
14992    // Unlocked templates are considered always valid because they act
14993    // as default values only.
14994    const isBlocksValidToTemplate = !template || templateLock !== 'all' || (0,external_wp_blocks_namespaceObject.doBlocksMatchTemplate)(blocks, template);
14995  
14996    // Update if validity has changed.
14997    const isValidTemplate = select.isValidTemplate();
14998    if (isBlocksValidToTemplate !== isValidTemplate) {
14999      dispatch.setTemplateValidity(isBlocksValidToTemplate);
15000      return isBlocksValidToTemplate;
15001    }
15002  };
15003  
15004  /**
15005   * A block selection object.
15006   *
15007   * @typedef {Object} WPBlockSelection
15008   *
15009   * @property {string} clientId     A block client ID.
15010   * @property {string} attributeKey A block attribute key.
15011   * @property {number} offset       An attribute value offset, based on the rich
15012   *                                 text value. See `wp.richText.create`.
15013   */
15014  
15015  /**
15016   * A selection object.
15017   *
15018   * @typedef {Object} WPSelection
15019   *
15020   * @property {WPBlockSelection} start The selection start.
15021   * @property {WPBlockSelection} end   The selection end.
15022   */
15023  
15024  /* eslint-disable jsdoc/valid-types */
15025  /**
15026   * Returns an action object used in signalling that selection state should be
15027   * reset to the specified selection.
15028   *
15029   * @param {WPBlockSelection} selectionStart  The selection start.
15030   * @param {WPBlockSelection} selectionEnd    The selection end.
15031   * @param {0|-1|null}        initialPosition Initial block position.
15032   *
15033   * @return {Object} Action object.
15034   */
15035  function resetSelection(selectionStart, selectionEnd, initialPosition) {
15036    /* eslint-enable jsdoc/valid-types */
15037    return {
15038      type: 'RESET_SELECTION',
15039      selectionStart,
15040      selectionEnd,
15041      initialPosition
15042    };
15043  }
15044  
15045  /**
15046   * Returns an action object used in signalling that blocks have been received.
15047   * Unlike resetBlocks, these should be appended to the existing known set, not
15048   * replacing.
15049   *
15050   * @deprecated
15051   *
15052   * @param {Object[]} blocks Array of block objects.
15053   *
15054   * @return {Object} Action object.
15055   */
15056  function receiveBlocks(blocks) {
15057    external_wp_deprecated_default()('wp.data.dispatch( "core/block-editor" ).receiveBlocks', {
15058      since: '5.9',
15059      alternative: 'resetBlocks or insertBlocks'
15060    });
15061    return {
15062      type: 'RECEIVE_BLOCKS',
15063      blocks
15064    };
15065  }
15066  
15067  /**
15068   * Action that updates attributes of multiple blocks with the specified client IDs.
15069   *
15070   * @param {string|string[]} clientIds     Block client IDs.
15071   * @param {Object}          attributes    Block attributes to be merged. Should be keyed by clientIds if
15072   *                                        uniqueByBlock is true.
15073   * @param {boolean}         uniqueByBlock true if each block in clientIds array has a unique set of attributes
15074   * @return {Object} Action object.
15075   */
15076  function updateBlockAttributes(clientIds, attributes, uniqueByBlock = false) {
15077    return {
15078      type: 'UPDATE_BLOCK_ATTRIBUTES',
15079      clientIds: actions_castArray(clientIds),
15080      attributes,
15081      uniqueByBlock
15082    };
15083  }
15084  
15085  /**
15086   * Action that updates the block with the specified client ID.
15087   *
15088   * @param {string} clientId Block client ID.
15089   * @param {Object} updates  Block attributes to be merged.
15090   *
15091   * @return {Object} Action object.
15092   */
15093  function updateBlock(clientId, updates) {
15094    return {
15095      type: 'UPDATE_BLOCK',
15096      clientId,
15097      updates
15098    };
15099  }
15100  
15101  /* eslint-disable jsdoc/valid-types */
15102  /**
15103   * Returns an action object used in signalling that the block with the
15104   * specified client ID has been selected, optionally accepting a position
15105   * value reflecting its selection directionality. An initialPosition of -1
15106   * reflects a reverse selection.
15107   *
15108   * @param {string}    clientId        Block client ID.
15109   * @param {0|-1|null} initialPosition Optional initial position. Pass as -1 to
15110   *                                    reflect reverse selection.
15111   *
15112   * @return {Object} Action object.
15113   */
15114  function selectBlock(clientId, initialPosition = 0) {
15115    /* eslint-enable jsdoc/valid-types */
15116    return {
15117      type: 'SELECT_BLOCK',
15118      initialPosition,
15119      clientId
15120    };
15121  }
15122  
15123  /**
15124   * Returns an action object used in signalling that the block with the
15125   * specified client ID has been hovered.
15126   *
15127   * @param {string} clientId Block client ID.
15128   *
15129   * @return {Object} Action object.
15130   */
15131  function hoverBlock(clientId) {
15132    return {
15133      type: 'HOVER_BLOCK',
15134      clientId
15135    };
15136  }
15137  
15138  /**
15139   * Yields action objects used in signalling that the block preceding the given
15140   * clientId (or optionally, its first parent from bottom to top)
15141   * should be selected.
15142   *
15143   * @param {string}  clientId         Block client ID.
15144   * @param {boolean} fallbackToParent If true, select the first parent if there is no previous block.
15145   */
15146  const selectPreviousBlock = (clientId, fallbackToParent = false) => ({
15147    select,
15148    dispatch
15149  }) => {
15150    const previousBlockClientId = select.getPreviousBlockClientId(clientId);
15151    if (previousBlockClientId) {
15152      dispatch.selectBlock(previousBlockClientId, -1);
15153    } else if (fallbackToParent) {
15154      const firstParentClientId = select.getBlockRootClientId(clientId);
15155      if (firstParentClientId) {
15156        dispatch.selectBlock(firstParentClientId, -1);
15157      }
15158    }
15159  };
15160  
15161  /**
15162   * Yields action objects used in signalling that the block following the given
15163   * clientId should be selected.
15164   *
15165   * @param {string} clientId Block client ID.
15166   */
15167  const selectNextBlock = clientId => ({
15168    select,
15169    dispatch
15170  }) => {
15171    const nextBlockClientId = select.getNextBlockClientId(clientId);
15172    if (nextBlockClientId) {
15173      dispatch.selectBlock(nextBlockClientId);
15174    }
15175  };
15176  
15177  /**
15178   * Action that starts block multi-selection.
15179   *
15180   * @return {Object} Action object.
15181   */
15182  function startMultiSelect() {
15183    return {
15184      type: 'START_MULTI_SELECT'
15185    };
15186  }
15187  
15188  /**
15189   * Action that stops block multi-selection.
15190   *
15191   * @return {Object} Action object.
15192   */
15193  function stopMultiSelect() {
15194    return {
15195      type: 'STOP_MULTI_SELECT'
15196    };
15197  }
15198  
15199  /**
15200   * Action that changes block multi-selection.
15201   *
15202   * @param {string}      start                         First block of the multi selection.
15203   * @param {string}      end                           Last block of the multiselection.
15204   * @param {number|null} __experimentalInitialPosition Optional initial position. Pass as null to skip focus within editor canvas.
15205   */
15206  const multiSelect = (start, end, __experimentalInitialPosition = 0) => ({
15207    select,
15208    dispatch
15209  }) => {
15210    const startBlockRootClientId = select.getBlockRootClientId(start);
15211    const endBlockRootClientId = select.getBlockRootClientId(end);
15212  
15213    // Only allow block multi-selections at the same level.
15214    if (startBlockRootClientId !== endBlockRootClientId) {
15215      return;
15216    }
15217    dispatch({
15218      type: 'MULTI_SELECT',
15219      start,
15220      end,
15221      initialPosition: __experimentalInitialPosition
15222    });
15223    const blockCount = select.getSelectedBlockCount();
15224    (0,external_wp_a11y_namespaceObject.speak)((0,external_wp_i18n_namespaceObject.sprintf)(/* translators: %s: number of selected blocks */
15225    (0,external_wp_i18n_namespaceObject._n)('%s block selected.', '%s blocks selected.', blockCount), blockCount), 'assertive');
15226  };
15227  
15228  /**
15229   * Action that clears the block selection.
15230   *
15231   * @return {Object} Action object.
15232   */
15233  function clearSelectedBlock() {
15234    return {
15235      type: 'CLEAR_SELECTED_BLOCK'
15236    };
15237  }
15238  
15239  /**
15240   * Action that enables or disables block selection.
15241   *
15242   * @param {boolean} [isSelectionEnabled=true] Whether block selection should
15243   *                                            be enabled.
15244   *
15245   * @return {Object} Action object.
15246   */
15247  function toggleSelection(isSelectionEnabled = true) {
15248    return {
15249      type: 'TOGGLE_SELECTION',
15250      isSelectionEnabled
15251    };
15252  }
15253  
15254  /* eslint-disable jsdoc/valid-types */
15255  /**
15256   * Action that replaces given blocks with one or more replacement blocks.
15257   *
15258   * @param {(string|string[])} clientIds       Block client ID(s) to replace.
15259   * @param {(Object|Object[])} blocks          Replacement block(s).
15260   * @param {number}            indexToSelect   Index of replacement block to select.
15261   * @param {0|-1|null}         initialPosition Index of caret after in the selected block after the operation.
15262   * @param {?Object}           meta            Optional Meta values to be passed to the action object.
15263   *
15264   * @return {Object} Action object.
15265   */
15266  const replaceBlocks = (clientIds, blocks, indexToSelect, initialPosition = 0, meta) => ({
15267    select,
15268    dispatch,
15269    registry
15270  }) => {
15271    /* eslint-enable jsdoc/valid-types */
15272    clientIds = actions_castArray(clientIds);
15273    blocks = actions_castArray(blocks);
15274    const rootClientId = select.getBlockRootClientId(clientIds[0]);
15275    // Replace is valid if the new blocks can be inserted in the root block.
15276    for (let index = 0; index < blocks.length; index++) {
15277      const block = blocks[index];
15278      const canInsertBlock = select.canInsertBlockType(block.name, rootClientId);
15279      if (!canInsertBlock) {
15280        return;
15281      }
15282    }
15283    // We're batching these two actions because an extra `undo/redo` step can
15284    // be created, based on whether we insert a default block or not.
15285    registry.batch(() => {
15286      dispatch({
15287        type: 'REPLACE_BLOCKS',
15288        clientIds,
15289        blocks,
15290        time: Date.now(),
15291        indexToSelect,
15292        initialPosition,
15293        meta
15294      });
15295      // To avoid a focus loss when removing the last block, assure there is
15296      // always a default block if the last of the blocks have been removed.
15297      dispatch.ensureDefaultBlock();
15298    });
15299  };
15300  
15301  /**
15302   * Action that replaces a single block with one or more replacement blocks.
15303   *
15304   * @param {(string|string[])} clientId Block client ID to replace.
15305   * @param {(Object|Object[])} block    Replacement block(s).
15306   *
15307   * @return {Object} Action object.
15308   */
15309  function replaceBlock(clientId, block) {
15310    return replaceBlocks(clientId, block);
15311  }
15312  
15313  /**
15314   * Higher-order action creator which, given the action type to dispatch creates
15315   * an action creator for managing block movement.
15316   *
15317   * @param {string} type Action type to dispatch.
15318   *
15319   * @return {Function} Action creator.
15320   */
15321  const createOnMove = type => (clientIds, rootClientId) => ({
15322    select,
15323    dispatch
15324  }) => {
15325    // If one of the blocks is locked or the parent is locked, we cannot move any block.
15326    const canMoveBlocks = select.canMoveBlocks(clientIds);
15327    if (!canMoveBlocks) {
15328      return;
15329    }
15330    dispatch({
15331      type,
15332      clientIds: actions_castArray(clientIds),
15333      rootClientId
15334    });
15335  };
15336  const moveBlocksDown = createOnMove('MOVE_BLOCKS_DOWN');
15337  const moveBlocksUp = createOnMove('MOVE_BLOCKS_UP');
15338  
15339  /**
15340   * Action that moves given blocks to a new position.
15341   *
15342   * @param {?string} clientIds        The client IDs of the blocks.
15343   * @param {?string} fromRootClientId Root client ID source.
15344   * @param {?string} toRootClientId   Root client ID destination.
15345   * @param {number}  index            The index to move the blocks to.
15346   */
15347  const moveBlocksToPosition = (clientIds, fromRootClientId = '', toRootClientId = '', index) => ({
15348    select,
15349    dispatch
15350  }) => {
15351    const canMoveBlocks = select.canMoveBlocks(clientIds);
15352  
15353    // If one of the blocks is locked or the parent is locked, we cannot move any block.
15354    if (!canMoveBlocks) {
15355      return;
15356    }
15357  
15358    // If moving inside the same root block the move is always possible.
15359    if (fromRootClientId !== toRootClientId) {
15360      const canRemoveBlocks = select.canRemoveBlocks(clientIds);
15361  
15362      // If we're moving to another block, it means we're deleting blocks from
15363      // the original block, so we need to check if removing is possible.
15364      if (!canRemoveBlocks) {
15365        return;
15366      }
15367      const canInsertBlocks = select.canInsertBlocks(clientIds, toRootClientId);
15368  
15369      // If moving to other parent block, the move is possible if we can insert a block of the same type inside the new parent block.
15370      if (!canInsertBlocks) {
15371        return;
15372      }
15373    }
15374    dispatch({
15375      type: 'MOVE_BLOCKS_TO_POSITION',
15376      fromRootClientId,
15377      toRootClientId,
15378      clientIds,
15379      index
15380    });
15381  };
15382  
15383  /**
15384   * Action that moves given block to a new position.
15385   *
15386   * @param {?string} clientId         The client ID of the block.
15387   * @param {?string} fromRootClientId Root client ID source.
15388   * @param {?string} toRootClientId   Root client ID destination.
15389   * @param {number}  index            The index to move the block to.
15390   */
15391  function moveBlockToPosition(clientId, fromRootClientId = '', toRootClientId = '', index) {
15392    return moveBlocksToPosition([clientId], fromRootClientId, toRootClientId, index);
15393  }
15394  
15395  /**
15396   * Action that inserts a single block, optionally at a specific index respective a root block list.
15397   *
15398   * Only allowed blocks are inserted. The action may fail silently for blocks that are not allowed or if
15399   * a templateLock is active on the block list.
15400   *
15401   * @param {Object}   block           Block object to insert.
15402   * @param {?number}  index           Index at which block should be inserted.
15403   * @param {?string}  rootClientId    Optional root client ID of block list on which to insert.
15404   * @param {?boolean} updateSelection If true block selection will be updated. If false, block selection will not change. Defaults to true.
15405   * @param {?Object}  meta            Optional Meta values to be passed to the action object.
15406   *
15407   * @return {Object} Action object.
15408   */
15409  function insertBlock(block, index, rootClientId, updateSelection, meta) {
15410    return insertBlocks([block], index, rootClientId, updateSelection, 0, meta);
15411  }
15412  
15413  /* eslint-disable jsdoc/valid-types */
15414  /**
15415   * Action that inserts an array of blocks, optionally at a specific index respective a root block list.
15416   *
15417   * Only allowed blocks are inserted. The action may fail silently for blocks that are not allowed or if
15418   * a templateLock is active on the block list.
15419   *
15420   * @param {Object[]}  blocks          Block objects to insert.
15421   * @param {?number}   index           Index at which block should be inserted.
15422   * @param {?string}   rootClientId    Optional root client ID of block list on which to insert.
15423   * @param {?boolean}  updateSelection If true block selection will be updated.  If false, block selection will not change. Defaults to true.
15424   * @param {0|-1|null} initialPosition Initial focus position. Setting it to null prevent focusing the inserted block.
15425   * @param {?Object}   meta            Optional Meta values to be passed to the action object.
15426   *
15427   * @return {Object} Action object.
15428   */
15429  const insertBlocks = (blocks, index, rootClientId, updateSelection = true, initialPosition = 0, meta) => ({
15430    select,
15431    dispatch
15432  }) => {
15433    /* eslint-enable jsdoc/valid-types */
15434    if (initialPosition !== null && typeof initialPosition === 'object') {
15435      meta = initialPosition;
15436      initialPosition = 0;
15437      external_wp_deprecated_default()("meta argument in wp.data.dispatch('core/block-editor')", {
15438        since: '5.8',
15439        hint: 'The meta argument is now the 6th argument of the function'
15440      });
15441    }
15442    blocks = actions_castArray(blocks);
15443    const allowedBlocks = [];
15444    for (const block of blocks) {
15445      const isValid = select.canInsertBlockType(block.name, rootClientId);
15446      if (isValid) {
15447        allowedBlocks.push(block);
15448      }
15449    }
15450    if (allowedBlocks.length) {
15451      dispatch({
15452        type: 'INSERT_BLOCKS',
15453        blocks: allowedBlocks,
15454        index,
15455        rootClientId,
15456        time: Date.now(),
15457        updateSelection,
15458        initialPosition: updateSelection ? initialPosition : null,
15459        meta
15460      });
15461    }
15462  };
15463  
15464  /**
15465   * Action that shows the insertion point.
15466   *
15467   * @param    {?string}         rootClientId           Optional root client ID of block list on
15468   *                                                    which to insert.
15469   * @param    {?number}         index                  Index at which block should be inserted.
15470   * @param    {?Object}         __unstableOptions      Additional options.
15471   * @property {boolean}         __unstableWithInserter Whether or not to show an inserter button.
15472   * @property {WPDropOperation} operation              The operation to perform when applied,
15473   *                                                    either 'insert' or 'replace' for now.
15474   *
15475   * @return {Object} Action object.
15476   */
15477  function showInsertionPoint(rootClientId, index, __unstableOptions = {}) {
15478    const {
15479      __unstableWithInserter,
15480      operation,
15481      nearestSide
15482    } = __unstableOptions;
15483    return {
15484      type: 'SHOW_INSERTION_POINT',
15485      rootClientId,
15486      index,
15487      __unstableWithInserter,
15488      operation,
15489      nearestSide
15490    };
15491  }
15492  /**
15493   * Action that hides the insertion point.
15494   */
15495  const hideInsertionPoint = () => ({
15496    select,
15497    dispatch
15498  }) => {
15499    if (!select.isBlockInsertionPointVisible()) {
15500      return;
15501    }
15502    dispatch({
15503      type: 'HIDE_INSERTION_POINT'
15504    });
15505  };
15506  
15507  /**
15508   * Action that resets the template validity.
15509   *
15510   * @param {boolean} isValid template validity flag.
15511   *
15512   * @return {Object} Action object.
15513   */
15514  function setTemplateValidity(isValid) {
15515    return {
15516      type: 'SET_TEMPLATE_VALIDITY',
15517      isValid
15518    };
15519  }
15520  
15521  /**
15522   * Action that synchronizes the template with the list of blocks.
15523   *
15524   * @return {Object} Action object.
15525   */
15526  const synchronizeTemplate = () => ({
15527    select,
15528    dispatch
15529  }) => {
15530    dispatch({
15531      type: 'SYNCHRONIZE_TEMPLATE'
15532    });
15533    const blocks = select.getBlocks();
15534    const template = select.getTemplate();
15535    const updatedBlockList = (0,external_wp_blocks_namespaceObject.synchronizeBlocksWithTemplate)(blocks, template);
15536    dispatch.resetBlocks(updatedBlockList);
15537  };
15538  
15539  /**
15540   * Delete the current selection.
15541   *
15542   * @param {boolean} isForward
15543   */
15544  const __unstableDeleteSelection = isForward => ({
15545    registry,
15546    select,
15547    dispatch
15548  }) => {
15549    const selectionAnchor = select.getSelectionStart();
15550    const selectionFocus = select.getSelectionEnd();
15551    if (selectionAnchor.clientId === selectionFocus.clientId) {
15552      return;
15553    }
15554  
15555    // It's not mergeable if there's no rich text selection.
15556    if (!selectionAnchor.attributeKey || !selectionFocus.attributeKey || typeof selectionAnchor.offset === 'undefined' || typeof selectionFocus.offset === 'undefined') {
15557      return false;
15558    }
15559    const anchorRootClientId = select.getBlockRootClientId(selectionAnchor.clientId);
15560    const focusRootClientId = select.getBlockRootClientId(selectionFocus.clientId);
15561  
15562    // It's not mergeable if the selection doesn't start and end in the same
15563    // block list. Maybe in the future it should be allowed.
15564    if (anchorRootClientId !== focusRootClientId) {
15565      return;
15566    }
15567    const blockOrder = select.getBlockOrder(anchorRootClientId);
15568    const anchorIndex = blockOrder.indexOf(selectionAnchor.clientId);
15569    const focusIndex = blockOrder.indexOf(selectionFocus.clientId);
15570  
15571    // Reassign selection start and end based on order.
15572    let selectionStart, selectionEnd;
15573    if (anchorIndex > focusIndex) {
15574      selectionStart = selectionFocus;
15575      selectionEnd = selectionAnchor;
15576    } else {
15577      selectionStart = selectionAnchor;
15578      selectionEnd = selectionFocus;
15579    }
15580    const targetSelection = isForward ? selectionEnd : selectionStart;
15581    const targetBlock = select.getBlock(targetSelection.clientId);
15582    const targetBlockType = (0,external_wp_blocks_namespaceObject.getBlockType)(targetBlock.name);
15583    if (!targetBlockType.merge) {
15584      return;
15585    }
15586    const selectionA = selectionStart;
15587    const selectionB = selectionEnd;
15588    const blockA = select.getBlock(selectionA.clientId);
15589    const blockB = select.getBlock(selectionB.clientId);
15590    const htmlA = blockA.attributes[selectionA.attributeKey];
15591    const htmlB = blockB.attributes[selectionB.attributeKey];
15592    let valueA = (0,external_wp_richText_namespaceObject.create)({
15593      html: htmlA
15594    });
15595    let valueB = (0,external_wp_richText_namespaceObject.create)({
15596      html: htmlB
15597    });
15598    valueA = (0,external_wp_richText_namespaceObject.remove)(valueA, selectionA.offset, valueA.text.length);
15599    valueB = (0,external_wp_richText_namespaceObject.insert)(valueB, START_OF_SELECTED_AREA, 0, selectionB.offset);
15600  
15601    // Clone the blocks so we don't manipulate the original.
15602    const cloneA = (0,external_wp_blocks_namespaceObject.cloneBlock)(blockA, {
15603      [selectionA.attributeKey]: (0,external_wp_richText_namespaceObject.toHTMLString)({
15604        value: valueA
15605      })
15606    });
15607    const cloneB = (0,external_wp_blocks_namespaceObject.cloneBlock)(blockB, {
15608      [selectionB.attributeKey]: (0,external_wp_richText_namespaceObject.toHTMLString)({
15609        value: valueB
15610      })
15611    });
15612    const followingBlock = isForward ? cloneA : cloneB;
15613  
15614    // We can only merge blocks with similar types
15615    // thus, we transform the block to merge first
15616    const blocksWithTheSameType = blockA.name === blockB.name ? [followingBlock] : (0,external_wp_blocks_namespaceObject.switchToBlockType)(followingBlock, targetBlockType.name);
15617  
15618    // If the block types can not match, do nothing
15619    if (!blocksWithTheSameType || !blocksWithTheSameType.length) {
15620      return;
15621    }
15622    let updatedAttributes;
15623    if (isForward) {
15624      const blockToMerge = blocksWithTheSameType.pop();
15625      updatedAttributes = targetBlockType.merge(blockToMerge.attributes, cloneB.attributes);
15626    } else {
15627      const blockToMerge = blocksWithTheSameType.shift();
15628      updatedAttributes = targetBlockType.merge(cloneA.attributes, blockToMerge.attributes);
15629    }
15630    const newAttributeKey = retrieveSelectedAttribute(updatedAttributes);
15631    const convertedHtml = updatedAttributes[newAttributeKey];
15632    const convertedValue = (0,external_wp_richText_namespaceObject.create)({
15633      html: convertedHtml
15634    });
15635    const newOffset = convertedValue.text.indexOf(START_OF_SELECTED_AREA);
15636    const newValue = (0,external_wp_richText_namespaceObject.remove)(convertedValue, newOffset, newOffset + 1);
15637    const newHtml = (0,external_wp_richText_namespaceObject.toHTMLString)({
15638      value: newValue
15639    });
15640    updatedAttributes[newAttributeKey] = newHtml;
15641    const selectedBlockClientIds = select.getSelectedBlockClientIds();
15642    const replacement = [...(isForward ? blocksWithTheSameType : []), {
15643      // Preserve the original client ID.
15644      ...targetBlock,
15645      attributes: {
15646        ...targetBlock.attributes,
15647        ...updatedAttributes
15648      }
15649    }, ...(isForward ? [] : blocksWithTheSameType)];
15650    registry.batch(() => {
15651      dispatch.selectionChange(targetBlock.clientId, newAttributeKey, newOffset, newOffset);
15652      dispatch.replaceBlocks(selectedBlockClientIds, replacement, 0,
15653      // If we don't pass the `indexToSelect` it will default to the last block.
15654      select.getSelectedBlocksInitialCaretPosition());
15655    });
15656  };
15657  
15658  /**
15659   * Split the current selection.
15660   * @param {?Array} blocks
15661   */
15662  const __unstableSplitSelection = (blocks = []) => ({
15663    registry,
15664    select,
15665    dispatch
15666  }) => {
15667    const selectionAnchor = select.getSelectionStart();
15668    const selectionFocus = select.getSelectionEnd();
15669    const anchorRootClientId = select.getBlockRootClientId(selectionAnchor.clientId);
15670    const focusRootClientId = select.getBlockRootClientId(selectionFocus.clientId);
15671  
15672    // It's not splittable if the selection doesn't start and end in the same
15673    // block list. Maybe in the future it should be allowed.
15674    if (anchorRootClientId !== focusRootClientId) {
15675      return;
15676    }
15677    const blockOrder = select.getBlockOrder(anchorRootClientId);
15678    const anchorIndex = blockOrder.indexOf(selectionAnchor.clientId);
15679    const focusIndex = blockOrder.indexOf(selectionFocus.clientId);
15680  
15681    // Reassign selection start and end based on order.
15682    let selectionStart, selectionEnd;
15683    if (anchorIndex > focusIndex) {
15684      selectionStart = selectionFocus;
15685      selectionEnd = selectionAnchor;
15686    } else {
15687      selectionStart = selectionAnchor;
15688      selectionEnd = selectionFocus;
15689    }
15690    const selectionA = selectionStart;
15691    const selectionB = selectionEnd;
15692    const blockA = select.getBlock(selectionA.clientId);
15693    const blockB = select.getBlock(selectionB.clientId);
15694    const blockAType = (0,external_wp_blocks_namespaceObject.getBlockType)(blockA.name);
15695    const blockBType = (0,external_wp_blocks_namespaceObject.getBlockType)(blockB.name);
15696    const attributeKeyA = typeof selectionA.attributeKey === 'string' ? selectionA.attributeKey : findRichTextAttributeKey(blockAType);
15697    const attributeKeyB = typeof selectionB.attributeKey === 'string' ? selectionB.attributeKey : findRichTextAttributeKey(blockBType);
15698    const blockAttributes = select.getBlockAttributes(selectionA.clientId);
15699    const bindings = blockAttributes?.metadata?.bindings;
15700  
15701    // If the attribute is bound, don't split the selection and insert a new block instead.
15702    if (bindings?.[attributeKeyA]) {
15703      // Show warning if user tries to insert a block into another block with bindings.
15704      if (blocks.length) {
15705        const {
15706          createWarningNotice
15707        } = registry.dispatch(external_wp_notices_namespaceObject.store);
15708        createWarningNotice((0,external_wp_i18n_namespaceObject.__)("Blocks can't be inserted into other blocks with bindings"), {
15709          type: 'snackbar'
15710        });
15711        return;
15712      }
15713      dispatch.insertAfterBlock(selectionA.clientId);
15714      return;
15715    }
15716  
15717    // Can't split if the selection is not set.
15718    if (!attributeKeyA || !attributeKeyB || typeof selectionAnchor.offset === 'undefined' || typeof selectionFocus.offset === 'undefined') {
15719      return;
15720    }
15721  
15722    // We can do some short-circuiting if the selection is collapsed.
15723    if (selectionA.clientId === selectionB.clientId && attributeKeyA === attributeKeyB && selectionA.offset === selectionB.offset) {
15724      // If an unmodified default block is selected, replace it. We don't
15725      // want to be converting into a default block.
15726      if (blocks.length) {
15727        if ((0,external_wp_blocks_namespaceObject.isUnmodifiedDefaultBlock)(blockA)) {
15728          dispatch.replaceBlocks([selectionA.clientId], blocks, blocks.length - 1, -1);
15729          return;
15730        }
15731      }
15732  
15733      // If selection is at the start or end, we can simply insert an
15734      // empty block, provided this block has no inner blocks.
15735      else if (!select.getBlockOrder(selectionA.clientId).length) {
15736        function createEmpty() {
15737          const defaultBlockName = (0,external_wp_blocks_namespaceObject.getDefaultBlockName)();
15738          return select.canInsertBlockType(defaultBlockName, anchorRootClientId) ? (0,external_wp_blocks_namespaceObject.createBlock)(defaultBlockName) : (0,external_wp_blocks_namespaceObject.createBlock)(select.getBlockName(selectionA.clientId));
15739        }
15740        const length = blockAttributes[attributeKeyA].length;
15741        if (selectionA.offset === 0 && length) {
15742          dispatch.insertBlocks([createEmpty()], select.getBlockIndex(selectionA.clientId), anchorRootClientId, false);
15743          return;
15744        }
15745        if (selectionA.offset === length) {
15746          dispatch.insertBlocks([createEmpty()], select.getBlockIndex(selectionA.clientId) + 1, anchorRootClientId);
15747          return;
15748        }
15749      }
15750    }
15751    const htmlA = blockA.attributes[attributeKeyA];
15752    const htmlB = blockB.attributes[attributeKeyB];
15753    let valueA = (0,external_wp_richText_namespaceObject.create)({
15754      html: htmlA
15755    });
15756    let valueB = (0,external_wp_richText_namespaceObject.create)({
15757      html: htmlB
15758    });
15759    valueA = (0,external_wp_richText_namespaceObject.remove)(valueA, selectionA.offset, valueA.text.length);
15760    valueB = (0,external_wp_richText_namespaceObject.remove)(valueB, 0, selectionB.offset);
15761    let head = {
15762      // Preserve the original client ID.
15763      ...blockA,
15764      // If both start and end are the same, should only copy innerBlocks
15765      // once.
15766      innerBlocks: blockA.clientId === blockB.clientId ? [] : blockA.innerBlocks,
15767      attributes: {
15768        ...blockA.attributes,
15769        [attributeKeyA]: (0,external_wp_richText_namespaceObject.toHTMLString)({
15770          value: valueA
15771        })
15772      }
15773    };
15774    let tail = {
15775      ...blockB,
15776      // Only preserve the original client ID if the end is different.
15777      clientId: blockA.clientId === blockB.clientId ? (0,external_wp_blocks_namespaceObject.createBlock)(blockB.name).clientId : blockB.clientId,
15778      attributes: {
15779        ...blockB.attributes,
15780        [attributeKeyB]: (0,external_wp_richText_namespaceObject.toHTMLString)({
15781          value: valueB
15782        })
15783      }
15784    };
15785  
15786    // When splitting a block, attempt to convert the tail block to the
15787    // default block type. For example, when splitting a heading block, the
15788    // tail block will be converted to a paragraph block. Note that for
15789    // blocks such as a list item and button, this will be skipped because
15790    // the default block type cannot be inserted.
15791    const defaultBlockName = (0,external_wp_blocks_namespaceObject.getDefaultBlockName)();
15792    if (
15793    // A block is only split when the selection is within the same
15794    // block.
15795    blockA.clientId === blockB.clientId && defaultBlockName && tail.name !== defaultBlockName && select.canInsertBlockType(defaultBlockName, anchorRootClientId)) {
15796      const switched = (0,external_wp_blocks_namespaceObject.switchToBlockType)(tail, defaultBlockName);
15797      if (switched?.length === 1) {
15798        tail = switched[0];
15799      }
15800    }
15801    if (!blocks.length) {
15802      dispatch.replaceBlocks(select.getSelectedBlockClientIds(), [head, tail]);
15803      return;
15804    }
15805    let selection;
15806    const output = [];
15807    const clonedBlocks = [...blocks];
15808    const firstBlock = clonedBlocks.shift();
15809    const headType = (0,external_wp_blocks_namespaceObject.getBlockType)(head.name);
15810    const firstBlocks = headType.merge && firstBlock.name === headType.name ? [firstBlock] : (0,external_wp_blocks_namespaceObject.switchToBlockType)(firstBlock, headType.name);
15811    if (firstBlocks?.length) {
15812      const first = firstBlocks.shift();
15813      head = {
15814        ...head,
15815        attributes: {
15816          ...head.attributes,
15817          ...headType.merge(head.attributes, first.attributes)
15818        }
15819      };
15820      output.push(head);
15821      selection = {
15822        clientId: head.clientId,
15823        attributeKey: attributeKeyA,
15824        offset: (0,external_wp_richText_namespaceObject.create)({
15825          html: head.attributes[attributeKeyA]
15826        }).text.length
15827      };
15828      clonedBlocks.unshift(...firstBlocks);
15829    } else {
15830      if (!(0,external_wp_blocks_namespaceObject.isUnmodifiedBlock)(head)) {
15831        output.push(head);
15832      }
15833      output.push(firstBlock);
15834    }
15835    const lastBlock = clonedBlocks.pop();
15836    const tailType = (0,external_wp_blocks_namespaceObject.getBlockType)(tail.name);
15837    if (clonedBlocks.length) {
15838      output.push(...clonedBlocks);
15839    }
15840    if (lastBlock) {
15841      const lastBlocks = tailType.merge && tailType.name === lastBlock.name ? [lastBlock] : (0,external_wp_blocks_namespaceObject.switchToBlockType)(lastBlock, tailType.name);
15842      if (lastBlocks?.length) {
15843        const last = lastBlocks.pop();
15844        output.push({
15845          ...tail,
15846          attributes: {
15847            ...tail.attributes,
15848            ...tailType.merge(last.attributes, tail.attributes)
15849          }
15850        });
15851        output.push(...lastBlocks);
15852        selection = {
15853          clientId: tail.clientId,
15854          attributeKey: attributeKeyB,
15855          offset: (0,external_wp_richText_namespaceObject.create)({
15856            html: last.attributes[attributeKeyB]
15857          }).text.length
15858        };
15859      } else {
15860        output.push(lastBlock);
15861        if (!(0,external_wp_blocks_namespaceObject.isUnmodifiedBlock)(tail)) {
15862          output.push(tail);
15863        }
15864      }
15865    } else if (!(0,external_wp_blocks_namespaceObject.isUnmodifiedBlock)(tail)) {
15866      output.push(tail);
15867    }
15868    registry.batch(() => {
15869      dispatch.replaceBlocks(select.getSelectedBlockClientIds(), output, output.length - 1, 0);
15870      if (selection) {
15871        dispatch.selectionChange(selection.clientId, selection.attributeKey, selection.offset, selection.offset);
15872      }
15873    });
15874  };
15875  
15876  /**
15877   * Expand the selection to cover the entire blocks, removing partial selection.
15878   */
15879  const __unstableExpandSelection = () => ({
15880    select,
15881    dispatch
15882  }) => {
15883    const selectionAnchor = select.getSelectionStart();
15884    const selectionFocus = select.getSelectionEnd();
15885    dispatch.selectionChange({
15886      start: {
15887        clientId: selectionAnchor.clientId
15888      },
15889      end: {
15890        clientId: selectionFocus.clientId
15891      }
15892    });
15893  };
15894  
15895  /**
15896   * Action that merges two blocks.
15897   *
15898   * @param {string} firstBlockClientId  Client ID of the first block to merge.
15899   * @param {string} secondBlockClientId Client ID of the second block to merge.
15900   */
15901  const mergeBlocks = (firstBlockClientId, secondBlockClientId) => ({
15902    registry,
15903    select,
15904    dispatch
15905  }) => {
15906    const clientIdA = firstBlockClientId;
15907    const clientIdB = secondBlockClientId;
15908    const blockA = select.getBlock(clientIdA);
15909    const blockAType = (0,external_wp_blocks_namespaceObject.getBlockType)(blockA.name);
15910    if (!blockAType) {
15911      return;
15912    }
15913    const blockB = select.getBlock(clientIdB);
15914    if (!blockAType.merge && (0,external_wp_blocks_namespaceObject.getBlockSupport)(blockA.name, '__experimentalOnMerge')) {
15915      // If there's no merge function defined, attempt merging inner
15916      // blocks.
15917      const blocksWithTheSameType = (0,external_wp_blocks_namespaceObject.switchToBlockType)(blockB, blockAType.name);
15918      // Only focus the previous block if it's not mergeable.
15919      if (blocksWithTheSameType?.length !== 1) {
15920        dispatch.selectBlock(blockA.clientId);
15921        return;
15922      }
15923      const [blockWithSameType] = blocksWithTheSameType;
15924      if (blockWithSameType.innerBlocks.length < 1) {
15925        dispatch.selectBlock(blockA.clientId);
15926        return;
15927      }
15928      registry.batch(() => {
15929        dispatch.insertBlocks(blockWithSameType.innerBlocks, undefined, clientIdA);
15930        dispatch.removeBlock(clientIdB);
15931        dispatch.selectBlock(blockWithSameType.innerBlocks[0].clientId);
15932  
15933        // Attempt to merge the next block if it's the same type and
15934        // same attributes. This is useful when merging a paragraph into
15935        // a list, and the next block is also a list. If we don't merge,
15936        // it looks like one list, but it's actually two lists. The same
15937        // applies to other blocks such as a group with the same
15938        // attributes.
15939        const nextBlockClientId = select.getNextBlockClientId(clientIdA);
15940        if (nextBlockClientId && select.getBlockName(clientIdA) === select.getBlockName(nextBlockClientId)) {
15941          const rootAttributes = select.getBlockAttributes(clientIdA);
15942          const previousRootAttributes = select.getBlockAttributes(nextBlockClientId);
15943          if (Object.keys(rootAttributes).every(key => rootAttributes[key] === previousRootAttributes[key])) {
15944            dispatch.moveBlocksToPosition(select.getBlockOrder(nextBlockClientId), nextBlockClientId, clientIdA);
15945            dispatch.removeBlock(nextBlockClientId, false);
15946          }
15947        }
15948      });
15949      return;
15950    }
15951    if ((0,external_wp_blocks_namespaceObject.isUnmodifiedDefaultBlock)(blockA)) {
15952      dispatch.removeBlock(clientIdA, select.isBlockSelected(clientIdA));
15953      return;
15954    }
15955    if ((0,external_wp_blocks_namespaceObject.isUnmodifiedDefaultBlock)(blockB)) {
15956      dispatch.removeBlock(clientIdB, select.isBlockSelected(clientIdB));
15957      return;
15958    }
15959    if (!blockAType.merge) {
15960      dispatch.selectBlock(blockA.clientId);
15961      return;
15962    }
15963    const blockBType = (0,external_wp_blocks_namespaceObject.getBlockType)(blockB.name);
15964    const {
15965      clientId,
15966      attributeKey,
15967      offset
15968    } = select.getSelectionStart();
15969    const selectedBlockType = clientId === clientIdA ? blockAType : blockBType;
15970    const attributeDefinition = selectedBlockType.attributes[attributeKey];
15971    const canRestoreTextSelection = (clientId === clientIdA || clientId === clientIdB) && attributeKey !== undefined && offset !== undefined &&
15972    // We cannot restore text selection if the RichText identifier
15973    // is not a defined block attribute key. This can be the case if the
15974    // fallback instance ID is used to store selection (and no RichText
15975    // identifier is set), or when the identifier is wrong.
15976    !!attributeDefinition;
15977    if (!attributeDefinition) {
15978      if (typeof attributeKey === 'number') {
15979        window.console.error(`RichText needs an identifier prop that is the block attribute key of the attribute it controls. Its type is expected to be a string, but was $typeof attributeKey}`);
15980      } else {
15981        window.console.error('The RichText identifier prop does not match any attributes defined by the block.');
15982      }
15983    }
15984  
15985    // Clone the blocks so we don't insert the character in a "live" block.
15986    const cloneA = (0,external_wp_blocks_namespaceObject.cloneBlock)(blockA);
15987    const cloneB = (0,external_wp_blocks_namespaceObject.cloneBlock)(blockB);
15988    if (canRestoreTextSelection) {
15989      const selectedBlock = clientId === clientIdA ? cloneA : cloneB;
15990      const html = selectedBlock.attributes[attributeKey];
15991      const value = (0,external_wp_richText_namespaceObject.insert)((0,external_wp_richText_namespaceObject.create)({
15992        html
15993      }), START_OF_SELECTED_AREA, offset, offset);
15994      selectedBlock.attributes[attributeKey] = (0,external_wp_richText_namespaceObject.toHTMLString)({
15995        value
15996      });
15997    }
15998  
15999    // We can only merge blocks with similar types
16000    // thus, we transform the block to merge first.
16001    const blocksWithTheSameType = blockA.name === blockB.name ? [cloneB] : (0,external_wp_blocks_namespaceObject.switchToBlockType)(cloneB, blockA.name);
16002  
16003    // If the block types can not match, do nothing.
16004    if (!blocksWithTheSameType || !blocksWithTheSameType.length) {
16005      return;
16006    }
16007  
16008    // Calling the merge to update the attributes and remove the block to be merged.
16009    const updatedAttributes = blockAType.merge(cloneA.attributes, blocksWithTheSameType[0].attributes);
16010    if (canRestoreTextSelection) {
16011      const newAttributeKey = retrieveSelectedAttribute(updatedAttributes);
16012      const convertedHtml = updatedAttributes[newAttributeKey];
16013      const convertedValue = (0,external_wp_richText_namespaceObject.create)({
16014        html: convertedHtml
16015      });
16016      const newOffset = convertedValue.text.indexOf(START_OF_SELECTED_AREA);
16017      const newValue = (0,external_wp_richText_namespaceObject.remove)(convertedValue, newOffset, newOffset + 1);
16018      const newHtml = (0,external_wp_richText_namespaceObject.toHTMLString)({
16019        value: newValue
16020      });
16021      updatedAttributes[newAttributeKey] = newHtml;
16022      dispatch.selectionChange(blockA.clientId, newAttributeKey, newOffset, newOffset);
16023    }
16024    dispatch.replaceBlocks([blockA.clientId, blockB.clientId], [{
16025      ...blockA,
16026      attributes: {
16027        ...blockA.attributes,
16028        ...updatedAttributes
16029      }
16030    }, ...blocksWithTheSameType.slice(1)], 0 // If we don't pass the `indexToSelect` it will default to the last block.
16031    );
16032  };
16033  
16034  /**
16035   * Yields action objects used in signalling that the blocks corresponding to
16036   * the set of specified client IDs are to be removed.
16037   *
16038   * @param {string|string[]} clientIds      Client IDs of blocks to remove.
16039   * @param {boolean}         selectPrevious True if the previous block
16040   *                                         or the immediate parent
16041   *                                         (if no previous block exists)
16042   *                                         should be selected
16043   *                                         when a block is removed.
16044   */
16045  const removeBlocks = (clientIds, selectPrevious = true) => privateRemoveBlocks(clientIds, selectPrevious);
16046  
16047  /**
16048   * Returns an action object used in signalling that the block with the
16049   * specified client ID is to be removed.
16050   *
16051   * @param {string}  clientId       Client ID of block to remove.
16052   * @param {boolean} selectPrevious True if the previous block should be
16053   *                                 selected when a block is removed.
16054   *
16055   * @return {Object} Action object.
16056   */
16057  function removeBlock(clientId, selectPrevious) {
16058    return removeBlocks([clientId], selectPrevious);
16059  }
16060  
16061  /* eslint-disable jsdoc/valid-types */
16062  /**
16063   * Returns an action object used in signalling that the inner blocks with the
16064   * specified client ID should be replaced.
16065   *
16066   * @param {string}    rootClientId    Client ID of the block whose InnerBlocks will re replaced.
16067   * @param {Object[]}  blocks          Block objects to insert as new InnerBlocks
16068   * @param {?boolean}  updateSelection If true block selection will be updated. If false, block selection will not change. Defaults to false.
16069   * @param {0|-1|null} initialPosition Initial block position.
16070   * @return {Object} Action object.
16071   */
16072  function replaceInnerBlocks(rootClientId, blocks, updateSelection = false, initialPosition = 0) {
16073    /* eslint-enable jsdoc/valid-types */
16074    return {
16075      type: 'REPLACE_INNER_BLOCKS',
16076      rootClientId,
16077      blocks,
16078      updateSelection,
16079      initialPosition: updateSelection ? initialPosition : null,
16080      time: Date.now()
16081    };
16082  }
16083  
16084  /**
16085   * Returns an action object used to toggle the block editing mode between
16086   * visual and HTML modes.
16087   *
16088   * @param {string} clientId Block client ID.
16089   *
16090   * @return {Object} Action object.
16091   */
16092  function toggleBlockMode(clientId) {
16093    return {
16094      type: 'TOGGLE_BLOCK_MODE',
16095      clientId
16096    };
16097  }
16098  
16099  /**
16100   * Returns an action object used in signalling that the user has begun to type.
16101   *
16102   * @return {Object} Action object.
16103   */
16104  function startTyping() {
16105    return {
16106      type: 'START_TYPING'
16107    };
16108  }
16109  
16110  /**
16111   * Returns an action object used in signalling that the user has stopped typing.
16112   *
16113   * @return {Object} Action object.
16114   */
16115  function stopTyping() {
16116    return {
16117      type: 'STOP_TYPING'
16118    };
16119  }
16120  
16121  /**
16122   * Returns an action object used in signalling that the user has begun to drag blocks.
16123   *
16124   * @param {string[]} clientIds An array of client ids being dragged
16125   *
16126   * @return {Object} Action object.
16127   */
16128  function startDraggingBlocks(clientIds = []) {
16129    return {
16130      type: 'START_DRAGGING_BLOCKS',
16131      clientIds
16132    };
16133  }
16134  
16135  /**
16136   * Returns an action object used in signalling that the user has stopped dragging blocks.
16137   *
16138   * @return {Object} Action object.
16139   */
16140  function stopDraggingBlocks() {
16141    return {
16142      type: 'STOP_DRAGGING_BLOCKS'
16143    };
16144  }
16145  
16146  /**
16147   * Returns an action object used in signalling that the caret has entered formatted text.
16148   *
16149   * @deprecated
16150   *
16151   * @return {Object} Action object.
16152   */
16153  function enterFormattedText() {
16154    external_wp_deprecated_default()('wp.data.dispatch( "core/block-editor" ).enterFormattedText', {
16155      since: '6.1',
16156      version: '6.3'
16157    });
16158    return {
16159      type: 'DO_NOTHING'
16160    };
16161  }
16162  
16163  /**
16164   * Returns an action object used in signalling that the user caret has exited formatted text.
16165   *
16166   * @deprecated
16167   *
16168   * @return {Object} Action object.
16169   */
16170  function exitFormattedText() {
16171    external_wp_deprecated_default()('wp.data.dispatch( "core/block-editor" ).exitFormattedText', {
16172      since: '6.1',
16173      version: '6.3'
16174    });
16175    return {
16176      type: 'DO_NOTHING'
16177    };
16178  }
16179  
16180  /**
16181   * Action that changes the position of the user caret.
16182   *
16183   * @param {string|WPSelection} clientId     The selected block client ID.
16184   * @param {string}             attributeKey The selected block attribute key.
16185   * @param {number}             startOffset  The start offset.
16186   * @param {number}             endOffset    The end offset.
16187   *
16188   * @return {Object} Action object.
16189   */
16190  function selectionChange(clientId, attributeKey, startOffset, endOffset) {
16191    if (typeof clientId === 'string') {
16192      return {
16193        type: 'SELECTION_CHANGE',
16194        clientId,
16195        attributeKey,
16196        startOffset,
16197        endOffset
16198      };
16199    }
16200    return {
16201      type: 'SELECTION_CHANGE',
16202      ...clientId
16203    };
16204  }
16205  
16206  /**
16207   * Action that adds a new block of the default type to the block list.
16208   *
16209   * @param {?Object} attributes   Optional attributes of the block to assign.
16210   * @param {?string} rootClientId Optional root client ID of block list on which
16211   *                               to append.
16212   * @param {?number} index        Optional index where to insert the default block.
16213   */
16214  const insertDefaultBlock = (attributes, rootClientId, index) => ({
16215    dispatch
16216  }) => {
16217    // Abort if there is no default block type (if it has been unregistered).
16218    const defaultBlockName = (0,external_wp_blocks_namespaceObject.getDefaultBlockName)();
16219    if (!defaultBlockName) {
16220      return;
16221    }
16222    const block = (0,external_wp_blocks_namespaceObject.createBlock)(defaultBlockName, attributes);
16223    return dispatch.insertBlock(block, index, rootClientId);
16224  };
16225  
16226  /**
16227   * @typedef {Object< string, Object >} SettingsByClientId
16228   */
16229  
16230  /**
16231   * Action that changes the nested settings of the given block(s).
16232   *
16233   * @param {string | SettingsByClientId} clientId Client ID of the block whose
16234   *                                               nested setting are being
16235   *                                               received, or object of settings
16236   *                                               by client ID.
16237   * @param {Object}                      settings Object with the new settings
16238   *                                               for the nested block.
16239   *
16240   * @return {Object} Action object
16241   */
16242  function updateBlockListSettings(clientId, settings) {
16243    return {
16244      type: 'UPDATE_BLOCK_LIST_SETTINGS',
16245      clientId,
16246      settings
16247    };
16248  }
16249  
16250  /**
16251   * Action that updates the block editor settings.
16252   *
16253   * @param {Object} settings Updated settings
16254   *
16255   * @return {Object} Action object
16256   */
16257  function updateSettings(settings) {
16258    return __experimentalUpdateSettings(settings, {
16259      stripExperimentalSettings: true
16260    });
16261  }
16262  
16263  /**
16264   * Action that signals that a temporary reusable block has been saved
16265   * in order to switch its temporary id with the real id.
16266   *
16267   * @param {string} id        Reusable block's id.
16268   * @param {string} updatedId Updated block's id.
16269   *
16270   * @return {Object} Action object.
16271   */
16272  function __unstableSaveReusableBlock(id, updatedId) {
16273    return {
16274      type: 'SAVE_REUSABLE_BLOCK_SUCCESS',
16275      id,
16276      updatedId
16277    };
16278  }
16279  
16280  /**
16281   * Action that marks the last block change explicitly as persistent.
16282   *
16283   * @return {Object} Action object.
16284   */
16285  function __unstableMarkLastChangeAsPersistent() {
16286    return {
16287      type: 'MARK_LAST_CHANGE_AS_PERSISTENT'
16288    };
16289  }
16290  
16291  /**
16292   * Action that signals that the next block change should be marked explicitly as not persistent.
16293   *
16294   * @return {Object} Action object.
16295   */
16296  function __unstableMarkNextChangeAsNotPersistent() {
16297    return {
16298      type: 'MARK_NEXT_CHANGE_AS_NOT_PERSISTENT'
16299    };
16300  }
16301  
16302  /**
16303   * Action that marks the last block change as an automatic change, meaning it was not
16304   * performed by the user, and can be undone using the `Escape` and `Backspace` keys.
16305   * This action must be called after the change was made, and any actions that are a
16306   * consequence of it, so it is recommended to be called at the next idle period to ensure all
16307   * selection changes have been recorded.
16308   */
16309  const __unstableMarkAutomaticChange = () => ({
16310    dispatch
16311  }) => {
16312    dispatch({
16313      type: 'MARK_AUTOMATIC_CHANGE'
16314    });
16315    const {
16316      requestIdleCallback = cb => setTimeout(cb, 100)
16317    } = window;
16318    requestIdleCallback(() => {
16319      dispatch({
16320        type: 'MARK_AUTOMATIC_CHANGE_FINAL'
16321      });
16322    });
16323  };
16324  
16325  /**
16326   * Action that enables or disables the navigation mode.
16327   *
16328   * @param {boolean} isNavigationMode Enable/Disable navigation mode.
16329   */
16330  const setNavigationMode = (isNavigationMode = true) => ({
16331    dispatch
16332  }) => {
16333    dispatch.__unstableSetEditorMode(isNavigationMode ? 'navigation' : 'edit');
16334  };
16335  
16336  /**
16337   * Action that sets the editor mode
16338   *
16339   * @param {string} mode Editor mode
16340   */
16341  const __unstableSetEditorMode = mode => ({
16342    registry
16343  }) => {
16344    registry.dispatch(external_wp_preferences_namespaceObject.store).set('core', 'editorTool', mode);
16345    if (mode === 'navigation') {
16346      (0,external_wp_a11y_namespaceObject.speak)((0,external_wp_i18n_namespaceObject.__)('You are currently in Write mode.'));
16347    } else if (mode === 'edit') {
16348      (0,external_wp_a11y_namespaceObject.speak)((0,external_wp_i18n_namespaceObject.__)('You are currently in Design mode.'));
16349    }
16350  };
16351  
16352  /**
16353   * Set the block moving client ID.
16354   *
16355   * @deprecated
16356   *
16357   * @return {Object} Action object.
16358   */
16359  function setBlockMovingClientId() {
16360    external_wp_deprecated_default()('wp.data.dispatch( "core/block-editor" ).setBlockMovingClientId', {
16361      since: '6.7',
16362      hint: 'Block moving mode feature has been removed'
16363    });
16364    return {
16365      type: 'DO_NOTHING'
16366    };
16367  }
16368  
16369  /**
16370   * Action that duplicates a list of blocks.
16371   *
16372   * @param {string[]} clientIds
16373   * @param {boolean}  updateSelection
16374   */
16375  const duplicateBlocks = (clientIds, updateSelection = true) => ({
16376    select,
16377    dispatch
16378  }) => {
16379    if (!clientIds || !clientIds.length) {
16380      return;
16381    }
16382  
16383    // Return early if blocks don't exist.
16384    const blocks = select.getBlocksByClientId(clientIds);
16385    if (blocks.some(block => !block)) {
16386      return;
16387    }
16388  
16389    // Return early if blocks don't support multiple usage.
16390    const blockNames = blocks.map(block => block.name);
16391    if (blockNames.some(blockName => !(0,external_wp_blocks_namespaceObject.hasBlockSupport)(blockName, 'multiple', true))) {
16392      return;
16393    }
16394    const rootClientId = select.getBlockRootClientId(clientIds[0]);
16395    const clientIdsArray = actions_castArray(clientIds);
16396    const lastSelectedIndex = select.getBlockIndex(clientIdsArray[clientIdsArray.length - 1]);
16397    const clonedBlocks = blocks.map(block => (0,external_wp_blocks_namespaceObject.__experimentalCloneSanitizedBlock)(block));
16398    dispatch.insertBlocks(clonedBlocks, lastSelectedIndex + 1, rootClientId, updateSelection);
16399    if (clonedBlocks.length > 1 && updateSelection) {
16400      dispatch.multiSelect(clonedBlocks[0].clientId, clonedBlocks[clonedBlocks.length - 1].clientId);
16401    }
16402    return clonedBlocks.map(block => block.clientId);
16403  };
16404  
16405  /**
16406   * Action that inserts a default block before a given block.
16407   *
16408   * @param {string} clientId
16409   */
16410  const insertBeforeBlock = clientId => ({
16411    select,
16412    dispatch
16413  }) => {
16414    if (!clientId) {
16415      return;
16416    }
16417    const rootClientId = select.getBlockRootClientId(clientId);
16418    const isLocked = select.getTemplateLock(rootClientId);
16419    if (isLocked) {
16420      return;
16421    }
16422    const blockIndex = select.getBlockIndex(clientId);
16423    const directInsertBlock = rootClientId ? select.getDirectInsertBlock(rootClientId) : null;
16424    if (!directInsertBlock) {
16425      return dispatch.insertDefaultBlock({}, rootClientId, blockIndex);
16426    }
16427    const copiedAttributes = {};
16428    if (directInsertBlock.attributesToCopy) {
16429      const attributes = select.getBlockAttributes(clientId);
16430      directInsertBlock.attributesToCopy.forEach(key => {
16431        if (attributes[key]) {
16432          copiedAttributes[key] = attributes[key];
16433        }
16434      });
16435    }
16436    const block = (0,external_wp_blocks_namespaceObject.createBlock)(directInsertBlock.name, {
16437      ...directInsertBlock.attributes,
16438      ...copiedAttributes
16439    });
16440    return dispatch.insertBlock(block, blockIndex, rootClientId);
16441  };
16442  
16443  /**
16444   * Action that inserts a default block after a given block.
16445   *
16446   * @param {string} clientId
16447   */
16448  const insertAfterBlock = clientId => ({
16449    select,
16450    dispatch
16451  }) => {
16452    if (!clientId) {
16453      return;
16454    }
16455    const rootClientId = select.getBlockRootClientId(clientId);
16456    const isLocked = select.getTemplateLock(rootClientId);
16457    if (isLocked) {
16458      return;
16459    }
16460    const blockIndex = select.getBlockIndex(clientId);
16461    const directInsertBlock = rootClientId ? select.getDirectInsertBlock(rootClientId) : null;
16462    if (!directInsertBlock) {
16463      return dispatch.insertDefaultBlock({}, rootClientId, blockIndex + 1);
16464    }
16465    const copiedAttributes = {};
16466    if (directInsertBlock.attributesToCopy) {
16467      const attributes = select.getBlockAttributes(clientId);
16468      directInsertBlock.attributesToCopy.forEach(key => {
16469        if (attributes[key]) {
16470          copiedAttributes[key] = attributes[key];
16471        }
16472      });
16473    }
16474    const block = (0,external_wp_blocks_namespaceObject.createBlock)(directInsertBlock.name, {
16475      ...directInsertBlock.attributes,
16476      ...copiedAttributes
16477    });
16478    return dispatch.insertBlock(block, blockIndex + 1, rootClientId);
16479  };
16480  
16481  /**
16482   * Action that toggles the highlighted block state.
16483   *
16484   * @param {string}  clientId      The block's clientId.
16485   * @param {boolean} isHighlighted The highlight state.
16486   */
16487  function toggleBlockHighlight(clientId, isHighlighted) {
16488    return {
16489      type: 'TOGGLE_BLOCK_HIGHLIGHT',
16490      clientId,
16491      isHighlighted
16492    };
16493  }
16494  
16495  /**
16496   * Action that "flashes" the block with a given `clientId` by rhythmically highlighting it.
16497   *
16498   * @param {string} clientId Target block client ID.
16499   */
16500  const flashBlock = clientId => async ({
16501    dispatch
16502  }) => {
16503    dispatch(toggleBlockHighlight(clientId, true));
16504    await new Promise(resolve => setTimeout(resolve, 150));
16505    dispatch(toggleBlockHighlight(clientId, false));
16506  };
16507  
16508  /**
16509   * Action that sets whether a block has controlled inner blocks.
16510   *
16511   * @param {string}  clientId                 The block's clientId.
16512   * @param {boolean} hasControlledInnerBlocks True if the block's inner blocks are controlled.
16513   */
16514  function setHasControlledInnerBlocks(clientId, hasControlledInnerBlocks) {
16515    return {
16516      type: 'SET_HAS_CONTROLLED_INNER_BLOCKS',
16517      hasControlledInnerBlocks,
16518      clientId
16519    };
16520  }
16521  
16522  /**
16523   * Action that sets whether given blocks are visible on the canvas.
16524   *
16525   * @param {Record<string,boolean>} updates For each block's clientId, its new visibility setting.
16526   */
16527  function setBlockVisibility(updates) {
16528    return {
16529      type: 'SET_BLOCK_VISIBILITY',
16530      updates
16531    };
16532  }
16533  
16534  /**
16535   * Action that sets whether a block is being temporarily edited as blocks.
16536   *
16537   * DO-NOT-USE in production.
16538   * This action is created for internal/experimental only usage and may be
16539   * removed anytime without any warning, causing breakage on any plugin or theme invoking it.
16540   *
16541   * @param {?string} temporarilyEditingAsBlocks The block's clientId being temporarily edited as blocks.
16542   * @param {?string} focusModeToRevert          The focus mode to revert after temporarily edit as blocks finishes.
16543   */
16544  function __unstableSetTemporarilyEditingAsBlocks(temporarilyEditingAsBlocks, focusModeToRevert) {
16545    return {
16546      type: 'SET_TEMPORARILY_EDITING_AS_BLOCKS',
16547      temporarilyEditingAsBlocks,
16548      focusModeToRevert
16549    };
16550  }
16551  
16552  /**
16553   * Interface for inserter media requests.
16554   *
16555   * @typedef {Object} InserterMediaRequest
16556   * @property {number} per_page How many items to fetch per page.
16557   * @property {string} search   The search term to use for filtering the results.
16558   */
16559  
16560  /**
16561   * Interface for inserter media responses. Any media resource should
16562   * map their response to this interface, in order to create the core
16563   * WordPress media blocks (image, video, audio).
16564   *
16565   * @typedef {Object} InserterMediaItem
16566   * @property {string}        title        The title of the media item.
16567   * @property {string}        url          The source url of the media item.
16568   * @property {string}        [previewUrl] The preview source url of the media item to display in the media list.
16569   * @property {number}        [id]         The WordPress id of the media item.
16570   * @property {number|string} [sourceId]   The id of the media item from external source.
16571   * @property {string}        [alt]        The alt text of the media item.
16572   * @property {string}        [caption]    The caption of the media item.
16573   */
16574  
16575  /**
16576   * Registers a new inserter media category. Once registered, the media category is
16577   * available in the inserter's media tab.
16578   *
16579   * The following interfaces are used:
16580   *
16581   * _Type Definition_
16582   *
16583   * - _InserterMediaRequest_ `Object`: Interface for inserter media requests.
16584   *
16585   * _Properties_
16586   *
16587   * - _per_page_ `number`: How many items to fetch per page.
16588   * - _search_ `string`: The search term to use for filtering the results.
16589   *
16590   * _Type Definition_
16591   *
16592   * - _InserterMediaItem_ `Object`: Interface for inserter media responses. Any media resource should
16593   * map their response to this interface, in order to create the core
16594   * WordPress media blocks (image, video, audio).
16595   *
16596   * _Properties_
16597   *
16598   * - _title_ `string`: The title of the media item.
16599   * - _url_ `string: The source url of the media item.
16600   * - _previewUrl_ `[string]`: The preview source url of the media item to display in the media list.
16601   * - _id_ `[number]`: The WordPress id of the media item.
16602   * - _sourceId_ `[number|string]`: The id of the media item from external source.
16603   * - _alt_ `[string]`: The alt text of the media item.
16604   * - _caption_ `[string]`: The caption of the media item.
16605   *
16606   * @param    {InserterMediaCategory}                                  category                       The inserter media category to register.
16607   *
16608   * @example
16609   * ```js
16610   *
16611   * wp.data.dispatch('core/block-editor').registerInserterMediaCategory( {
16612   *      name: 'openverse',
16613   *      labels: {
16614   *          name: 'Openverse',
16615   *          search_items: 'Search Openverse',
16616   *      },
16617   *      mediaType: 'image',
16618   *      async fetch( query = {} ) {
16619   *          const defaultArgs = {
16620   *              mature: false,
16621   *              excluded_source: 'flickr,inaturalist,wikimedia',
16622   *              license: 'pdm,cc0',
16623   *          };
16624   *          const finalQuery = { ...query, ...defaultArgs };
16625   *          // Sometimes you might need to map the supported request params according to `InserterMediaRequest`.
16626   *          // interface. In this example the `search` query param is named `q`.
16627   *          const mapFromInserterMediaRequest = {
16628   *              per_page: 'page_size',
16629   *              search: 'q',
16630   *          };
16631   *          const url = new URL( 'https://api.openverse.org/v1/images/' );
16632   *          Object.entries( finalQuery ).forEach( ( [ key, value ] ) => {
16633   *              const queryKey = mapFromInserterMediaRequest[ key ] || key;
16634   *              url.searchParams.set( queryKey, value );
16635   *          } );
16636   *          const response = await window.fetch( url, {
16637   *              headers: {
16638   *                  'User-Agent': 'WordPress/inserter-media-fetch',
16639   *              },
16640   *          } );
16641   *          const jsonResponse = await response.json();
16642   *          const results = jsonResponse.results;
16643   *          return results.map( ( result ) => ( {
16644   *              ...result,
16645   *              // If your response result includes an `id` prop that you want to access later, it should
16646   *              // be mapped to `InserterMediaItem`'s `sourceId` prop. This can be useful if you provide
16647   *              // a report URL getter.
16648   *              // Additionally you should always clear the `id` value of your response results because
16649   *              // it is used to identify WordPress media items.
16650   *              sourceId: result.id,
16651   *              id: undefined,
16652   *              caption: result.caption,
16653   *              previewUrl: result.thumbnail,
16654   *          } ) );
16655   *      },
16656   *      getReportUrl: ( { sourceId } ) =>
16657   *          `https://wordpress.org/openverse/image/${ sourceId }/report/`,
16658   *      isExternalResource: true,
16659   * } );
16660   * ```
16661   *
16662   * @typedef {Object} InserterMediaCategory Interface for inserter media category.
16663   * @property {string}                                                 name                           The name of the media category, that should be unique among all media categories.
16664   * @property {Object}                                                 labels                         Labels for the media category.
16665   * @property {string}                                                 labels.name                    General name of the media category. It's used in the inserter media items list.
16666   * @property {string}                                                 [labels.search_items='Search'] Label for searching items. Default is ‘Search Posts’ / ‘Search Pages’.
16667   * @property {('image'|'audio'|'video')}                              mediaType                      The media type of the media category.
16668   * @property {(InserterMediaRequest) => Promise<InserterMediaItem[]>} fetch                          The function to fetch media items for the category.
16669   * @property {(InserterMediaItem) => string}                          [getReportUrl]                 If the media category supports reporting media items, this function should return
16670   *                                                                                                   the report url for the media item. It accepts the `InserterMediaItem` as an argument.
16671   * @property {boolean}                                                [isExternalResource]           If the media category is an external resource, this should be set to true.
16672   *                                                                                                   This is used to avoid making a request to the external resource when the user
16673   */
16674  const registerInserterMediaCategory = category => ({
16675    select,
16676    dispatch
16677  }) => {
16678    if (!category || typeof category !== 'object') {
16679      console.error('Category should be an `InserterMediaCategory` object.');
16680      return;
16681    }
16682    if (!category.name) {
16683      console.error('Category should have a `name` that should be unique among all media categories.');
16684      return;
16685    }
16686    if (!category.labels?.name) {
16687      console.error('Category should have a `labels.name`.');
16688      return;
16689    }
16690    if (!['image', 'audio', 'video'].includes(category.mediaType)) {
16691      console.error('Category should have `mediaType` property that is one of `image|audio|video`.');
16692      return;
16693    }
16694    if (!category.fetch || typeof category.fetch !== 'function') {
16695      console.error('Category should have a `fetch` function defined with the following signature `(InserterMediaRequest) => Promise<InserterMediaItem[]>`.');
16696      return;
16697    }
16698    const registeredInserterMediaCategories = select.getRegisteredInserterMediaCategories();
16699    if (registeredInserterMediaCategories.some(({
16700      name
16701    }) => name === category.name)) {
16702      console.error(`A category is already registered with the same name: "$category.name}".`);
16703      return;
16704    }
16705    if (registeredInserterMediaCategories.some(({
16706      labels: {
16707        name
16708      } = {}
16709    }) => name === category.labels?.name)) {
16710      console.error(`A category is already registered with the same labels.name: "$category.labels.name}".`);
16711      return;
16712    }
16713    // `inserterMediaCategories` is a private block editor setting, which means it cannot
16714    // be updated through the public `updateSettings` action. We preserve this setting as
16715    // private, so extenders can only add new inserter media categories and don't have any
16716    // control over the core media categories.
16717    dispatch({
16718      type: 'REGISTER_INSERTER_MEDIA_CATEGORY',
16719      category: {
16720        ...category,
16721        isExternalResource: true
16722      }
16723    });
16724  };
16725  
16726  /**
16727   * @typedef {import('../components/block-editing-mode').BlockEditingMode} BlockEditingMode
16728   */
16729  
16730  /**
16731   * Sets the block editing mode for a given block.
16732   *
16733   * @see useBlockEditingMode
16734   *
16735   * @param {string}           clientId The block client ID, or `''` for the root container.
16736   * @param {BlockEditingMode} mode     The block editing mode. One of `'disabled'`,
16737   *                                    `'contentOnly'`, or `'default'`.
16738   *
16739   * @return {Object} Action object.
16740   */
16741  function setBlockEditingMode(clientId = '', mode) {
16742    return {
16743      type: 'SET_BLOCK_EDITING_MODE',
16744      clientId,
16745      mode
16746    };
16747  }
16748  
16749  /**
16750   * Clears the block editing mode for a given block.
16751   *
16752   * @see useBlockEditingMode
16753   *
16754   * @param {string} clientId The block client ID, or `''` for the root container.
16755   *
16756   * @return {Object} Action object.
16757   */
16758  function unsetBlockEditingMode(clientId = '') {
16759    return {
16760      type: 'UNSET_BLOCK_EDITING_MODE',
16761      clientId
16762    };
16763  }
16764  
16765  ;// ./node_modules/@wordpress/block-editor/build-module/store/index.js
16766  /**
16767   * WordPress dependencies
16768   */
16769  
16770  
16771  /**
16772   * Internal dependencies
16773   */
16774  
16775  
16776  
16777  
16778  
16779  
16780  
16781  
16782  /**
16783   * Block editor data store configuration.
16784   *
16785   * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/data/README.md#registerStore
16786   */
16787  const storeConfig = {
16788    reducer: reducer,
16789    selectors: selectors_namespaceObject,
16790    actions: actions_namespaceObject
16791  };
16792  
16793  /**
16794   * Store definition for the block editor namespace.
16795   *
16796   * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/data/README.md#createReduxStore
16797   */
16798  const store = (0,external_wp_data_namespaceObject.createReduxStore)(STORE_NAME, {
16799    ...storeConfig,
16800    persist: ['preferences']
16801  });
16802  
16803  // We will be able to use the `register` function once we switch
16804  // the "preferences" persistence to use the new preferences package.
16805  const registeredStore = (0,external_wp_data_namespaceObject.registerStore)(STORE_NAME, {
16806    ...storeConfig,
16807    persist: ['preferences']
16808  });
16809  unlock(registeredStore).registerPrivateActions(private_actions_namespaceObject);
16810  unlock(registeredStore).registerPrivateSelectors(private_selectors_namespaceObject);
16811  
16812  // TODO: Remove once we switch to the `register` function (see above).
16813  //
16814  // Until then, private functions also need to be attached to the original
16815  // `store` descriptor in order to avoid unit tests failing, which could happen
16816  // when tests create new registries in which they register stores.
16817  //
16818  // @see https://github.com/WordPress/gutenberg/pull/51145#discussion_r1239999590
16819  unlock(store).registerPrivateActions(private_actions_namespaceObject);
16820  unlock(store).registerPrivateSelectors(private_selectors_namespaceObject);
16821  
16822  ;// ./node_modules/@wordpress/block-editor/build-module/components/use-settings/index.js
16823  /**
16824   * WordPress dependencies
16825   */
16826  
16827  
16828  
16829  /**
16830   * Internal dependencies
16831   */
16832  
16833  
16834  
16835  
16836  /**
16837   * Hook that retrieves the given settings for the block instance in use.
16838   *
16839   * It looks up the settings first in the block instance hierarchy.
16840   * If none are found, it'll look them up in the block editor settings.
16841   *
16842   * @param {string[]} paths The paths to the settings.
16843   * @return {any[]} Returns the values defined for the settings.
16844   * @example
16845   * ```js
16846   * const [ fixed, sticky ] = useSettings( 'position.fixed', 'position.sticky' );
16847   * ```
16848   */
16849  function use_settings_useSettings(...paths) {
16850    const {
16851      clientId = null
16852    } = useBlockEditContext();
16853    return (0,external_wp_data_namespaceObject.useSelect)(select => unlock(select(store)).getBlockSettings(clientId, ...paths), [clientId, ...paths]);
16854  }
16855  
16856  /**
16857   * Hook that retrieves the given setting for the block instance in use.
16858   *
16859   * It looks up the setting first in the block instance hierarchy.
16860   * If none is found, it'll look it up in the block editor settings.
16861   *
16862   * @deprecated 6.5.0 Use useSettings instead.
16863   *
16864   * @param {string} path The path to the setting.
16865   * @return {any} Returns the value defined for the setting.
16866   * @example
16867   * ```js
16868   * const isEnabled = useSetting( 'typography.dropCap' );
16869   * ```
16870   */
16871  function useSetting(path) {
16872    external_wp_deprecated_default()('wp.blockEditor.useSetting', {
16873      since: '6.5',
16874      alternative: 'wp.blockEditor.useSettings',
16875      note: 'The new useSettings function can retrieve multiple settings at once, with better performance.'
16876    });
16877    const [value] = use_settings_useSettings(path);
16878    return value;
16879  }
16880  
16881  ;// external ["wp","styleEngine"]
16882  const external_wp_styleEngine_namespaceObject = window["wp"]["styleEngine"];
16883  ;// ./node_modules/@wordpress/block-editor/build-module/components/font-sizes/fluid-utils.js
16884  /**
16885   * The fluid utilities must match the backend equivalent.
16886   * See: gutenberg_get_typography_font_size_value() in lib/block-supports/typography.php
16887   * ---------------------------------------------------------------
16888   */
16889  
16890  // Defaults.
16891  const DEFAULT_MAXIMUM_VIEWPORT_WIDTH = '1600px';
16892  const DEFAULT_MINIMUM_VIEWPORT_WIDTH = '320px';
16893  const DEFAULT_SCALE_FACTOR = 1;
16894  const DEFAULT_MINIMUM_FONT_SIZE_FACTOR_MIN = 0.25;
16895  const DEFAULT_MINIMUM_FONT_SIZE_FACTOR_MAX = 0.75;
16896  const DEFAULT_MINIMUM_FONT_SIZE_LIMIT = '14px';
16897  
16898  /**
16899   * Computes a fluid font-size value that uses clamp(). A minimum and maximum
16900   * font size OR a single font size can be specified.
16901   *
16902   * If a single font size is specified, it is scaled up and down using a logarithmic scale.
16903   *
16904   * @example
16905   * ```js
16906   * // Calculate fluid font-size value from a minimum and maximum value.
16907   * const fontSize = getComputedFluidTypographyValue( {
16908   *     minimumFontSize: '20px',
16909   *     maximumFontSize: '45px'
16910   * } );
16911   * // Calculate fluid font-size value from a single font size.
16912   * const fontSize = getComputedFluidTypographyValue( {
16913   *     fontSize: '30px',
16914   * } );
16915   * ```
16916   *
16917   * @param {Object}        args
16918   * @param {?string}       args.minimumViewportWidth Minimum viewport size from which type will have fluidity. Optional if fontSize is specified.
16919   * @param {?string}       args.maximumViewportWidth Maximum size up to which type will have fluidity. Optional if fontSize is specified.
16920   * @param {string|number} [args.fontSize]           Size to derive maximumFontSize and minimumFontSize from, if necessary. Optional if minimumFontSize and maximumFontSize are specified.
16921   * @param {?string}       args.maximumFontSize      Maximum font size for any clamp() calculation. Optional.
16922   * @param {?string}       args.minimumFontSize      Minimum font size for any clamp() calculation. Optional.
16923   * @param {?number}       args.scaleFactor          A scale factor to determine how fast a font scales within boundaries. Optional.
16924   * @param {?string}       args.minimumFontSizeLimit The smallest a calculated font size may be. Optional.
16925   *
16926   * @return {string|null} A font-size value using clamp().
16927   */
16928  function getComputedFluidTypographyValue({
16929    minimumFontSize,
16930    maximumFontSize,
16931    fontSize,
16932    minimumViewportWidth = DEFAULT_MINIMUM_VIEWPORT_WIDTH,
16933    maximumViewportWidth = DEFAULT_MAXIMUM_VIEWPORT_WIDTH,
16934    scaleFactor = DEFAULT_SCALE_FACTOR,
16935    minimumFontSizeLimit
16936  }) {
16937    // Validate incoming settings and set defaults.
16938    minimumFontSizeLimit = !!getTypographyValueAndUnit(minimumFontSizeLimit) ? minimumFontSizeLimit : DEFAULT_MINIMUM_FONT_SIZE_LIMIT;
16939  
16940    /*
16941     * Calculates missing minimumFontSize and maximumFontSize from
16942     * defaultFontSize if provided.
16943     */
16944    if (fontSize) {
16945      // Parses default font size.
16946      const fontSizeParsed = getTypographyValueAndUnit(fontSize);
16947  
16948      // Protect against invalid units.
16949      if (!fontSizeParsed?.unit) {
16950        return null;
16951      }
16952  
16953      // Parses the minimum font size limit, so we can perform checks using it.
16954      const minimumFontSizeLimitParsed = getTypographyValueAndUnit(minimumFontSizeLimit, {
16955        coerceTo: fontSizeParsed.unit
16956      });
16957  
16958      // Don't enforce minimum font size if a font size has explicitly set a min and max value.
16959      if (!!minimumFontSizeLimitParsed?.value && !minimumFontSize && !maximumFontSize) {
16960        /*
16961         * If a minimum size was not passed to this function
16962         * and the user-defined font size is lower than $minimum_font_size_limit,
16963         * do not calculate a fluid value.
16964         */
16965        if (fontSizeParsed?.value <= minimumFontSizeLimitParsed?.value) {
16966          return null;
16967        }
16968      }
16969  
16970      // If no fluid max font size is available use the incoming value.
16971      if (!maximumFontSize) {
16972        maximumFontSize = `$fontSizeParsed.value}$fontSizeParsed.unit}`;
16973      }
16974  
16975      /*
16976       * If no minimumFontSize is provided, create one using
16977       * the given font size multiplied by the min font size scale factor.
16978       */
16979      if (!minimumFontSize) {
16980        const fontSizeValueInPx = fontSizeParsed.unit === 'px' ? fontSizeParsed.value : fontSizeParsed.value * 16;
16981  
16982        /*
16983         * The scale factor is a multiplier that affects how quickly the curve will move towards the minimum,
16984         * that is, how quickly the size factor reaches 0 given increasing font size values.
16985         * For a - b * log2(), lower values of b will make the curve move towards the minimum faster.
16986         * The scale factor is constrained between min and max values.
16987         */
16988        const minimumFontSizeFactor = Math.min(Math.max(1 - 0.075 * Math.log2(fontSizeValueInPx), DEFAULT_MINIMUM_FONT_SIZE_FACTOR_MIN), DEFAULT_MINIMUM_FONT_SIZE_FACTOR_MAX);
16989  
16990        // Calculates the minimum font size.
16991        const calculatedMinimumFontSize = roundToPrecision(fontSizeParsed.value * minimumFontSizeFactor, 3);
16992  
16993        // Only use calculated min font size if it's > $minimum_font_size_limit value.
16994        if (!!minimumFontSizeLimitParsed?.value && calculatedMinimumFontSize < minimumFontSizeLimitParsed?.value) {
16995          minimumFontSize = `$minimumFontSizeLimitParsed.value}$minimumFontSizeLimitParsed.unit}`;
16996        } else {
16997          minimumFontSize = `$calculatedMinimumFontSize}$fontSizeParsed.unit}`;
16998        }
16999      }
17000    }
17001  
17002    // Grab the minimum font size and normalize it in order to use the value for calculations.
17003    const minimumFontSizeParsed = getTypographyValueAndUnit(minimumFontSize);
17004  
17005    // We get a 'preferred' unit to keep units consistent when calculating,
17006    // otherwise the result will not be accurate.
17007    const fontSizeUnit = minimumFontSizeParsed?.unit || 'rem';
17008  
17009    // Grabs the maximum font size and normalize it in order to use the value for calculations.
17010    const maximumFontSizeParsed = getTypographyValueAndUnit(maximumFontSize, {
17011      coerceTo: fontSizeUnit
17012    });
17013  
17014    // Checks for mandatory min and max sizes, and protects against unsupported units.
17015    if (!minimumFontSizeParsed || !maximumFontSizeParsed) {
17016      return null;
17017    }
17018  
17019    // Uses rem for accessible fluid target font scaling.
17020    const minimumFontSizeRem = getTypographyValueAndUnit(minimumFontSize, {
17021      coerceTo: 'rem'
17022    });
17023  
17024    // Viewport widths defined for fluid typography. Normalize units
17025    const maximumViewportWidthParsed = getTypographyValueAndUnit(maximumViewportWidth, {
17026      coerceTo: fontSizeUnit
17027    });
17028    const minimumViewportWidthParsed = getTypographyValueAndUnit(minimumViewportWidth, {
17029      coerceTo: fontSizeUnit
17030    });
17031  
17032    // Protect against unsupported units.
17033    if (!maximumViewportWidthParsed || !minimumViewportWidthParsed || !minimumFontSizeRem) {
17034      return null;
17035    }
17036  
17037    // Calculates the linear factor denominator. If it's 0, we cannot calculate a fluid value.
17038    const linearDenominator = maximumViewportWidthParsed.value - minimumViewportWidthParsed.value;
17039    if (!linearDenominator) {
17040      return null;
17041    }
17042  
17043    // Build CSS rule.
17044    // Borrowed from https://websemantics.uk/tools/responsive-font-calculator/.
17045    const minViewportWidthOffsetValue = roundToPrecision(minimumViewportWidthParsed.value / 100, 3);
17046    const viewportWidthOffset = roundToPrecision(minViewportWidthOffsetValue, 3) + fontSizeUnit;
17047    const linearFactor = 100 * ((maximumFontSizeParsed.value - minimumFontSizeParsed.value) / linearDenominator);
17048    const linearFactorScaled = roundToPrecision((linearFactor || 1) * scaleFactor, 3);
17049    const fluidTargetFontSize = `$minimumFontSizeRem.value}$minimumFontSizeRem.unit} + ((1vw - $viewportWidthOffset}) * $linearFactorScaled})`;
17050    return `clamp($minimumFontSize}, $fluidTargetFontSize}, $maximumFontSize})`;
17051  }
17052  
17053  /**
17054   * Internal method that checks a string for a unit and value and returns an array consisting of `'value'` and `'unit'`, e.g., [ '42', 'rem' ].
17055   * A raw font size of `value + unit` is expected. If the value is an integer, it will convert to `value + 'px'`.
17056   *
17057   * @param {string|number}    rawValue Raw size value from theme.json.
17058   * @param {Object|undefined} options  Calculation options.
17059   *
17060   * @return {{ unit: string, value: number }|null} An object consisting of `'value'` and `'unit'` properties.
17061   */
17062  function getTypographyValueAndUnit(rawValue, options = {}) {
17063    if (typeof rawValue !== 'string' && typeof rawValue !== 'number') {
17064      return null;
17065    }
17066  
17067    // Converts numeric values to pixel values by default.
17068    if (isFinite(rawValue)) {
17069      rawValue = `$rawValue}px`;
17070    }
17071    const {
17072      coerceTo,
17073      rootSizeValue,
17074      acceptableUnits
17075    } = {
17076      coerceTo: '',
17077      // Default browser font size. Later we could inject some JS to compute this `getComputedStyle( document.querySelector( "html" ) ).fontSize`.
17078      rootSizeValue: 16,
17079      acceptableUnits: ['rem', 'px', 'em'],
17080      ...options
17081    };
17082    const acceptableUnitsGroup = acceptableUnits?.join('|');
17083    const regexUnits = new RegExp(`^(\\d*\\.?\\d+)($acceptableUnitsGroup}){1,1}$`);
17084    const matches = rawValue.match(regexUnits);
17085  
17086    // We need a number value and a unit.
17087    if (!matches || matches.length < 3) {
17088      return null;
17089    }
17090    let [, value, unit] = matches;
17091    let returnValue = parseFloat(value);
17092    if ('px' === coerceTo && ('em' === unit || 'rem' === unit)) {
17093      returnValue = returnValue * rootSizeValue;
17094      unit = coerceTo;
17095    }
17096    if ('px' === unit && ('em' === coerceTo || 'rem' === coerceTo)) {
17097      returnValue = returnValue / rootSizeValue;
17098      unit = coerceTo;
17099    }
17100  
17101    /*
17102     * No calculation is required if swapping between em and rem yet,
17103     * since we assume a root size value. Later we might like to differentiate between
17104     * :root font size (rem) and parent element font size (em) relativity.
17105     */
17106    if (('em' === coerceTo || 'rem' === coerceTo) && ('em' === unit || 'rem' === unit)) {
17107      unit = coerceTo;
17108    }
17109    return {
17110      value: roundToPrecision(returnValue, 3),
17111      unit
17112    };
17113  }
17114  
17115  /**
17116   * Returns a value rounded to defined precision.
17117   * Returns `undefined` if the value is not a valid finite number.
17118   *
17119   * @param {number} value  Raw value.
17120   * @param {number} digits The number of digits to appear after the decimal point
17121   *
17122   * @return {number|undefined} Value rounded to standard precision.
17123   */
17124  function roundToPrecision(value, digits = 3) {
17125    const base = Math.pow(10, digits);
17126    return Number.isFinite(value) ? parseFloat(Math.round(value * base) / base) : undefined;
17127  }
17128  
17129  ;// ./node_modules/@wordpress/block-editor/build-module/utils/format-font-style.js
17130  /**
17131   * WordPress dependencies
17132   */
17133  
17134  
17135  /**
17136   * Formats font styles to human readable names.
17137   *
17138   * @param {string} fontStyle font style string
17139   * @return {Object} new object with formatted font style
17140   */
17141  function formatFontStyle(fontStyle) {
17142    if (!fontStyle) {
17143      return {};
17144    }
17145    if (typeof fontStyle === 'object') {
17146      return fontStyle;
17147    }
17148    let name;
17149    switch (fontStyle) {
17150      case 'normal':
17151        name = (0,external_wp_i18n_namespaceObject._x)('Regular', 'font style');
17152        break;
17153      case 'italic':
17154        name = (0,external_wp_i18n_namespaceObject._x)('Italic', 'font style');
17155        break;
17156      case 'oblique':
17157        name = (0,external_wp_i18n_namespaceObject._x)('Oblique', 'font style');
17158        break;
17159      default:
17160        name = fontStyle;
17161        break;
17162    }
17163    return {
17164      name,
17165      value: fontStyle
17166    };
17167  }
17168  
17169  ;// ./node_modules/@wordpress/block-editor/build-module/utils/format-font-weight.js
17170  /**
17171   * WordPress dependencies
17172   */
17173  
17174  
17175  /**
17176   * Formats font weights to human readable names.
17177   *
17178   * @param {string} fontWeight font weight string
17179   * @return {Object} new object with formatted font weight
17180   */
17181  function formatFontWeight(fontWeight) {
17182    if (!fontWeight) {
17183      return {};
17184    }
17185    if (typeof fontWeight === 'object') {
17186      return fontWeight;
17187    }
17188    let name;
17189    switch (fontWeight) {
17190      case 'normal':
17191      case '400':
17192        name = (0,external_wp_i18n_namespaceObject._x)('Regular', 'font weight');
17193        break;
17194      case 'bold':
17195      case '700':
17196        name = (0,external_wp_i18n_namespaceObject._x)('Bold', 'font weight');
17197        break;
17198      case '100':
17199        name = (0,external_wp_i18n_namespaceObject._x)('Thin', 'font weight');
17200        break;
17201      case '200':
17202        name = (0,external_wp_i18n_namespaceObject._x)('Extra Light', 'font weight');
17203        break;
17204      case '300':
17205        name = (0,external_wp_i18n_namespaceObject._x)('Light', 'font weight');
17206        break;
17207      case '500':
17208        name = (0,external_wp_i18n_namespaceObject._x)('Medium', 'font weight');
17209        break;
17210      case '600':
17211        name = (0,external_wp_i18n_namespaceObject._x)('Semi Bold', 'font weight');
17212        break;
17213      case '800':
17214        name = (0,external_wp_i18n_namespaceObject._x)('Extra Bold', 'font weight');
17215        break;
17216      case '900':
17217        name = (0,external_wp_i18n_namespaceObject._x)('Black', 'font weight');
17218        break;
17219      case '1000':
17220        name = (0,external_wp_i18n_namespaceObject._x)('Extra Black', 'font weight');
17221        break;
17222      default:
17223        name = fontWeight;
17224        break;
17225    }
17226    return {
17227      name,
17228      value: fontWeight
17229    };
17230  }
17231  
17232  ;// ./node_modules/@wordpress/block-editor/build-module/utils/get-font-styles-and-weights.js
17233  /**
17234   * WordPress dependencies
17235   */
17236  
17237  
17238  /**
17239   * Internal dependencies
17240   */
17241  
17242  
17243  const FONT_STYLES = [{
17244    name: (0,external_wp_i18n_namespaceObject._x)('Regular', 'font style'),
17245    value: 'normal'
17246  }, {
17247    name: (0,external_wp_i18n_namespaceObject._x)('Italic', 'font style'),
17248    value: 'italic'
17249  }];
17250  const FONT_WEIGHTS = [{
17251    name: (0,external_wp_i18n_namespaceObject._x)('Thin', 'font weight'),
17252    value: '100'
17253  }, {
17254    name: (0,external_wp_i18n_namespaceObject._x)('Extra Light', 'font weight'),
17255    value: '200'
17256  }, {
17257    name: (0,external_wp_i18n_namespaceObject._x)('Light', 'font weight'),
17258    value: '300'
17259  }, {
17260    name: (0,external_wp_i18n_namespaceObject._x)('Regular', 'font weight'),
17261    value: '400'
17262  }, {
17263    name: (0,external_wp_i18n_namespaceObject._x)('Medium', 'font weight'),
17264    value: '500'
17265  }, {
17266    name: (0,external_wp_i18n_namespaceObject._x)('Semi Bold', 'font weight'),
17267    value: '600'
17268  }, {
17269    name: (0,external_wp_i18n_namespaceObject._x)('Bold', 'font weight'),
17270    value: '700'
17271  }, {
17272    name: (0,external_wp_i18n_namespaceObject._x)('Extra Bold', 'font weight'),
17273    value: '800'
17274  }, {
17275    name: (0,external_wp_i18n_namespaceObject._x)('Black', 'font weight'),
17276    value: '900'
17277  }, {
17278    name: (0,external_wp_i18n_namespaceObject._x)('Extra Black', 'font weight'),
17279    value: '1000'
17280  }];
17281  
17282  /**
17283   * Builds a list of font style and weight options based on font family faces.
17284   * Defaults to the standard font styles and weights if no font family faces are provided.
17285   *
17286   * @param {Array} fontFamilyFaces font family faces array
17287   * @return {Object} new object with combined and separated font style and weight properties
17288   */
17289  function getFontStylesAndWeights(fontFamilyFaces) {
17290    let fontStyles = [];
17291    let fontWeights = [];
17292    const combinedStyleAndWeightOptions = [];
17293    const isSystemFont = !fontFamilyFaces || fontFamilyFaces?.length === 0;
17294    let isVariableFont = false;
17295    fontFamilyFaces?.forEach(face => {
17296      // Check for variable font by looking for a space in the font weight value. e.g. "100 900"
17297      if ('string' === typeof face.fontWeight && /\s/.test(face.fontWeight.trim())) {
17298        isVariableFont = true;
17299  
17300        // Find font weight start and end values.
17301        let [startValue, endValue] = face.fontWeight.split(' ');
17302        startValue = parseInt(startValue.slice(0, 1));
17303        if (endValue === '1000') {
17304          endValue = 10;
17305        } else {
17306          endValue = parseInt(endValue.slice(0, 1));
17307        }
17308  
17309        // Create font weight options for available variable weights.
17310        for (let i = startValue; i <= endValue; i++) {
17311          const fontWeightValue = `$i.toString()}00`;
17312          if (!fontWeights.some(weight => weight.value === fontWeightValue)) {
17313            fontWeights.push(formatFontWeight(fontWeightValue));
17314          }
17315        }
17316      }
17317  
17318      // Format font style and weight values.
17319      const fontWeight = formatFontWeight('number' === typeof face.fontWeight ? face.fontWeight.toString() : face.fontWeight);
17320      const fontStyle = formatFontStyle(face.fontStyle);
17321  
17322      // Create font style and font weight lists without duplicates.
17323      if (fontStyle && Object.keys(fontStyle).length) {
17324        if (!fontStyles.some(style => style.value === fontStyle.value)) {
17325          fontStyles.push(fontStyle);
17326        }
17327      }
17328      if (fontWeight && Object.keys(fontWeight).length) {
17329        if (!fontWeights.some(weight => weight.value === fontWeight.value)) {
17330          if (!isVariableFont) {
17331            fontWeights.push(fontWeight);
17332          }
17333        }
17334      }
17335    });
17336  
17337    // If there is no font weight of 600 or above, then include faux bold as an option.
17338    if (!fontWeights.some(weight => weight.value >= '600')) {
17339      fontWeights.push({
17340        name: (0,external_wp_i18n_namespaceObject._x)('Bold', 'font weight'),
17341        value: '700'
17342      });
17343    }
17344  
17345    // If there is no italic font style, then include faux italic as an option.
17346    if (!fontStyles.some(style => style.value === 'italic')) {
17347      fontStyles.push({
17348        name: (0,external_wp_i18n_namespaceObject._x)('Italic', 'font style'),
17349        value: 'italic'
17350      });
17351    }
17352  
17353    // Use default font styles and weights for system fonts.
17354    if (isSystemFont) {
17355      fontStyles = FONT_STYLES;
17356      fontWeights = FONT_WEIGHTS;
17357    }
17358  
17359    // Use default styles and weights if there are no available styles or weights from the provided font faces.
17360    fontStyles = fontStyles.length === 0 ? FONT_STYLES : fontStyles;
17361    fontWeights = fontWeights.length === 0 ? FONT_WEIGHTS : fontWeights;
17362  
17363    // Generate combined font style and weight options for available fonts.
17364    fontStyles.forEach(({
17365      name: styleName,
17366      value: styleValue
17367    }) => {
17368      fontWeights.forEach(({
17369        name: weightName,
17370        value: weightValue
17371      }) => {
17372        const optionName = styleValue === 'normal' ? weightName : (0,external_wp_i18n_namespaceObject.sprintf)(/* translators: 1: Font weight name. 2: Font style name. */
17373        (0,external_wp_i18n_namespaceObject._x)('%1$s %2$s', 'font'), weightName, styleName);
17374        combinedStyleAndWeightOptions.push({
17375          key: `$styleValue}-$weightValue}`,
17376          name: optionName,
17377          style: {
17378            fontStyle: styleValue,
17379            fontWeight: weightValue
17380          }
17381        });
17382      });
17383    });
17384    return {
17385      fontStyles,
17386      fontWeights,
17387      combinedStyleAndWeightOptions,
17388      isSystemFont,
17389      isVariableFont
17390    };
17391  }
17392  
17393  ;// ./node_modules/@wordpress/block-editor/build-module/components/global-styles/typography-utils.js
17394  /**
17395   * The fluid utilities must match the backend equivalent.
17396   * See: gutenberg_get_typography_font_size_value() in lib/block-supports/typography.php
17397   * ---------------------------------------------------------------
17398   */
17399  
17400  /**
17401   * Internal dependencies
17402   */
17403  
17404  
17405  
17406  /**
17407   * @typedef {Object} FluidPreset
17408   * @property {string|undefined}  max A maximum font size value.
17409   * @property {?string|undefined} min A minimum font size value.
17410   */
17411  
17412  /**
17413   * @typedef {Object} Preset
17414   * @property {?string|?number}               size  A default font size.
17415   * @property {string}                        name  A font size name, displayed in the UI.
17416   * @property {string}                        slug  A font size slug
17417   * @property {boolean|FluidPreset|undefined} fluid Specifies the minimum and maximum font size value of a fluid font size.
17418   */
17419  
17420  /**
17421   * @typedef {Object} TypographySettings
17422   * @property {?string} minViewportWidth  Minimum viewport size from which type will have fluidity. Optional if size is specified.
17423   * @property {?string} maxViewportWidth  Maximum size up to which type will have fluidity. Optional if size is specified.
17424   * @property {?number} scaleFactor       A scale factor to determine how fast a font scales within boundaries. Optional.
17425   * @property {?number} minFontSizeFactor How much to scale defaultFontSize by to derive minimumFontSize. Optional.
17426   * @property {?string} minFontSize       The smallest a calculated font size may be. Optional.
17427   */
17428  
17429  /**
17430   * Returns a font-size value based on a given font-size preset.
17431   * Takes into account fluid typography parameters and attempts to return a css formula depending on available, valid values.
17432   *
17433   * The Core PHP equivalent is wp_get_typography_font_size_value().
17434   *
17435   * @param {Preset}                     preset
17436   * @param {Object}                     settings
17437   * @param {boolean|TypographySettings} settings.typography.fluid  Whether fluid typography is enabled, and, optionally, fluid font size options.
17438   * @param {?Object}                    settings.typography.layout Layout options.
17439   *
17440   * @return {string|*} A font-size value or the value of preset.size.
17441   */
17442  function getTypographyFontSizeValue(preset, settings) {
17443    const {
17444      size: defaultSize
17445    } = preset;
17446  
17447    /*
17448     * Catch falsy values and 0/'0'. Fluid calculations cannot be performed on `0`.
17449     * Also return early when a preset font size explicitly disables fluid typography with `false`.
17450     */
17451    if (!defaultSize || '0' === defaultSize || false === preset?.fluid) {
17452      return defaultSize;
17453    }
17454  
17455    /*
17456     * Return early when fluid typography is disabled in the settings, and there
17457     * are no local settings to enable it for the individual preset.
17458     *
17459     * If this condition isn't met, either the settings or individual preset settings
17460     * have enabled fluid typography.
17461     */
17462    if (!isFluidTypographyEnabled(settings?.typography) && !isFluidTypographyEnabled(preset)) {
17463      return defaultSize;
17464    }
17465    let fluidTypographySettings = getFluidTypographyOptionsFromSettings(settings);
17466    fluidTypographySettings = typeof fluidTypographySettings?.fluid === 'object' ? fluidTypographySettings?.fluid : {};
17467    const fluidFontSizeValue = getComputedFluidTypographyValue({
17468      minimumFontSize: preset?.fluid?.min,
17469      maximumFontSize: preset?.fluid?.max,
17470      fontSize: defaultSize,
17471      minimumFontSizeLimit: fluidTypographySettings?.minFontSize,
17472      maximumViewportWidth: fluidTypographySettings?.maxViewportWidth,
17473      minimumViewportWidth: fluidTypographySettings?.minViewportWidth
17474    });
17475    if (!!fluidFontSizeValue) {
17476      return fluidFontSizeValue;
17477    }
17478    return defaultSize;
17479  }
17480  function isFluidTypographyEnabled(typographySettings) {
17481    const fluidSettings = typographySettings?.fluid;
17482    return true === fluidSettings || fluidSettings && typeof fluidSettings === 'object' && Object.keys(fluidSettings).length > 0;
17483  }
17484  
17485  /**
17486   * Returns fluid typography settings from theme.json setting object.
17487   *
17488   * @param {Object} settings            Theme.json settings
17489   * @param {Object} settings.typography Theme.json typography settings
17490   * @param {Object} settings.layout     Theme.json layout settings
17491   * @return {TypographySettings} Fluid typography settings
17492   */
17493  function getFluidTypographyOptionsFromSettings(settings) {
17494    const typographySettings = settings?.typography;
17495    const layoutSettings = settings?.layout;
17496    const defaultMaxViewportWidth = getTypographyValueAndUnit(layoutSettings?.wideSize) ? layoutSettings?.wideSize : null;
17497    return isFluidTypographyEnabled(typographySettings) && defaultMaxViewportWidth ? {
17498      fluid: {
17499        maxViewportWidth: defaultMaxViewportWidth,
17500        ...typographySettings.fluid
17501      }
17502    } : {
17503      fluid: typographySettings?.fluid
17504    };
17505  }
17506  
17507  /**
17508   * Returns an object of merged font families and the font faces from the selected font family
17509   * based on the theme.json settings object and the currently selected font family.
17510   *
17511   * @param {Object} settings           Theme.json settings.
17512   * @param {string} selectedFontFamily Decoded font family string.
17513   * @return {Object} Merged font families and font faces from the selected font family.
17514   */
17515  function getMergedFontFamiliesAndFontFamilyFaces(settings, selectedFontFamily) {
17516    var _fontFamilies$find$fo;
17517    const fontFamiliesFromSettings = settings?.typography?.fontFamilies;
17518    const fontFamilies = ['default', 'theme', 'custom'].flatMap(key => {
17519      var _fontFamiliesFromSett;
17520      return (_fontFamiliesFromSett = fontFamiliesFromSettings?.[key]) !== null && _fontFamiliesFromSett !== void 0 ? _fontFamiliesFromSett : [];
17521    });
17522    const fontFamilyFaces = (_fontFamilies$find$fo = fontFamilies.find(family => family.fontFamily === selectedFontFamily)?.fontFace) !== null && _fontFamilies$find$fo !== void 0 ? _fontFamilies$find$fo : [];
17523    return {
17524      fontFamilies,
17525      fontFamilyFaces
17526    };
17527  }
17528  
17529  /**
17530   * Returns the nearest font weight value from the available font weight list based on the new font weight.
17531   * The nearest font weight is the one with the smallest difference from the new font weight.
17532   *
17533   * @param {Array}  availableFontWeights Array of available font weights.
17534   * @param {string} newFontWeightValue   New font weight value.
17535   * @return {string} Nearest font weight.
17536   */
17537  function findNearestFontWeight(availableFontWeights, newFontWeightValue) {
17538    newFontWeightValue = 'number' === typeof newFontWeightValue ? newFontWeightValue.toString() : newFontWeightValue;
17539    if (!newFontWeightValue || typeof newFontWeightValue !== 'string') {
17540      return '';
17541    }
17542    if (!availableFontWeights || availableFontWeights.length === 0) {
17543      return newFontWeightValue;
17544    }
17545    const nearestFontWeight = availableFontWeights?.reduce((nearest, {
17546      value: fw
17547    }) => {
17548      const currentDiff = Math.abs(parseInt(fw) - parseInt(newFontWeightValue));
17549      const nearestDiff = Math.abs(parseInt(nearest) - parseInt(newFontWeightValue));
17550      return currentDiff < nearestDiff ? fw : nearest;
17551    }, availableFontWeights[0]?.value);
17552    return nearestFontWeight;
17553  }
17554  
17555  /**
17556   * Returns the nearest font style based on the new font style.
17557   * Defaults to an empty string if the new font style is not valid or available.
17558   *
17559   * @param {Array}  availableFontStyles Array of available font weights.
17560   * @param {string} newFontStyleValue   New font style value.
17561   * @return {string} Nearest font style or an empty string.
17562   */
17563  function findNearestFontStyle(availableFontStyles, newFontStyleValue) {
17564    if (typeof newFontStyleValue !== 'string' || !newFontStyleValue) {
17565      return '';
17566    }
17567    const validStyles = ['normal', 'italic', 'oblique'];
17568    if (!validStyles.includes(newFontStyleValue)) {
17569      return '';
17570    }
17571    if (!availableFontStyles || availableFontStyles.length === 0 || availableFontStyles.find(style => style.value === newFontStyleValue)) {
17572      return newFontStyleValue;
17573    }
17574    if (newFontStyleValue === 'oblique' && !availableFontStyles.find(style => style.value === 'oblique')) {
17575      return 'italic';
17576    }
17577    return '';
17578  }
17579  
17580  /**
17581   * Returns the nearest font style and weight based on the available font family faces and the new font style and weight.
17582   *
17583   * @param {Array}  fontFamilyFaces Array of available font family faces.
17584   * @param {string} fontStyle       New font style. Defaults to previous value.
17585   * @param {string} fontWeight      New font weight. Defaults to previous value.
17586   * @return {Object} Nearest font style and font weight.
17587   */
17588  function findNearestStyleAndWeight(fontFamilyFaces, fontStyle, fontWeight) {
17589    let nearestFontStyle = fontStyle;
17590    let nearestFontWeight = fontWeight;
17591    const {
17592      fontStyles,
17593      fontWeights,
17594      combinedStyleAndWeightOptions
17595    } = getFontStylesAndWeights(fontFamilyFaces);
17596  
17597    // Check if the new font style and weight are available in the font family faces.
17598    const hasFontStyle = fontStyles?.some(({
17599      value: fs
17600    }) => fs === fontStyle);
17601    const hasFontWeight = fontWeights?.some(({
17602      value: fw
17603    }) => fw?.toString() === fontWeight?.toString());
17604    if (!hasFontStyle) {
17605      /*
17606       * Default to italic if oblique is not available.
17607       * Or find the nearest font style based on the nearest font weight.
17608       */
17609      nearestFontStyle = fontStyle ? findNearestFontStyle(fontStyles, fontStyle) : combinedStyleAndWeightOptions?.find(option => option.style.fontWeight === findNearestFontWeight(fontWeights, fontWeight))?.style?.fontStyle;
17610    }
17611    if (!hasFontWeight) {
17612      /*
17613       * Find the nearest font weight based on available weights.
17614       * Or find the nearest font weight based on the nearest font style.
17615       */
17616      nearestFontWeight = fontWeight ? findNearestFontWeight(fontWeights, fontWeight) : combinedStyleAndWeightOptions?.find(option => option.style.fontStyle === (nearestFontStyle || fontStyle))?.style?.fontWeight;
17617    }
17618    return {
17619      nearestFontStyle,
17620      nearestFontWeight
17621    };
17622  }
17623  
17624  ;// ./node_modules/@wordpress/block-editor/build-module/components/global-styles/utils.js
17625  /**
17626   * External dependencies
17627   */
17628  
17629  
17630  /**
17631   * WordPress dependencies
17632   */
17633  
17634  
17635  
17636  /**
17637   * Internal dependencies
17638   */
17639  
17640  
17641  
17642  /* Supporting data. */
17643  const ROOT_BLOCK_SELECTOR = 'body';
17644  const ROOT_CSS_PROPERTIES_SELECTOR = ':root';
17645  const PRESET_METADATA = [{
17646    path: ['color', 'palette'],
17647    valueKey: 'color',
17648    cssVarInfix: 'color',
17649    classes: [{
17650      classSuffix: 'color',
17651      propertyName: 'color'
17652    }, {
17653      classSuffix: 'background-color',
17654      propertyName: 'background-color'
17655    }, {
17656      classSuffix: 'border-color',
17657      propertyName: 'border-color'
17658    }]
17659  }, {
17660    path: ['color', 'gradients'],
17661    valueKey: 'gradient',
17662    cssVarInfix: 'gradient',
17663    classes: [{
17664      classSuffix: 'gradient-background',
17665      propertyName: 'background'
17666    }]
17667  }, {
17668    path: ['color', 'duotone'],
17669    valueKey: 'colors',
17670    cssVarInfix: 'duotone',
17671    valueFunc: ({
17672      slug
17673    }) => `url( '#wp-duotone-$slug}' )`,
17674    classes: []
17675  }, {
17676    path: ['shadow', 'presets'],
17677    valueKey: 'shadow',
17678    cssVarInfix: 'shadow',
17679    classes: []
17680  }, {
17681    path: ['typography', 'fontSizes'],
17682    valueFunc: (preset, settings) => getTypographyFontSizeValue(preset, settings),
17683    valueKey: 'size',
17684    cssVarInfix: 'font-size',
17685    classes: [{
17686      classSuffix: 'font-size',
17687      propertyName: 'font-size'
17688    }]
17689  }, {
17690    path: ['typography', 'fontFamilies'],
17691    valueKey: 'fontFamily',
17692    cssVarInfix: 'font-family',
17693    classes: [{
17694      classSuffix: 'font-family',
17695      propertyName: 'font-family'
17696    }]
17697  }, {
17698    path: ['spacing', 'spacingSizes'],
17699    valueKey: 'size',
17700    cssVarInfix: 'spacing',
17701    valueFunc: ({
17702      size
17703    }) => size,
17704    classes: []
17705  }];
17706  const STYLE_PATH_TO_CSS_VAR_INFIX = {
17707    'color.background': 'color',
17708    'color.text': 'color',
17709    'filter.duotone': 'duotone',
17710    'elements.link.color.text': 'color',
17711    'elements.link.:hover.color.text': 'color',
17712    'elements.link.typography.fontFamily': 'font-family',
17713    'elements.link.typography.fontSize': 'font-size',
17714    'elements.button.color.text': 'color',
17715    'elements.button.color.background': 'color',
17716    'elements.caption.color.text': 'color',
17717    'elements.button.typography.fontFamily': 'font-family',
17718    'elements.button.typography.fontSize': 'font-size',
17719    'elements.heading.color': 'color',
17720    'elements.heading.color.background': 'color',
17721    'elements.heading.typography.fontFamily': 'font-family',
17722    'elements.heading.gradient': 'gradient',
17723    'elements.heading.color.gradient': 'gradient',
17724    'elements.h1.color': 'color',
17725    'elements.h1.color.background': 'color',
17726    'elements.h1.typography.fontFamily': 'font-family',
17727    'elements.h1.color.gradient': 'gradient',
17728    'elements.h2.color': 'color',
17729    'elements.h2.color.background': 'color',
17730    'elements.h2.typography.fontFamily': 'font-family',
17731    'elements.h2.color.gradient': 'gradient',
17732    'elements.h3.color': 'color',
17733    'elements.h3.color.background': 'color',
17734    'elements.h3.typography.fontFamily': 'font-family',
17735    'elements.h3.color.gradient': 'gradient',
17736    'elements.h4.color': 'color',
17737    'elements.h4.color.background': 'color',
17738    'elements.h4.typography.fontFamily': 'font-family',
17739    'elements.h4.color.gradient': 'gradient',
17740    'elements.h5.color': 'color',
17741    'elements.h5.color.background': 'color',
17742    'elements.h5.typography.fontFamily': 'font-family',
17743    'elements.h5.color.gradient': 'gradient',
17744    'elements.h6.color': 'color',
17745    'elements.h6.color.background': 'color',
17746    'elements.h6.typography.fontFamily': 'font-family',
17747    'elements.h6.color.gradient': 'gradient',
17748    'color.gradient': 'gradient',
17749    shadow: 'shadow',
17750    'typography.fontSize': 'font-size',
17751    'typography.fontFamily': 'font-family'
17752  };
17753  
17754  // A static list of block attributes that store global style preset slugs.
17755  const STYLE_PATH_TO_PRESET_BLOCK_ATTRIBUTE = {
17756    'color.background': 'backgroundColor',
17757    'color.text': 'textColor',
17758    'color.gradient': 'gradient',
17759    'typography.fontSize': 'fontSize',
17760    'typography.fontFamily': 'fontFamily'
17761  };
17762  function useToolsPanelDropdownMenuProps() {
17763    const isMobile = (0,external_wp_compose_namespaceObject.useViewportMatch)('medium', '<');
17764    return !isMobile ? {
17765      popoverProps: {
17766        placement: 'left-start',
17767        // For non-mobile, inner sidebar width (248px) - button width (24px) - border (1px) + padding (16px) + spacing (20px)
17768        offset: 259
17769      }
17770    } : {};
17771  }
17772  function findInPresetsBy(features, blockName, presetPath, presetProperty, presetValueValue) {
17773    // Block presets take priority above root level presets.
17774    const orderedPresetsByOrigin = [getValueFromObjectPath(features, ['blocks', blockName, ...presetPath]), getValueFromObjectPath(features, presetPath)];
17775    for (const presetByOrigin of orderedPresetsByOrigin) {
17776      if (presetByOrigin) {
17777        // Preset origins ordered by priority.
17778        const origins = ['custom', 'theme', 'default'];
17779        for (const origin of origins) {
17780          const presets = presetByOrigin[origin];
17781          if (presets) {
17782            const presetObject = presets.find(preset => preset[presetProperty] === presetValueValue);
17783            if (presetObject) {
17784              if (presetProperty === 'slug') {
17785                return presetObject;
17786              }
17787              // If there is a highest priority preset with the same slug but different value the preset we found was overwritten and should be ignored.
17788              const highestPresetObjectWithSameSlug = findInPresetsBy(features, blockName, presetPath, 'slug', presetObject.slug);
17789              if (highestPresetObjectWithSameSlug[presetProperty] === presetObject[presetProperty]) {
17790                return presetObject;
17791              }
17792              return undefined;
17793            }
17794          }
17795        }
17796      }
17797    }
17798  }
17799  function getPresetVariableFromValue(features, blockName, variableStylePath, presetPropertyValue) {
17800    if (!presetPropertyValue) {
17801      return presetPropertyValue;
17802    }
17803    const cssVarInfix = STYLE_PATH_TO_CSS_VAR_INFIX[variableStylePath];
17804    const metadata = PRESET_METADATA.find(data => data.cssVarInfix === cssVarInfix);
17805    if (!metadata) {
17806      // The property doesn't have preset data
17807      // so the value should be returned as it is.
17808      return presetPropertyValue;
17809    }
17810    const {
17811      valueKey,
17812      path
17813    } = metadata;
17814    const presetObject = findInPresetsBy(features, blockName, path, valueKey, presetPropertyValue);
17815    if (!presetObject) {
17816      // Value wasn't found in the presets,
17817      // so it must be a custom value.
17818      return presetPropertyValue;
17819    }
17820    return `var:preset|$cssVarInfix}|$presetObject.slug}`;
17821  }
17822  function getValueFromPresetVariable(features, blockName, variable, [presetType, slug]) {
17823    const metadata = PRESET_METADATA.find(data => data.cssVarInfix === presetType);
17824    if (!metadata) {
17825      return variable;
17826    }
17827    const presetObject = findInPresetsBy(features.settings, blockName, metadata.path, 'slug', slug);
17828    if (presetObject) {
17829      const {
17830        valueKey
17831      } = metadata;
17832      const result = presetObject[valueKey];
17833      return getValueFromVariable(features, blockName, result);
17834    }
17835    return variable;
17836  }
17837  function getValueFromCustomVariable(features, blockName, variable, path) {
17838    var _getValueFromObjectPa;
17839    const result = (_getValueFromObjectPa = getValueFromObjectPath(features.settings, ['blocks', blockName, 'custom', ...path])) !== null && _getValueFromObjectPa !== void 0 ? _getValueFromObjectPa : getValueFromObjectPath(features.settings, ['custom', ...path]);
17840    if (!result) {
17841      return variable;
17842    }
17843    // A variable may reference another variable so we need recursion until we find the value.
17844    return getValueFromVariable(features, blockName, result);
17845  }
17846  
17847  /**
17848   * Attempts to fetch the value of a theme.json CSS variable.
17849   *
17850   * @param {Object}   features  GlobalStylesContext config, e.g., user, base or merged. Represents the theme.json tree.
17851   * @param {string}   blockName The name of a block as represented in the styles property. E.g., 'root' for root-level, and 'core/${blockName}' for blocks.
17852   * @param {string|*} variable  An incoming style value. A CSS var value is expected, but it could be any value.
17853   * @return {string|*|{ref}} The value of the CSS var, if found. If not found, the passed variable argument.
17854   */
17855  function getValueFromVariable(features, blockName, variable) {
17856    if (!variable || typeof variable !== 'string') {
17857      if (typeof variable?.ref === 'string') {
17858        variable = getValueFromObjectPath(features, variable.ref);
17859        // Presence of another ref indicates a reference to another dynamic value.
17860        // Pointing to another dynamic value is not supported.
17861        if (!variable || !!variable?.ref) {
17862          return variable;
17863        }
17864      } else {
17865        return variable;
17866      }
17867    }
17868    const USER_VALUE_PREFIX = 'var:';
17869    const THEME_VALUE_PREFIX = 'var(--wp--';
17870    const THEME_VALUE_SUFFIX = ')';
17871    let parsedVar;
17872    if (variable.startsWith(USER_VALUE_PREFIX)) {
17873      parsedVar = variable.slice(USER_VALUE_PREFIX.length).split('|');
17874    } else if (variable.startsWith(THEME_VALUE_PREFIX) && variable.endsWith(THEME_VALUE_SUFFIX)) {
17875      parsedVar = variable.slice(THEME_VALUE_PREFIX.length, -THEME_VALUE_SUFFIX.length).split('--');
17876    } else {
17877      // We don't know how to parse the value: either is raw of uses complex CSS such as `calc(1px * var(--wp--variable) )`
17878      return variable;
17879    }
17880    const [type, ...path] = parsedVar;
17881    if (type === 'preset') {
17882      return getValueFromPresetVariable(features, blockName, variable, path);
17883    }
17884    if (type === 'custom') {
17885      return getValueFromCustomVariable(features, blockName, variable, path);
17886    }
17887    return variable;
17888  }
17889  
17890  /**
17891   * Function that scopes a selector with another one. This works a bit like
17892   * SCSS nesting except the `&` operator isn't supported.
17893   *
17894   * @example
17895   * ```js
17896   * const scope = '.a, .b .c';
17897   * const selector = '> .x, .y';
17898   * const merged = scopeSelector( scope, selector );
17899   * // merged is '.a > .x, .a .y, .b .c > .x, .b .c .y'
17900   * ```
17901   *
17902   * @param {string} scope    Selector to scope to.
17903   * @param {string} selector Original selector.
17904   *
17905   * @return {string} Scoped selector.
17906   */
17907  function scopeSelector(scope, selector) {
17908    if (!scope || !selector) {
17909      return selector;
17910    }
17911    const scopes = scope.split(',');
17912    const selectors = selector.split(',');
17913    const selectorsScoped = [];
17914    scopes.forEach(outer => {
17915      selectors.forEach(inner => {
17916        selectorsScoped.push(`$outer.trim()} $inner.trim()}`);
17917      });
17918    });
17919    return selectorsScoped.join(', ');
17920  }
17921  
17922  /**
17923   * Scopes a collection of selectors for features and subfeatures.
17924   *
17925   * @example
17926   * ```js
17927   * const scope = '.custom-scope';
17928   * const selectors = {
17929   *     color: '.wp-my-block p',
17930   *     typography: { fontSize: '.wp-my-block caption' },
17931   * };
17932   * const result = scopeFeatureSelector( scope, selectors );
17933   * // result is {
17934   * //     color: '.custom-scope .wp-my-block p',
17935   * //     typography: { fonSize: '.custom-scope .wp-my-block caption' },
17936   * // }
17937   * ```
17938   *
17939   * @param {string} scope     Selector to scope collection of selectors with.
17940   * @param {Object} selectors Collection of feature selectors e.g.
17941   *
17942   * @return {Object|undefined} Scoped collection of feature selectors.
17943   */
17944  function scopeFeatureSelectors(scope, selectors) {
17945    if (!scope || !selectors) {
17946      return;
17947    }
17948    const featureSelectors = {};
17949    Object.entries(selectors).forEach(([feature, selector]) => {
17950      if (typeof selector === 'string') {
17951        featureSelectors[feature] = scopeSelector(scope, selector);
17952      }
17953      if (typeof selector === 'object') {
17954        featureSelectors[feature] = {};
17955        Object.entries(selector).forEach(([subfeature, subfeatureSelector]) => {
17956          featureSelectors[feature][subfeature] = scopeSelector(scope, subfeatureSelector);
17957        });
17958      }
17959    });
17960    return featureSelectors;
17961  }
17962  
17963  /**
17964   * Appends a sub-selector to an existing one.
17965   *
17966   * Given the compounded `selector` "h1, h2, h3"
17967   * and the `toAppend` selector ".some-class" the result will be
17968   * "h1.some-class, h2.some-class, h3.some-class".
17969   *
17970   * @param {string} selector Original selector.
17971   * @param {string} toAppend Selector to append.
17972   *
17973   * @return {string} The new selector.
17974   */
17975  function appendToSelector(selector, toAppend) {
17976    if (!selector.includes(',')) {
17977      return selector + toAppend;
17978    }
17979    const selectors = selector.split(',');
17980    const newSelectors = selectors.map(sel => sel + toAppend);
17981    return newSelectors.join(',');
17982  }
17983  
17984  /**
17985   * Compares global style variations according to their styles and settings properties.
17986   *
17987   * @example
17988   * ```js
17989   * const globalStyles = { styles: { typography: { fontSize: '10px' } }, settings: {} };
17990   * const variation = { styles: { typography: { fontSize: '10000px' } }, settings: {} };
17991   * const isEqual = areGlobalStyleConfigsEqual( globalStyles, variation );
17992   * // false
17993   * ```
17994   *
17995   * @param {Object} original  A global styles object.
17996   * @param {Object} variation A global styles object.
17997   *
17998   * @return {boolean} Whether `original` and `variation` match.
17999   */
18000  function areGlobalStyleConfigsEqual(original, variation) {
18001    if (typeof original !== 'object' || typeof variation !== 'object') {
18002      return original === variation;
18003    }
18004    return es6_default()(original?.styles, variation?.styles) && es6_default()(original?.settings, variation?.settings);
18005  }
18006  
18007  /**
18008   * Generates the selector for a block style variation by creating the
18009   * appropriate CSS class and adding it to the ancestor portion of the block's
18010   * selector.
18011   *
18012   * For example, take the Button block which has a compound selector:
18013   * `.wp-block-button .wp-block-button__link`. With a variation named 'custom',
18014   * the class `.is-style-custom` should be added to the `.wp-block-button`
18015   * ancestor only.
18016   *
18017   * This function will take into account comma separated and complex selectors.
18018   *
18019   * @param {string} variation     Name for the variation.
18020   * @param {string} blockSelector CSS selector for the block.
18021   *
18022   * @return {string} CSS selector for the block style variation.
18023   */
18024  function getBlockStyleVariationSelector(variation, blockSelector) {
18025    const variationClass = `.is-style-$variation}`;
18026    if (!blockSelector) {
18027      return variationClass;
18028    }
18029    const ancestorRegex = /((?::\([^)]+\))?\s*)([^\s:]+)/;
18030    const addVariationClass = (_match, group1, group2) => {
18031      return group1 + group2 + variationClass;
18032    };
18033    const result = blockSelector.split(',').map(part => part.replace(ancestorRegex, addVariationClass));
18034    return result.join(',');
18035  }
18036  
18037  /**
18038   * Looks up a theme file URI based on a relative path.
18039   *
18040   * @param {string}        file          A relative path.
18041   * @param {Array<Object>} themeFileURIs A collection of absolute theme file URIs and their corresponding file paths.
18042   * @return {string} A resolved theme file URI, if one is found in the themeFileURIs collection.
18043   */
18044  function getResolvedThemeFilePath(file, themeFileURIs) {
18045    if (!file || !themeFileURIs || !Array.isArray(themeFileURIs)) {
18046      return file;
18047    }
18048    const uri = themeFileURIs.find(themeFileUri => themeFileUri?.name === file);
18049    if (!uri?.href) {
18050      return file;
18051    }
18052    return uri?.href;
18053  }
18054  
18055  /**
18056   * Resolves ref values in theme JSON.
18057   *
18058   * @param {Object|string} ruleValue A block style value that may contain a reference to a theme.json value.
18059   * @param {Object}        tree      A theme.json object.
18060   * @return {*} The resolved value or incoming ruleValue.
18061   */
18062  function getResolvedRefValue(ruleValue, tree) {
18063    if (!ruleValue || !tree) {
18064      return ruleValue;
18065    }
18066  
18067    /*
18068     * Where the rule value is an object with a 'ref' property pointing
18069     * to a path, this converts that path into the value at that path.
18070     * For example: { "ref": "style.color.background" } => "#fff".
18071     */
18072    if (typeof ruleValue !== 'string' && ruleValue?.ref) {
18073      const resolvedRuleValue = (0,external_wp_styleEngine_namespaceObject.getCSSValueFromRawStyle)(getValueFromObjectPath(tree, ruleValue.ref));
18074  
18075      /*
18076       * Presence of another ref indicates a reference to another dynamic value.
18077       * Pointing to another dynamic value is not supported.
18078       */
18079      if (resolvedRuleValue?.ref) {
18080        return undefined;
18081      }
18082      if (resolvedRuleValue === undefined) {
18083        return ruleValue;
18084      }
18085      return resolvedRuleValue;
18086    }
18087    return ruleValue;
18088  }
18089  
18090  /**
18091   * Resolves ref and relative path values in theme JSON.
18092   *
18093   * @param {Object|string} ruleValue A block style value that may contain a reference to a theme.json value.
18094   * @param {Object}        tree      A theme.json object.
18095   * @return {*} The resolved value or incoming ruleValue.
18096   */
18097  function getResolvedValue(ruleValue, tree) {
18098    if (!ruleValue || !tree) {
18099      return ruleValue;
18100    }
18101  
18102    // Resolve ref values.
18103    const resolvedValue = getResolvedRefValue(ruleValue, tree);
18104  
18105    // Resolve relative paths.
18106    if (resolvedValue?.url) {
18107      resolvedValue.url = getResolvedThemeFilePath(resolvedValue.url, tree?._links?.['wp:theme-file']);
18108    }
18109    return resolvedValue;
18110  }
18111  
18112  ;// ./node_modules/@wordpress/block-editor/build-module/components/global-styles/context.js
18113  /**
18114   * WordPress dependencies
18115   */
18116  
18117  const DEFAULT_GLOBAL_STYLES_CONTEXT = {
18118    user: {},
18119    base: {},
18120    merged: {},
18121    setUserConfig: () => {}
18122  };
18123  const GlobalStylesContext = (0,external_wp_element_namespaceObject.createContext)(DEFAULT_GLOBAL_STYLES_CONTEXT);
18124  
18125  ;// ./node_modules/@wordpress/block-editor/build-module/components/global-styles/hooks.js
18126  /**
18127   * External dependencies
18128   */
18129  
18130  
18131  /**
18132   * WordPress dependencies
18133   */
18134  
18135  
18136  
18137  
18138  
18139  /**
18140   * Internal dependencies
18141   */
18142  
18143  
18144  
18145  
18146  const EMPTY_CONFIG = {
18147    settings: {},
18148    styles: {}
18149  };
18150  const VALID_SETTINGS = ['appearanceTools', 'useRootPaddingAwareAlignments', 'background.backgroundImage', 'background.backgroundRepeat', 'background.backgroundSize', 'background.backgroundPosition', 'border.color', 'border.radius', 'border.style', 'border.width', 'shadow.presets', 'shadow.defaultPresets', 'color.background', 'color.button', 'color.caption', 'color.custom', 'color.customDuotone', 'color.customGradient', 'color.defaultDuotone', 'color.defaultGradients', 'color.defaultPalette', 'color.duotone', 'color.gradients', 'color.heading', 'color.link', 'color.palette', 'color.text', 'custom', 'dimensions.aspectRatio', 'dimensions.minHeight', 'layout.contentSize', 'layout.definitions', 'layout.wideSize', 'lightbox.enabled', 'lightbox.allowEditing', 'position.fixed', 'position.sticky', 'spacing.customSpacingSize', 'spacing.defaultSpacingSizes', 'spacing.spacingSizes', 'spacing.spacingScale', 'spacing.blockGap', 'spacing.margin', 'spacing.padding', 'spacing.units', 'typography.fluid', 'typography.customFontSize', 'typography.defaultFontSizes', 'typography.dropCap', 'typography.fontFamilies', 'typography.fontSizes', 'typography.fontStyle', 'typography.fontWeight', 'typography.letterSpacing', 'typography.lineHeight', 'typography.textAlign', 'typography.textColumns', 'typography.textDecoration', 'typography.textTransform', 'typography.writingMode'];
18151  const useGlobalStylesReset = () => {
18152    const {
18153      user,
18154      setUserConfig
18155    } = (0,external_wp_element_namespaceObject.useContext)(GlobalStylesContext);
18156    const config = {
18157      settings: user.settings,
18158      styles: user.styles
18159    };
18160    const canReset = !!config && !es6_default()(config, EMPTY_CONFIG);
18161    return [canReset, (0,external_wp_element_namespaceObject.useCallback)(() => setUserConfig(EMPTY_CONFIG), [setUserConfig])];
18162  };
18163  function useGlobalSetting(propertyPath, blockName, source = 'all') {
18164    const {
18165      setUserConfig,
18166      ...configs
18167    } = (0,external_wp_element_namespaceObject.useContext)(GlobalStylesContext);
18168    const appendedBlockPath = blockName ? '.blocks.' + blockName : '';
18169    const appendedPropertyPath = propertyPath ? '.' + propertyPath : '';
18170    const contextualPath = `settings$appendedBlockPath}$appendedPropertyPath}`;
18171    const globalPath = `settings$appendedPropertyPath}`;
18172    const sourceKey = source === 'all' ? 'merged' : source;
18173    const settingValue = (0,external_wp_element_namespaceObject.useMemo)(() => {
18174      const configToUse = configs[sourceKey];
18175      if (!configToUse) {
18176        throw 'Unsupported source';
18177      }
18178      if (propertyPath) {
18179        var _getValueFromObjectPa;
18180        return (_getValueFromObjectPa = getValueFromObjectPath(configToUse, contextualPath)) !== null && _getValueFromObjectPa !== void 0 ? _getValueFromObjectPa : getValueFromObjectPath(configToUse, globalPath);
18181      }
18182      let result = {};
18183      VALID_SETTINGS.forEach(setting => {
18184        var _getValueFromObjectPa2;
18185        const value = (_getValueFromObjectPa2 = getValueFromObjectPath(configToUse, `settings$appendedBlockPath}.$setting}`)) !== null && _getValueFromObjectPa2 !== void 0 ? _getValueFromObjectPa2 : getValueFromObjectPath(configToUse, `settings.$setting}`);
18186        if (value !== undefined) {
18187          result = setImmutably(result, setting.split('.'), value);
18188        }
18189      });
18190      return result;
18191    }, [configs, sourceKey, propertyPath, contextualPath, globalPath, appendedBlockPath]);
18192    const setSetting = newValue => {
18193      setUserConfig(currentConfig => setImmutably(currentConfig, contextualPath.split('.'), newValue));
18194    };
18195    return [settingValue, setSetting];
18196  }
18197  function useGlobalStyle(path, blockName, source = 'all', {
18198    shouldDecodeEncode = true
18199  } = {}) {
18200    const {
18201      merged: mergedConfig,
18202      base: baseConfig,
18203      user: userConfig,
18204      setUserConfig
18205    } = (0,external_wp_element_namespaceObject.useContext)(GlobalStylesContext);
18206    const appendedPath = path ? '.' + path : '';
18207    const finalPath = !blockName ? `styles$appendedPath}` : `styles.blocks.$blockName}$appendedPath}`;
18208    const setStyle = newValue => {
18209      setUserConfig(currentConfig => setImmutably(currentConfig, finalPath.split('.'), shouldDecodeEncode ? getPresetVariableFromValue(mergedConfig.settings, blockName, path, newValue) : newValue));
18210    };
18211    let rawResult, result;
18212    switch (source) {
18213      case 'all':
18214        rawResult = getValueFromObjectPath(mergedConfig, finalPath);
18215        result = shouldDecodeEncode ? getValueFromVariable(mergedConfig, blockName, rawResult) : rawResult;
18216        break;
18217      case 'user':
18218        rawResult = getValueFromObjectPath(userConfig, finalPath);
18219        result = shouldDecodeEncode ? getValueFromVariable(mergedConfig, blockName, rawResult) : rawResult;
18220        break;
18221      case 'base':
18222        rawResult = getValueFromObjectPath(baseConfig, finalPath);
18223        result = shouldDecodeEncode ? getValueFromVariable(baseConfig, blockName, rawResult) : rawResult;
18224        break;
18225      default:
18226        throw 'Unsupported source';
18227    }
18228    return [result, setStyle];
18229  }
18230  
18231  /**
18232   * React hook that overrides a global settings object with block and element specific settings.
18233   *
18234   * @param {Object}     parentSettings Settings object.
18235   * @param {blockName?} blockName      Block name.
18236   * @param {element?}   element        Element name.
18237   *
18238   * @return {Object} Merge of settings and supports.
18239   */
18240  function useSettingsForBlockElement(parentSettings, blockName, element) {
18241    const {
18242      supportedStyles,
18243      supports
18244    } = (0,external_wp_data_namespaceObject.useSelect)(select => {
18245      return {
18246        supportedStyles: unlock(select(external_wp_blocks_namespaceObject.store)).getSupportedStyles(blockName, element),
18247        supports: select(external_wp_blocks_namespaceObject.store).getBlockType(blockName)?.supports
18248      };
18249    }, [blockName, element]);
18250    return (0,external_wp_element_namespaceObject.useMemo)(() => {
18251      const updatedSettings = {
18252        ...parentSettings
18253      };
18254      if (!supportedStyles.includes('fontSize')) {
18255        updatedSettings.typography = {
18256          ...updatedSettings.typography,
18257          fontSizes: {},
18258          customFontSize: false,
18259          defaultFontSizes: false
18260        };
18261      }
18262      if (!supportedStyles.includes('fontFamily')) {
18263        updatedSettings.typography = {
18264          ...updatedSettings.typography,
18265          fontFamilies: {}
18266        };
18267      }
18268      updatedSettings.color = {
18269        ...updatedSettings.color,
18270        text: updatedSettings.color?.text && supportedStyles.includes('color'),
18271        background: updatedSettings.color?.background && (supportedStyles.includes('background') || supportedStyles.includes('backgroundColor')),
18272        button: updatedSettings.color?.button && supportedStyles.includes('buttonColor'),
18273        heading: updatedSettings.color?.heading && supportedStyles.includes('headingColor'),
18274        link: updatedSettings.color?.link && supportedStyles.includes('linkColor'),
18275        caption: updatedSettings.color?.caption && supportedStyles.includes('captionColor')
18276      };
18277  
18278      // Some blocks can enable background colors but disable gradients.
18279      if (!supportedStyles.includes('background')) {
18280        updatedSettings.color.gradients = [];
18281        updatedSettings.color.customGradient = false;
18282      }
18283  
18284      // If filters are not supported by the block/element, disable duotone.
18285      if (!supportedStyles.includes('filter')) {
18286        updatedSettings.color.defaultDuotone = false;
18287        updatedSettings.color.customDuotone = false;
18288      }
18289      ['lineHeight', 'fontStyle', 'fontWeight', 'letterSpacing', 'textAlign', 'textTransform', 'textDecoration', 'writingMode'].forEach(key => {
18290        if (!supportedStyles.includes(key)) {
18291          updatedSettings.typography = {
18292            ...updatedSettings.typography,
18293            [key]: false
18294          };
18295        }
18296      });
18297  
18298      // The column-count style is named text column to reduce confusion with
18299      // the columns block and manage expectations from the support.
18300      // See: https://github.com/WordPress/gutenberg/pull/33587
18301      if (!supportedStyles.includes('columnCount')) {
18302        updatedSettings.typography = {
18303          ...updatedSettings.typography,
18304          textColumns: false
18305        };
18306      }
18307      ['contentSize', 'wideSize'].forEach(key => {
18308        if (!supportedStyles.includes(key)) {
18309          updatedSettings.layout = {
18310            ...updatedSettings.layout,
18311            [key]: false
18312          };
18313        }
18314      });
18315      ['padding', 'margin', 'blockGap'].forEach(key => {
18316        if (!supportedStyles.includes(key)) {
18317          updatedSettings.spacing = {
18318            ...updatedSettings.spacing,
18319            [key]: false
18320          };
18321        }
18322        const sides = Array.isArray(supports?.spacing?.[key]) ? supports?.spacing?.[key] : supports?.spacing?.[key]?.sides;
18323        // Check if spacing type is supported before adding sides.
18324        if (sides?.length && updatedSettings.spacing?.[key]) {
18325          updatedSettings.spacing = {
18326            ...updatedSettings.spacing,
18327            [key]: {
18328              ...updatedSettings.spacing?.[key],
18329              sides
18330            }
18331          };
18332        }
18333      });
18334      ['aspectRatio', 'minHeight'].forEach(key => {
18335        if (!supportedStyles.includes(key)) {
18336          updatedSettings.dimensions = {
18337            ...updatedSettings.dimensions,
18338            [key]: false
18339          };
18340        }
18341      });
18342      ['radius', 'color', 'style', 'width'].forEach(key => {
18343        if (!supportedStyles.includes('border' + key.charAt(0).toUpperCase() + key.slice(1))) {
18344          updatedSettings.border = {
18345            ...updatedSettings.border,
18346            [key]: false
18347          };
18348        }
18349      });
18350      ['backgroundImage', 'backgroundSize'].forEach(key => {
18351        if (!supportedStyles.includes(key)) {
18352          updatedSettings.background = {
18353            ...updatedSettings.background,
18354            [key]: false
18355          };
18356        }
18357      });
18358      updatedSettings.shadow = supportedStyles.includes('shadow') ? updatedSettings.shadow : false;
18359  
18360      // Text alignment is only available for blocks.
18361      if (element) {
18362        updatedSettings.typography.textAlign = false;
18363      }
18364      return updatedSettings;
18365    }, [parentSettings, supportedStyles, supports, element]);
18366  }
18367  function useColorsPerOrigin(settings) {
18368    const customColors = settings?.color?.palette?.custom;
18369    const themeColors = settings?.color?.palette?.theme;
18370    const defaultColors = settings?.color?.palette?.default;
18371    const shouldDisplayDefaultColors = settings?.color?.defaultPalette;
18372    return (0,external_wp_element_namespaceObject.useMemo)(() => {
18373      const result = [];
18374      if (themeColors && themeColors.length) {
18375        result.push({
18376          name: (0,external_wp_i18n_namespaceObject._x)('Theme', 'Indicates this palette comes from the theme.'),
18377          colors: themeColors
18378        });
18379      }
18380      if (shouldDisplayDefaultColors && defaultColors && defaultColors.length) {
18381        result.push({
18382          name: (0,external_wp_i18n_namespaceObject._x)('Default', 'Indicates this palette comes from WordPress.'),
18383          colors: defaultColors
18384        });
18385      }
18386      if (customColors && customColors.length) {
18387        result.push({
18388          name: (0,external_wp_i18n_namespaceObject._x)('Custom', 'Indicates this palette is created by the user.'),
18389          colors: customColors
18390        });
18391      }
18392      return result;
18393    }, [customColors, themeColors, defaultColors, shouldDisplayDefaultColors]);
18394  }
18395  function useGradientsPerOrigin(settings) {
18396    const customGradients = settings?.color?.gradients?.custom;
18397    const themeGradients = settings?.color?.gradients?.theme;
18398    const defaultGradients = settings?.color?.gradients?.default;
18399    const shouldDisplayDefaultGradients = settings?.color?.defaultGradients;
18400    return (0,external_wp_element_namespaceObject.useMemo)(() => {
18401      const result = [];
18402      if (themeGradients && themeGradients.length) {
18403        result.push({
18404          name: (0,external_wp_i18n_namespaceObject._x)('Theme', 'Indicates this palette comes from the theme.'),
18405          gradients: themeGradients
18406        });
18407      }
18408      if (shouldDisplayDefaultGradients && defaultGradients && defaultGradients.length) {
18409        result.push({
18410          name: (0,external_wp_i18n_namespaceObject._x)('Default', 'Indicates this palette comes from WordPress.'),
18411          gradients: defaultGradients
18412        });
18413      }
18414      if (customGradients && customGradients.length) {
18415        result.push({
18416          name: (0,external_wp_i18n_namespaceObject._x)('Custom', 'Indicates this palette is created by the user.'),
18417          gradients: customGradients
18418        });
18419      }
18420      return result;
18421    }, [customGradients, themeGradients, defaultGradients, shouldDisplayDefaultGradients]);
18422  }
18423  
18424  ;// ./node_modules/clsx/dist/clsx.mjs
18425  function r(e){var t,f,n="";if("string"==typeof e||"number"==typeof e)n+=e;else if("object"==typeof e)if(Array.isArray(e)){var o=e.length;for(t=0;t<o;t++)e[t]&&(f=r(e[t]))&&(n&&(n+=" "),n+=f)}else for(f in e)e[f]&&(n&&(n+=" "),n+=f);return n}function clsx(){for(var e,t,f=0,n="",o=arguments.length;f<o;f++)(e=arguments[f])&&(t=r(e))&&(n&&(n+=" "),n+=t);return n}/* harmony default export */ const dist_clsx = (clsx);
18426  ;// ./node_modules/@wordpress/block-editor/build-module/hooks/utils.js
18427  /**
18428   * WordPress dependencies
18429   */
18430  
18431  
18432  
18433  
18434  
18435  
18436  /**
18437   * Internal dependencies
18438   */
18439  
18440  
18441  
18442  
18443  
18444  
18445  /**
18446   * External dependencies
18447   */
18448  
18449  
18450  /**
18451   * Removed falsy values from nested object.
18452   *
18453   * @param {*} object
18454   * @return {*} Object cleaned from falsy values
18455   */
18456  
18457  const utils_cleanEmptyObject = object => {
18458    if (object === null || typeof object !== 'object' || Array.isArray(object)) {
18459      return object;
18460    }
18461    const cleanedNestedObjects = Object.entries(object).map(([key, value]) => [key, utils_cleanEmptyObject(value)]).filter(([, value]) => value !== undefined);
18462    return !cleanedNestedObjects.length ? undefined : Object.fromEntries(cleanedNestedObjects);
18463  };
18464  function transformStyles(activeSupports, migrationPaths, result, source, index, results) {
18465    // If there are no active supports return early.
18466    if (Object.values(activeSupports !== null && activeSupports !== void 0 ? activeSupports : {}).every(isActive => !isActive)) {
18467      return result;
18468    }
18469    // If the condition verifies we are probably in the presence of a wrapping transform
18470    // e.g: nesting paragraphs in a group or columns and in that case the styles should not be transformed.
18471    if (results.length === 1 && result.innerBlocks.length === source.length) {
18472      return result;
18473    }
18474    // For cases where we have a transform from one block to multiple blocks
18475    // or multiple blocks to one block we apply the styles of the first source block
18476    // to the result(s).
18477    let referenceBlockAttributes = source[0]?.attributes;
18478    // If we are in presence of transform between more than one block in the source
18479    // that has more than one block in the result
18480    // we apply the styles on source N to the result N,
18481    // if source N does not exists we do nothing.
18482    if (results.length > 1 && source.length > 1) {
18483      if (source[index]) {
18484        referenceBlockAttributes = source[index]?.attributes;
18485      } else {
18486        return result;
18487      }
18488    }
18489    let returnBlock = result;
18490    Object.entries(activeSupports).forEach(([support, isActive]) => {
18491      if (isActive) {
18492        migrationPaths[support].forEach(path => {
18493          const styleValue = getValueFromObjectPath(referenceBlockAttributes, path);
18494          if (styleValue) {
18495            returnBlock = {
18496              ...returnBlock,
18497              attributes: setImmutably(returnBlock.attributes, path, styleValue)
18498            };
18499          }
18500        });
18501      }
18502    });
18503    return returnBlock;
18504  }
18505  
18506  /**
18507   * Check whether serialization of specific block support feature or set should
18508   * be skipped.
18509   *
18510   * @param {string|Object} blockNameOrType Block name or block type object.
18511   * @param {string}        featureSet      Name of block support feature set.
18512   * @param {string}        feature         Name of the individual feature to check.
18513   *
18514   * @return {boolean} Whether serialization should occur.
18515   */
18516  function shouldSkipSerialization(blockNameOrType, featureSet, feature) {
18517    const support = (0,external_wp_blocks_namespaceObject.getBlockSupport)(blockNameOrType, featureSet);
18518    const skipSerialization = support?.__experimentalSkipSerialization;
18519    if (Array.isArray(skipSerialization)) {
18520      return skipSerialization.includes(feature);
18521    }
18522    return skipSerialization;
18523  }
18524  const pendingStyleOverrides = new WeakMap();
18525  
18526  /**
18527   * Override a block editor settings style. Leave the ID blank to create a new
18528   * style.
18529   *
18530   * @param {Object}  override     Override object.
18531   * @param {?string} override.id  Id of the style override, leave blank to create
18532   *                               a new style.
18533   * @param {string}  override.css CSS to apply.
18534   */
18535  function useStyleOverride({
18536    id,
18537    css
18538  }) {
18539    return usePrivateStyleOverride({
18540      id,
18541      css
18542    });
18543  }
18544  function usePrivateStyleOverride({
18545    id,
18546    css,
18547    assets,
18548    __unstableType,
18549    variation,
18550    clientId
18551  } = {}) {
18552    const {
18553      setStyleOverride,
18554      deleteStyleOverride
18555    } = unlock((0,external_wp_data_namespaceObject.useDispatch)(store));
18556    const registry = (0,external_wp_data_namespaceObject.useRegistry)();
18557    const fallbackId = (0,external_wp_element_namespaceObject.useId)();
18558    (0,external_wp_element_namespaceObject.useEffect)(() => {
18559      // Unmount if there is CSS and assets are empty.
18560      if (!css && !assets) {
18561        return;
18562      }
18563      const _id = id || fallbackId;
18564      const override = {
18565        id,
18566        css,
18567        assets,
18568        __unstableType,
18569        variation,
18570        clientId
18571      };
18572      // Batch updates to style overrides to avoid triggering cascading renders
18573      // for each style override block included in a tree and optimize initial render.
18574      if (!pendingStyleOverrides.get(registry)) {
18575        pendingStyleOverrides.set(registry, []);
18576      }
18577      pendingStyleOverrides.get(registry).push([_id, override]);
18578      window.queueMicrotask(() => {
18579        if (pendingStyleOverrides.get(registry)?.length) {
18580          registry.batch(() => {
18581            pendingStyleOverrides.get(registry).forEach(args => {
18582              setStyleOverride(...args);
18583            });
18584            pendingStyleOverrides.set(registry, []);
18585          });
18586        }
18587      });
18588      return () => {
18589        const isPending = pendingStyleOverrides.get(registry)?.find(([currentId]) => currentId === _id);
18590        if (isPending) {
18591          pendingStyleOverrides.set(registry, pendingStyleOverrides.get(registry).filter(([currentId]) => currentId !== _id));
18592        } else {
18593          deleteStyleOverride(_id);
18594        }
18595      };
18596    }, [id, css, clientId, assets, __unstableType, fallbackId, setStyleOverride, deleteStyleOverride, registry]);
18597  }
18598  
18599  /**
18600   * Based on the block and its context, returns an object of all the block settings.
18601   * This object can be passed as a prop to all the Styles UI components
18602   * (TypographyPanel, DimensionsPanel...).
18603   *
18604   * @param {string} name         Block name.
18605   * @param {*}      parentLayout Parent layout.
18606   *
18607   * @return {Object} Settings object.
18608   */
18609  function useBlockSettings(name, parentLayout) {
18610    const [backgroundImage, backgroundSize, customFontFamilies, defaultFontFamilies, themeFontFamilies, defaultFontSizesEnabled, customFontSizes, defaultFontSizes, themeFontSizes, customFontSize, fontStyle, fontWeight, lineHeight, textAlign, textColumns, textDecoration, writingMode, textTransform, letterSpacing, padding, margin, blockGap, defaultSpacingSizesEnabled, customSpacingSize, userSpacingSizes, defaultSpacingSizes, themeSpacingSizes, units, aspectRatio, minHeight, layout, borderColor, borderRadius, borderStyle, borderWidth, customColorsEnabled, customColors, customDuotone, themeColors, defaultColors, defaultPalette, defaultDuotone, userDuotonePalette, themeDuotonePalette, defaultDuotonePalette, userGradientPalette, themeGradientPalette, defaultGradientPalette, defaultGradients, areCustomGradientsEnabled, isBackgroundEnabled, isLinkEnabled, isTextEnabled, isHeadingEnabled, isButtonEnabled, shadow] = use_settings_useSettings('background.backgroundImage', 'background.backgroundSize', 'typography.fontFamilies.custom', 'typography.fontFamilies.default', 'typography.fontFamilies.theme', 'typography.defaultFontSizes', 'typography.fontSizes.custom', 'typography.fontSizes.default', 'typography.fontSizes.theme', 'typography.customFontSize', 'typography.fontStyle', 'typography.fontWeight', 'typography.lineHeight', 'typography.textAlign', 'typography.textColumns', 'typography.textDecoration', 'typography.writingMode', 'typography.textTransform', 'typography.letterSpacing', 'spacing.padding', 'spacing.margin', 'spacing.blockGap', 'spacing.defaultSpacingSizes', 'spacing.customSpacingSize', 'spacing.spacingSizes.custom', 'spacing.spacingSizes.default', 'spacing.spacingSizes.theme', 'spacing.units', 'dimensions.aspectRatio', 'dimensions.minHeight', 'layout', 'border.color', 'border.radius', 'border.style', 'border.width', 'color.custom', 'color.palette.custom', 'color.customDuotone', 'color.palette.theme', 'color.palette.default', 'color.defaultPalette', 'color.defaultDuotone', 'color.duotone.custom', 'color.duotone.theme', 'color.duotone.default', 'color.gradients.custom', 'color.gradients.theme', 'color.gradients.default', 'color.defaultGradients', 'color.customGradient', 'color.background', 'color.link', 'color.text', 'color.heading', 'color.button', 'shadow');
18611    const rawSettings = (0,external_wp_element_namespaceObject.useMemo)(() => {
18612      return {
18613        background: {
18614          backgroundImage,
18615          backgroundSize
18616        },
18617        color: {
18618          palette: {
18619            custom: customColors,
18620            theme: themeColors,
18621            default: defaultColors
18622          },
18623          gradients: {
18624            custom: userGradientPalette,
18625            theme: themeGradientPalette,
18626            default: defaultGradientPalette
18627          },
18628          duotone: {
18629            custom: userDuotonePalette,
18630            theme: themeDuotonePalette,
18631            default: defaultDuotonePalette
18632          },
18633          defaultGradients,
18634          defaultPalette,
18635          defaultDuotone,
18636          custom: customColorsEnabled,
18637          customGradient: areCustomGradientsEnabled,
18638          customDuotone,
18639          background: isBackgroundEnabled,
18640          link: isLinkEnabled,
18641          heading: isHeadingEnabled,
18642          button: isButtonEnabled,
18643          text: isTextEnabled
18644        },
18645        typography: {
18646          fontFamilies: {
18647            custom: customFontFamilies,
18648            default: defaultFontFamilies,
18649            theme: themeFontFamilies
18650          },
18651          fontSizes: {
18652            custom: customFontSizes,
18653            default: defaultFontSizes,
18654            theme: themeFontSizes
18655          },
18656          customFontSize,
18657          defaultFontSizes: defaultFontSizesEnabled,
18658          fontStyle,
18659          fontWeight,
18660          lineHeight,
18661          textAlign,
18662          textColumns,
18663          textDecoration,
18664          textTransform,
18665          letterSpacing,
18666          writingMode
18667        },
18668        spacing: {
18669          spacingSizes: {
18670            custom: userSpacingSizes,
18671            default: defaultSpacingSizes,
18672            theme: themeSpacingSizes
18673          },
18674          customSpacingSize,
18675          defaultSpacingSizes: defaultSpacingSizesEnabled,
18676          padding,
18677          margin,
18678          blockGap,
18679          units
18680        },
18681        border: {
18682          color: borderColor,
18683          radius: borderRadius,
18684          style: borderStyle,
18685          width: borderWidth
18686        },
18687        dimensions: {
18688          aspectRatio,
18689          minHeight
18690        },
18691        layout,
18692        parentLayout,
18693        shadow
18694      };
18695    }, [backgroundImage, backgroundSize, customFontFamilies, defaultFontFamilies, themeFontFamilies, defaultFontSizesEnabled, customFontSizes, defaultFontSizes, themeFontSizes, customFontSize, fontStyle, fontWeight, lineHeight, textAlign, textColumns, textDecoration, textTransform, letterSpacing, writingMode, padding, margin, blockGap, defaultSpacingSizesEnabled, customSpacingSize, userSpacingSizes, defaultSpacingSizes, themeSpacingSizes, units, aspectRatio, minHeight, layout, parentLayout, borderColor, borderRadius, borderStyle, borderWidth, customColorsEnabled, customColors, customDuotone, themeColors, defaultColors, defaultPalette, defaultDuotone, userDuotonePalette, themeDuotonePalette, defaultDuotonePalette, userGradientPalette, themeGradientPalette, defaultGradientPalette, defaultGradients, areCustomGradientsEnabled, isBackgroundEnabled, isLinkEnabled, isTextEnabled, isHeadingEnabled, isButtonEnabled, shadow]);
18696    return useSettingsForBlockElement(rawSettings, name);
18697  }
18698  function createBlockEditFilter(features) {
18699    // We don't want block controls to re-render when typing inside a block.
18700    // `memo` will prevent re-renders unless props change, so only pass the
18701    // needed props and not the whole attributes object.
18702    features = features.map(settings => {
18703      return {
18704        ...settings,
18705        Edit: (0,external_wp_element_namespaceObject.memo)(settings.edit)
18706      };
18707    });
18708    const withBlockEditHooks = (0,external_wp_compose_namespaceObject.createHigherOrderComponent)(OriginalBlockEdit => props => {
18709      const context = useBlockEditContext();
18710      // CAUTION: code added before this line will be executed for all
18711      // blocks, not just those that support the feature! Code added
18712      // above this line should be carefully evaluated for its impact on
18713      // performance.
18714      return [...features.map((feature, i) => {
18715        const {
18716          Edit,
18717          hasSupport,
18718          attributeKeys = [],
18719          shareWithChildBlocks
18720        } = feature;
18721        const shouldDisplayControls = context[mayDisplayControlsKey] || context[mayDisplayParentControlsKey] && shareWithChildBlocks;
18722        if (!shouldDisplayControls || !hasSupport(props.name)) {
18723          return null;
18724        }
18725        const neededProps = {};
18726        for (const key of attributeKeys) {
18727          if (props.attributes[key]) {
18728            neededProps[key] = props.attributes[key];
18729          }
18730        }
18731        return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Edit
18732        // We can use the index because the array length
18733        // is fixed per page load right now.
18734        , {
18735          name: props.name,
18736          isSelected: props.isSelected,
18737          clientId: props.clientId,
18738          setAttributes: props.setAttributes,
18739          __unstableParentLayout: props.__unstableParentLayout
18740          // This component is pure, so only pass needed
18741          // props!!!
18742          ,
18743          ...neededProps
18744        }, i);
18745      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(OriginalBlockEdit, {
18746        ...props
18747      }, "edit")];
18748    }, 'withBlockEditHooks');
18749    (0,external_wp_hooks_namespaceObject.addFilter)('editor.BlockEdit', 'core/editor/hooks', withBlockEditHooks);
18750  }
18751  function BlockProps({
18752    index,
18753    useBlockProps: hook,
18754    setAllWrapperProps,
18755    ...props
18756  }) {
18757    const wrapperProps = hook(props);
18758    const setWrapperProps = next => setAllWrapperProps(prev => {
18759      const nextAll = [...prev];
18760      nextAll[index] = next;
18761      return nextAll;
18762    });
18763    // Setting state after every render is fine because this component is
18764    // pure and will only re-render when needed props change.
18765    (0,external_wp_element_namespaceObject.useEffect)(() => {
18766      // We could shallow compare the props, but since this component only
18767      // changes when needed attributes change, the benefit is probably small.
18768      setWrapperProps(wrapperProps);
18769      return () => {
18770        setWrapperProps(undefined);
18771      };
18772    });
18773    return null;
18774  }
18775  const BlockPropsPure = (0,external_wp_element_namespaceObject.memo)(BlockProps);
18776  function createBlockListBlockFilter(features) {
18777    const withBlockListBlockHooks = (0,external_wp_compose_namespaceObject.createHigherOrderComponent)(BlockListBlock => props => {
18778      const [allWrapperProps, setAllWrapperProps] = (0,external_wp_element_namespaceObject.useState)(Array(features.length).fill(undefined));
18779      return [...features.map((feature, i) => {
18780        const {
18781          hasSupport,
18782          attributeKeys = [],
18783          useBlockProps,
18784          isMatch
18785        } = feature;
18786        const neededProps = {};
18787        for (const key of attributeKeys) {
18788          if (props.attributes[key]) {
18789            neededProps[key] = props.attributes[key];
18790          }
18791        }
18792        if (
18793        // Skip rendering if none of the needed attributes are
18794        // set.
18795        !Object.keys(neededProps).length || !hasSupport(props.name) || isMatch && !isMatch(neededProps)) {
18796          return null;
18797        }
18798        return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockPropsPure
18799        // We can use the index because the array length
18800        // is fixed per page load right now.
18801        , {
18802          index: i,
18803          useBlockProps: useBlockProps
18804          // This component is pure, so we must pass a stable
18805          // function reference.
18806          ,
18807          setAllWrapperProps: setAllWrapperProps,
18808          name: props.name,
18809          clientId: props.clientId
18810          // This component is pure, so only pass needed
18811          // props!!!
18812          ,
18813          ...neededProps
18814        }, i);
18815      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockListBlock, {
18816        ...props,
18817        wrapperProps: allWrapperProps.filter(Boolean).reduce((acc, wrapperProps) => {
18818          return {
18819            ...acc,
18820            ...wrapperProps,
18821            className: dist_clsx(acc.className, wrapperProps.className),
18822            style: {
18823              ...acc.style,
18824              ...wrapperProps.style
18825            }
18826          };
18827        }, props.wrapperProps || {})
18828      }, "edit")];
18829    }, 'withBlockListBlockHooks');
18830    (0,external_wp_hooks_namespaceObject.addFilter)('editor.BlockListBlock', 'core/editor/hooks', withBlockListBlockHooks);
18831  }
18832  function createBlockSaveFilter(features) {
18833    function extraPropsFromHooks(props, name, attributes) {
18834      return features.reduce((accu, feature) => {
18835        const {
18836          hasSupport,
18837          attributeKeys = [],
18838          addSaveProps
18839        } = feature;
18840        const neededAttributes = {};
18841        for (const key of attributeKeys) {
18842          if (attributes[key]) {
18843            neededAttributes[key] = attributes[key];
18844          }
18845        }
18846        if (
18847        // Skip rendering if none of the needed attributes are
18848        // set.
18849        !Object.keys(neededAttributes).length || !hasSupport(name)) {
18850          return accu;
18851        }
18852        return addSaveProps(accu, name, neededAttributes);
18853      }, props);
18854    }
18855    (0,external_wp_hooks_namespaceObject.addFilter)('blocks.getSaveContent.extraProps', 'core/editor/hooks', extraPropsFromHooks, 0);
18856    (0,external_wp_hooks_namespaceObject.addFilter)('blocks.getSaveContent.extraProps', 'core/editor/hooks', props => {
18857      // Previously we had a filter deleting the className if it was an empty
18858      // string. That filter is no longer running, so now we need to delete it
18859      // here.
18860      if (props.hasOwnProperty('className') && !props.className) {
18861        delete props.className;
18862      }
18863      return props;
18864    });
18865  }
18866  
18867  ;// ./node_modules/@wordpress/block-editor/build-module/hooks/compat.js
18868  /**
18869   * WordPress dependencies
18870   */
18871  
18872  
18873  function migrateLightBlockWrapper(settings) {
18874    const {
18875      apiVersion = 1
18876    } = settings;
18877    if (apiVersion < 2 && (0,external_wp_blocks_namespaceObject.hasBlockSupport)(settings, 'lightBlockWrapper', false)) {
18878      settings.apiVersion = 2;
18879    }
18880    return settings;
18881  }
18882  (0,external_wp_hooks_namespaceObject.addFilter)('blocks.registerBlockType', 'core/compat/migrateLightBlockWrapper', migrateLightBlockWrapper);
18883  
18884  ;// external ["wp","components"]
18885  const external_wp_components_namespaceObject = window["wp"]["components"];
18886  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-controls/groups.js
18887  /**
18888   * WordPress dependencies
18889   */
18890  
18891  const BlockControlsDefault = (0,external_wp_components_namespaceObject.createSlotFill)('BlockControls');
18892  const BlockControlsBlock = (0,external_wp_components_namespaceObject.createSlotFill)('BlockControlsBlock');
18893  const BlockControlsInline = (0,external_wp_components_namespaceObject.createSlotFill)('BlockFormatControls');
18894  const BlockControlsOther = (0,external_wp_components_namespaceObject.createSlotFill)('BlockControlsOther');
18895  const BlockControlsParent = (0,external_wp_components_namespaceObject.createSlotFill)('BlockControlsParent');
18896  const groups = {
18897    default: BlockControlsDefault,
18898    block: BlockControlsBlock,
18899    inline: BlockControlsInline,
18900    other: BlockControlsOther,
18901    parent: BlockControlsParent
18902  };
18903  /* harmony default export */ const block_controls_groups = (groups);
18904  
18905  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-controls/hook.js
18906  /**
18907   * WordPress dependencies
18908   */
18909  
18910  /**
18911   * Internal dependencies
18912   */
18913  
18914  
18915  function useBlockControlsFill(group, shareWithChildBlocks) {
18916    const context = useBlockEditContext();
18917    if (context[mayDisplayControlsKey]) {
18918      return block_controls_groups[group]?.Fill;
18919    }
18920    if (context[mayDisplayParentControlsKey] && shareWithChildBlocks) {
18921      return block_controls_groups.parent.Fill;
18922    }
18923    return null;
18924  }
18925  
18926  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-controls/fill.js
18927  /**
18928   * WordPress dependencies
18929   */
18930  
18931  
18932  /**
18933   * Internal dependencies
18934   */
18935  
18936  
18937  function BlockControlsFill({
18938    group = 'default',
18939    controls,
18940    children,
18941    __experimentalShareWithChildBlocks = false
18942  }) {
18943    const Fill = useBlockControlsFill(group, __experimentalShareWithChildBlocks);
18944    if (!Fill) {
18945      return null;
18946    }
18947    const innerMarkup = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
18948      children: [group === 'default' && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarGroup, {
18949        controls: controls
18950      }), children]
18951    });
18952    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalStyleProvider, {
18953      document: document,
18954      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Fill, {
18955        children: fillProps => {
18956          // `fillProps.forwardedContext` is an array of context provider entries, provided by slot,
18957          // that should wrap the fill markup.
18958          const {
18959            forwardedContext = []
18960          } = fillProps;
18961          return forwardedContext.reduce((inner, [Provider, props]) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Provider, {
18962            ...props,
18963            children: inner
18964          }), innerMarkup);
18965        }
18966      })
18967    });
18968  }
18969  
18970  ;// external ["wp","warning"]
18971  const external_wp_warning_namespaceObject = window["wp"]["warning"];
18972  var external_wp_warning_default = /*#__PURE__*/__webpack_require__.n(external_wp_warning_namespaceObject);
18973  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-controls/slot.js
18974  /**
18975   * WordPress dependencies
18976   */
18977  
18978  
18979  
18980  
18981  /**
18982   * Internal dependencies
18983   */
18984  
18985  
18986  
18987  const {
18988    ComponentsContext
18989  } = unlock(external_wp_components_namespaceObject.privateApis);
18990  function BlockControlsSlot({
18991    group = 'default',
18992    ...props
18993  }) {
18994    const toolbarState = (0,external_wp_element_namespaceObject.useContext)(external_wp_components_namespaceObject.__experimentalToolbarContext);
18995    const contextState = (0,external_wp_element_namespaceObject.useContext)(ComponentsContext);
18996    const fillProps = (0,external_wp_element_namespaceObject.useMemo)(() => ({
18997      forwardedContext: [[external_wp_components_namespaceObject.__experimentalToolbarContext.Provider, {
18998        value: toolbarState
18999      }], [ComponentsContext.Provider, {
19000        value: contextState
19001      }]]
19002    }), [toolbarState, contextState]);
19003    const slotFill = block_controls_groups[group];
19004    const fills = (0,external_wp_components_namespaceObject.__experimentalUseSlotFills)(slotFill.name);
19005    if (!slotFill) {
19006       true ? external_wp_warning_default()(`Unknown BlockControls group "$group}" provided.`) : 0;
19007      return null;
19008    }
19009    if (!fills?.length) {
19010      return null;
19011    }
19012    const {
19013      Slot
19014    } = slotFill;
19015    const slot = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Slot, {
19016      ...props,
19017      bubblesVirtually: true,
19018      fillProps: fillProps
19019    });
19020    if (group === 'default') {
19021      return slot;
19022    }
19023    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarGroup, {
19024      children: slot
19025    });
19026  }
19027  
19028  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-controls/index.js
19029  /**
19030   * Internal dependencies
19031   */
19032  
19033  
19034  
19035  const BlockControls = BlockControlsFill;
19036  BlockControls.Slot = BlockControlsSlot;
19037  
19038  // This is just here for backward compatibility.
19039  const BlockFormatControls = props => {
19040    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockControlsFill, {
19041      group: "inline",
19042      ...props
19043    });
19044  };
19045  BlockFormatControls.Slot = props => {
19046    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockControlsSlot, {
19047      group: "inline",
19048      ...props
19049    });
19050  };
19051  /* harmony default export */ const block_controls = (BlockControls);
19052  
19053  ;// ./node_modules/@wordpress/icons/build-module/library/justify-left.js
19054  /**
19055   * WordPress dependencies
19056   */
19057  
19058  
19059  const justifyLeft = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
19060    xmlns: "http://www.w3.org/2000/svg",
19061    viewBox: "0 0 24 24",
19062    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
19063      d: "M9 9v6h11V9H9zM4 20h1.5V4H4v16z"
19064    })
19065  });
19066  /* harmony default export */ const justify_left = (justifyLeft);
19067  
19068  ;// ./node_modules/@wordpress/icons/build-module/library/justify-center.js
19069  /**
19070   * WordPress dependencies
19071   */
19072  
19073  
19074  const justifyCenter = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
19075    xmlns: "http://www.w3.org/2000/svg",
19076    viewBox: "0 0 24 24",
19077    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
19078      d: "M12.5 15v5H11v-5H4V9h7V4h1.5v5h7v6h-7Z"
19079    })
19080  });
19081  /* harmony default export */ const justify_center = (justifyCenter);
19082  
19083  ;// ./node_modules/@wordpress/icons/build-module/library/justify-right.js
19084  /**
19085   * WordPress dependencies
19086   */
19087  
19088  
19089  const justifyRight = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
19090    xmlns: "http://www.w3.org/2000/svg",
19091    viewBox: "0 0 24 24",
19092    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
19093      d: "M4 15h11V9H4v6zM18.5 4v16H20V4h-1.5z"
19094    })
19095  });
19096  /* harmony default export */ const justify_right = (justifyRight);
19097  
19098  ;// ./node_modules/@wordpress/icons/build-module/library/justify-space-between.js
19099  /**
19100   * WordPress dependencies
19101   */
19102  
19103  
19104  const justifySpaceBetween = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
19105    xmlns: "http://www.w3.org/2000/svg",
19106    viewBox: "0 0 24 24",
19107    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
19108      d: "M9 15h6V9H9v6zm-5 5h1.5V4H4v16zM18.5 4v16H20V4h-1.5z"
19109    })
19110  });
19111  /* harmony default export */ const justify_space_between = (justifySpaceBetween);
19112  
19113  ;// ./node_modules/@wordpress/icons/build-module/library/justify-stretch.js
19114  /**
19115   * WordPress dependencies
19116   */
19117  
19118  
19119  const justifyStretch = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
19120    xmlns: "http://www.w3.org/2000/svg",
19121    viewBox: "0 0 24 24",
19122    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
19123      d: "M4 4H5.5V20H4V4ZM7 10L17 10V14L7 14V10ZM20 4H18.5V20H20V4Z"
19124    })
19125  });
19126  /* harmony default export */ const justify_stretch = (justifyStretch);
19127  
19128  ;// ./node_modules/@wordpress/icons/build-module/library/arrow-right.js
19129  /**
19130   * WordPress dependencies
19131   */
19132  
19133  
19134  const arrowRight = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
19135    xmlns: "http://www.w3.org/2000/svg",
19136    viewBox: "0 0 24 24",
19137    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
19138      d: "m14.5 6.5-1 1 3.7 3.7H4v1.6h13.2l-3.7 3.7 1 1 5.6-5.5z"
19139    })
19140  });
19141  /* harmony default export */ const arrow_right = (arrowRight);
19142  
19143  ;// ./node_modules/@wordpress/icons/build-module/library/arrow-down.js
19144  /**
19145   * WordPress dependencies
19146   */
19147  
19148  
19149  const arrowDown = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
19150    xmlns: "http://www.w3.org/2000/svg",
19151    viewBox: "0 0 24 24",
19152    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
19153      d: "m16.5 13.5-3.7 3.7V4h-1.5v13.2l-3.8-3.7-1 1 5.5 5.6 5.5-5.6z"
19154    })
19155  });
19156  /* harmony default export */ const arrow_down = (arrowDown);
19157  
19158  ;// ./node_modules/@wordpress/block-editor/build-module/layouts/definitions.js
19159  // Layout definitions keyed by layout type.
19160  // Provides a common definition of slugs, classnames, base styles, and spacing styles for each layout type.
19161  // If making changes or additions to layout definitions, be sure to update the corresponding PHP definitions in
19162  // `block-supports/layout.php` so that the server-side and client-side definitions match.
19163  const LAYOUT_DEFINITIONS = {
19164    default: {
19165      name: 'default',
19166      slug: 'flow',
19167      className: 'is-layout-flow',
19168      baseStyles: [{
19169        selector: ' > .alignleft',
19170        rules: {
19171          float: 'left',
19172          'margin-inline-start': '0',
19173          'margin-inline-end': '2em'
19174        }
19175      }, {
19176        selector: ' > .alignright',
19177        rules: {
19178          float: 'right',
19179          'margin-inline-start': '2em',
19180          'margin-inline-end': '0'
19181        }
19182      }, {
19183        selector: ' > .aligncenter',
19184        rules: {
19185          'margin-left': 'auto !important',
19186          'margin-right': 'auto !important'
19187        }
19188      }],
19189      spacingStyles: [{
19190        selector: ' > :first-child',
19191        rules: {
19192          'margin-block-start': '0'
19193        }
19194      }, {
19195        selector: ' > :last-child',
19196        rules: {
19197          'margin-block-end': '0'
19198        }
19199      }, {
19200        selector: ' > *',
19201        rules: {
19202          'margin-block-start': null,
19203          'margin-block-end': '0'
19204        }
19205      }]
19206    },
19207    constrained: {
19208      name: 'constrained',
19209      slug: 'constrained',
19210      className: 'is-layout-constrained',
19211      baseStyles: [{
19212        selector: ' > .alignleft',
19213        rules: {
19214          float: 'left',
19215          'margin-inline-start': '0',
19216          'margin-inline-end': '2em'
19217        }
19218      }, {
19219        selector: ' > .alignright',
19220        rules: {
19221          float: 'right',
19222          'margin-inline-start': '2em',
19223          'margin-inline-end': '0'
19224        }
19225      }, {
19226        selector: ' > .aligncenter',
19227        rules: {
19228          'margin-left': 'auto !important',
19229          'margin-right': 'auto !important'
19230        }
19231      }, {
19232        selector: ' > :where(:not(.alignleft):not(.alignright):not(.alignfull))',
19233        rules: {
19234          'max-width': 'var(--wp--style--global--content-size)',
19235          'margin-left': 'auto !important',
19236          'margin-right': 'auto !important'
19237        }
19238      }, {
19239        selector: ' > .alignwide',
19240        rules: {
19241          'max-width': 'var(--wp--style--global--wide-size)'
19242        }
19243      }],
19244      spacingStyles: [{
19245        selector: ' > :first-child',
19246        rules: {
19247          'margin-block-start': '0'
19248        }
19249      }, {
19250        selector: ' > :last-child',
19251        rules: {
19252          'margin-block-end': '0'
19253        }
19254      }, {
19255        selector: ' > *',
19256        rules: {
19257          'margin-block-start': null,
19258          'margin-block-end': '0'
19259        }
19260      }]
19261    },
19262    flex: {
19263      name: 'flex',
19264      slug: 'flex',
19265      className: 'is-layout-flex',
19266      displayMode: 'flex',
19267      baseStyles: [{
19268        selector: '',
19269        rules: {
19270          'flex-wrap': 'wrap',
19271          'align-items': 'center'
19272        }
19273      }, {
19274        selector: ' > :is(*, div)',
19275        // :is(*, div) instead of just * increases the specificity by 001.
19276        rules: {
19277          margin: '0'
19278        }
19279      }],
19280      spacingStyles: [{
19281        selector: '',
19282        rules: {
19283          gap: null
19284        }
19285      }]
19286    },
19287    grid: {
19288      name: 'grid',
19289      slug: 'grid',
19290      className: 'is-layout-grid',
19291      displayMode: 'grid',
19292      baseStyles: [{
19293        selector: ' > :is(*, div)',
19294        // :is(*, div) instead of just * increases the specificity by 001.
19295        rules: {
19296          margin: '0'
19297        }
19298      }],
19299      spacingStyles: [{
19300        selector: '',
19301        rules: {
19302          gap: null
19303        }
19304      }]
19305    }
19306  };
19307  
19308  ;// ./node_modules/@wordpress/block-editor/build-module/layouts/utils.js
19309  /**
19310   * WordPress dependencies
19311   */
19312  
19313  
19314  /**
19315   * Internal dependencies
19316   */
19317  
19318  
19319  /**
19320   * Utility to generate the proper CSS selector for layout styles.
19321   *
19322   * @param {string} selectors CSS selector, also supports multiple comma-separated selectors.
19323   * @param {string} append    The string to append.
19324   *
19325   * @return {string} - CSS selector.
19326   */
19327  function appendSelectors(selectors, append = '') {
19328    return selectors.split(',').map(subselector => `$subselector}$append ? ` $append}` : ''}`).join(',');
19329  }
19330  
19331  /**
19332   * Get generated blockGap CSS rules based on layout definitions provided in theme.json
19333   * Falsy values in the layout definition's spacingStyles rules will be swapped out
19334   * with the provided `blockGapValue`.
19335   *
19336   * @param {string} selector          The CSS selector to target for the generated rules.
19337   * @param {Object} layoutDefinitions Layout definitions object.
19338   * @param {string} layoutType        The layout type (e.g. `default` or `flex`).
19339   * @param {string} blockGapValue     The current blockGap value to be applied.
19340   * @return {string} The generated CSS rules.
19341   */
19342  function getBlockGapCSS(selector, layoutDefinitions = LAYOUT_DEFINITIONS, layoutType, blockGapValue) {
19343    let output = '';
19344    if (layoutDefinitions?.[layoutType]?.spacingStyles?.length && blockGapValue) {
19345      layoutDefinitions[layoutType].spacingStyles.forEach(gapStyle => {
19346        output += `$appendSelectors(selector, gapStyle.selector.trim())} { `;
19347        output += Object.entries(gapStyle.rules).map(([cssProperty, value]) => `$cssProperty}: $value ? value : blockGapValue}`).join('; ');
19348        output += '; }';
19349      });
19350    }
19351    return output;
19352  }
19353  
19354  /**
19355   * Helper method to assign contextual info to clarify
19356   * alignment settings.
19357   *
19358   * Besides checking if `contentSize` and `wideSize` have a
19359   * value, we now show this information only if their values
19360   * are not a `css var`. This needs to change when parsing
19361   * css variables land.
19362   *
19363   * @see https://github.com/WordPress/gutenberg/pull/34710#issuecomment-918000752
19364   *
19365   * @param {Object} layout The layout object.
19366   * @return {Object} An object with contextual info per alignment.
19367   */
19368  function getAlignmentsInfo(layout) {
19369    const {
19370      contentSize,
19371      wideSize,
19372      type = 'default'
19373    } = layout;
19374    const alignmentInfo = {};
19375    const sizeRegex = /^(?!0)\d+(px|em|rem|vw|vh|%|svw|lvw|dvw|svh|lvh|dvh|vi|svi|lvi|dvi|vb|svb|lvb|dvb|vmin|svmin|lvmin|dvmin|vmax|svmax|lvmax|dvmax)?$/i;
19376    if (sizeRegex.test(contentSize) && type === 'constrained') {
19377      // translators: %s: container size (i.e. 600px etc)
19378      alignmentInfo.none = (0,external_wp_i18n_namespaceObject.sprintf)((0,external_wp_i18n_namespaceObject.__)('Max %s wide'), contentSize);
19379    }
19380    if (sizeRegex.test(wideSize)) {
19381      // translators: %s: container size (i.e. 600px etc)
19382      alignmentInfo.wide = (0,external_wp_i18n_namespaceObject.sprintf)((0,external_wp_i18n_namespaceObject.__)('Max %s wide'), wideSize);
19383    }
19384    return alignmentInfo;
19385  }
19386  
19387  ;// ./node_modules/@wordpress/icons/build-module/library/sides-all.js
19388  /**
19389   * WordPress dependencies
19390   */
19391  
19392  
19393  const sidesAll = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
19394    xmlns: "http://www.w3.org/2000/svg",
19395    viewBox: "0 0 24 24",
19396    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
19397      d: "m7.5 6h9v-1.5h-9zm0 13.5h9v-1.5h-9zm-3-3h1.5v-9h-1.5zm13.5-9v9h1.5v-9z"
19398    })
19399  });
19400  /* harmony default export */ const sides_all = (sidesAll);
19401  
19402  ;// ./node_modules/@wordpress/icons/build-module/library/sides-horizontal.js
19403  /**
19404   * WordPress dependencies
19405   */
19406  
19407  
19408  const sidesHorizontal = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_primitives_namespaceObject.SVG, {
19409    xmlns: "http://www.w3.org/2000/svg",
19410    viewBox: "0 0 24 24",
19411    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
19412      d: "m7.5 6h9v-1.5h-9zm0 13.5h9v-1.5h-9zm-3-3h1.5v-9h-1.5zm13.5-9v9h1.5v-9z",
19413      style: {
19414        opacity: 0.25
19415      }
19416    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
19417      d: "m4.5 7.5v9h1.5v-9z"
19418    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
19419      d: "m18 7.5v9h1.5v-9z"
19420    })]
19421  });
19422  /* harmony default export */ const sides_horizontal = (sidesHorizontal);
19423  
19424  ;// ./node_modules/@wordpress/icons/build-module/library/sides-vertical.js
19425  /**
19426   * WordPress dependencies
19427   */
19428  
19429  
19430  const sidesVertical = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_primitives_namespaceObject.SVG, {
19431    xmlns: "http://www.w3.org/2000/svg",
19432    viewBox: "0 0 24 24",
19433    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
19434      d: "m7.5 6h9v-1.5h-9zm0 13.5h9v-1.5h-9zm-3-3h1.5v-9h-1.5zm13.5-9v9h1.5v-9z",
19435      style: {
19436        opacity: 0.25
19437      }
19438    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
19439      d: "m7.5 6h9v-1.5h-9z"
19440    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
19441      d: "m7.5 19.5h9v-1.5h-9z"
19442    })]
19443  });
19444  /* harmony default export */ const sides_vertical = (sidesVertical);
19445  
19446  ;// ./node_modules/@wordpress/icons/build-module/library/sides-top.js
19447  /**
19448   * WordPress dependencies
19449   */
19450  
19451  
19452  const sidesTop = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_primitives_namespaceObject.SVG, {
19453    xmlns: "http://www.w3.org/2000/svg",
19454    viewBox: "0 0 24 24",
19455    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
19456      d: "m7.5 6h9v-1.5h-9zm0 13.5h9v-1.5h-9zm-3-3h1.5v-9h-1.5zm13.5-9v9h1.5v-9z",
19457      style: {
19458        opacity: 0.25
19459      }
19460    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
19461      d: "m16.5 6h-9v-1.5h9z"
19462    })]
19463  });
19464  /* harmony default export */ const sides_top = (sidesTop);
19465  
19466  ;// ./node_modules/@wordpress/icons/build-module/library/sides-right.js
19467  /**
19468   * WordPress dependencies
19469   */
19470  
19471  
19472  const sidesRight = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_primitives_namespaceObject.SVG, {
19473    xmlns: "http://www.w3.org/2000/svg",
19474    viewBox: "0 0 24 24",
19475    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
19476      d: "m7.5 6h9v-1.5h-9zm0 13.5h9v-1.5h-9zm-3-3h1.5v-9h-1.5zm13.5-9v9h1.5v-9z",
19477      style: {
19478        opacity: 0.25
19479      }
19480    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
19481      d: "m18 16.5v-9h1.5v9z"
19482    })]
19483  });
19484  /* harmony default export */ const sides_right = (sidesRight);
19485  
19486  ;// ./node_modules/@wordpress/icons/build-module/library/sides-bottom.js
19487  /**
19488   * WordPress dependencies
19489   */
19490  
19491  
19492  const sidesBottom = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_primitives_namespaceObject.SVG, {
19493    xmlns: "http://www.w3.org/2000/svg",
19494    viewBox: "0 0 24 24",
19495    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
19496      d: "m7.5 6h9v-1.5h-9zm0 13.5h9v-1.5h-9zm-3-3h1.5v-9h-1.5zm13.5-9v9h1.5v-9z",
19497      style: {
19498        opacity: 0.25
19499      }
19500    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
19501      d: "m16.5 19.5h-9v-1.5h9z"
19502    })]
19503  });
19504  /* harmony default export */ const sides_bottom = (sidesBottom);
19505  
19506  ;// ./node_modules/@wordpress/icons/build-module/library/sides-left.js
19507  /**
19508   * WordPress dependencies
19509   */
19510  
19511  
19512  const sidesLeft = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_primitives_namespaceObject.SVG, {
19513    xmlns: "http://www.w3.org/2000/svg",
19514    viewBox: "0 0 24 24",
19515    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
19516      d: "m7.5 6h9v-1.5h-9zm0 13.5h9v-1.5h-9zm-3-3h1.5v-9h-1.5zm13.5-9v9h1.5v-9z",
19517      style: {
19518        opacity: 0.25
19519      }
19520    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
19521      d: "m4.5 16.5v-9h1.5v9z"
19522    })]
19523  });
19524  /* harmony default export */ const sides_left = (sidesLeft);
19525  
19526  ;// ./node_modules/@wordpress/block-editor/build-module/components/spacing-sizes-control/utils.js
19527  /**
19528   * WordPress dependencies
19529   */
19530  
19531  
19532  const RANGE_CONTROL_MAX_SIZE = 8;
19533  const ALL_SIDES = ['top', 'right', 'bottom', 'left'];
19534  const DEFAULT_VALUES = {
19535    top: undefined,
19536    right: undefined,
19537    bottom: undefined,
19538    left: undefined
19539  };
19540  const ICONS = {
19541    custom: sides_all,
19542    axial: sides_all,
19543    horizontal: sides_horizontal,
19544    vertical: sides_vertical,
19545    top: sides_top,
19546    right: sides_right,
19547    bottom: sides_bottom,
19548    left: sides_left
19549  };
19550  const LABELS = {
19551    default: (0,external_wp_i18n_namespaceObject.__)('Spacing control'),
19552    top: (0,external_wp_i18n_namespaceObject.__)('Top'),
19553    bottom: (0,external_wp_i18n_namespaceObject.__)('Bottom'),
19554    left: (0,external_wp_i18n_namespaceObject.__)('Left'),
19555    right: (0,external_wp_i18n_namespaceObject.__)('Right'),
19556    mixed: (0,external_wp_i18n_namespaceObject.__)('Mixed'),
19557    vertical: (0,external_wp_i18n_namespaceObject.__)('Vertical'),
19558    horizontal: (0,external_wp_i18n_namespaceObject.__)('Horizontal'),
19559    axial: (0,external_wp_i18n_namespaceObject.__)('Horizontal & vertical'),
19560    custom: (0,external_wp_i18n_namespaceObject.__)('Custom')
19561  };
19562  const VIEWS = {
19563    axial: 'axial',
19564    top: 'top',
19565    right: 'right',
19566    bottom: 'bottom',
19567    left: 'left',
19568    custom: 'custom'
19569  };
19570  
19571  /**
19572   * Checks is given value is a spacing preset.
19573   *
19574   * @param {string} value Value to check
19575   *
19576   * @return {boolean} Return true if value is string in format var:preset|spacing|.
19577   */
19578  function isValueSpacingPreset(value) {
19579    if (!value?.includes) {
19580      return false;
19581    }
19582    return value === '0' || value.includes('var:preset|spacing|');
19583  }
19584  
19585  /**
19586   * Converts a spacing preset into a custom value.
19587   *
19588   * @param {string} value        Value to convert
19589   * @param {Array}  spacingSizes Array of the current spacing preset objects
19590   *
19591   * @return {string} Mapping of the spacing preset to its equivalent custom value.
19592   */
19593  function getCustomValueFromPreset(value, spacingSizes) {
19594    if (!isValueSpacingPreset(value)) {
19595      return value;
19596    }
19597    const slug = getSpacingPresetSlug(value);
19598    const spacingSize = spacingSizes.find(size => String(size.slug) === slug);
19599    return spacingSize?.size;
19600  }
19601  
19602  /**
19603   * Converts a custom value to preset value if one can be found.
19604   *
19605   * Returns value as-is if no match is found.
19606   *
19607   * @param {string} value        Value to convert
19608   * @param {Array}  spacingSizes Array of the current spacing preset objects
19609   *
19610   * @return {string} The preset value if it can be found.
19611   */
19612  function getPresetValueFromCustomValue(value, spacingSizes) {
19613    // Return value as-is if it is undefined or is already a preset, or '0';
19614    if (!value || isValueSpacingPreset(value) || value === '0') {
19615      return value;
19616    }
19617    const spacingMatch = spacingSizes.find(size => String(size.size) === String(value));
19618    if (spacingMatch?.slug) {
19619      return `var:preset|spacing|$spacingMatch.slug}`;
19620    }
19621    return value;
19622  }
19623  
19624  /**
19625   * Converts a spacing preset into a custom value.
19626   *
19627   * @param {string} value Value to convert.
19628   *
19629   * @return {string | undefined} CSS var string for given spacing preset value.
19630   */
19631  function getSpacingPresetCssVar(value) {
19632    if (!value) {
19633      return;
19634    }
19635    const slug = value.match(/var:preset\|spacing\|(.+)/);
19636    if (!slug) {
19637      return value;
19638    }
19639    return `var(--wp--preset--spacing--$slug[1]})`;
19640  }
19641  
19642  /**
19643   * Returns the slug section of the given spacing preset string.
19644   *
19645   * @param {string} value Value to extract slug from.
19646   *
19647   * @return {string|undefined} The int value of the slug from given spacing preset.
19648   */
19649  function getSpacingPresetSlug(value) {
19650    if (!value) {
19651      return;
19652    }
19653    if (value === '0' || value === 'default') {
19654      return value;
19655    }
19656    const slug = value.match(/var:preset\|spacing\|(.+)/);
19657    return slug ? slug[1] : undefined;
19658  }
19659  
19660  /**
19661   * Converts spacing preset value into a Range component value .
19662   *
19663   * @param {string} presetValue  Value to convert to Range value.
19664   * @param {Array}  spacingSizes Array of current spacing preset value objects.
19665   *
19666   * @return {number} The int value for use in Range control.
19667   */
19668  function getSliderValueFromPreset(presetValue, spacingSizes) {
19669    if (presetValue === undefined) {
19670      return 0;
19671    }
19672    const slug = parseFloat(presetValue, 10) === 0 ? '0' : getSpacingPresetSlug(presetValue);
19673    const sliderValue = spacingSizes.findIndex(spacingSize => {
19674      return String(spacingSize.slug) === slug;
19675    });
19676  
19677    // Returning NaN rather than undefined as undefined makes range control thumb sit in center
19678    return sliderValue !== -1 ? sliderValue : NaN;
19679  }
19680  
19681  /**
19682   * Determines whether a particular axis has support. If no axis is
19683   * specified, this function checks if either axis is supported.
19684   *
19685   * @param {Array}  sides Supported sides.
19686   * @param {string} axis  Which axis to check.
19687   *
19688   * @return {boolean} Whether there is support for the specified axis or both axes.
19689   */
19690  function hasAxisSupport(sides, axis) {
19691    if (!sides || !sides.length) {
19692      return false;
19693    }
19694    const hasHorizontalSupport = sides.includes('horizontal') || sides.includes('left') && sides.includes('right');
19695    const hasVerticalSupport = sides.includes('vertical') || sides.includes('top') && sides.includes('bottom');
19696    if (axis === 'horizontal') {
19697      return hasHorizontalSupport;
19698    }
19699    if (axis === 'vertical') {
19700      return hasVerticalSupport;
19701    }
19702    return hasHorizontalSupport || hasVerticalSupport;
19703  }
19704  
19705  /**
19706   * Checks if the supported sides are balanced for each axis.
19707   * - Horizontal - both left and right sides are supported.
19708   * - Vertical - both top and bottom are supported.
19709   *
19710   * @param {Array} sides The supported sides which may be axes as well.
19711   *
19712   * @return {boolean} Whether or not the supported sides are balanced.
19713   */
19714  function hasBalancedSidesSupport(sides = []) {
19715    const counts = {
19716      top: 0,
19717      right: 0,
19718      bottom: 0,
19719      left: 0
19720    };
19721    sides.forEach(side => counts[side] += 1);
19722    return (counts.top + counts.bottom) % 2 === 0 && (counts.left + counts.right) % 2 === 0;
19723  }
19724  
19725  /**
19726   * Determines which view the SpacingSizesControl should default to on its
19727   * first render; Axial, Custom, or Single side.
19728   *
19729   * @param {Object} values Current side values.
19730   * @param {Array}  sides  Supported sides.
19731   *
19732   * @return {string} View to display.
19733   */
19734  function getInitialView(values = {}, sides) {
19735    const {
19736      top,
19737      right,
19738      bottom,
19739      left
19740    } = values;
19741    const sideValues = [top, right, bottom, left].filter(Boolean);
19742  
19743    // Axial ( Horizontal & vertical ).
19744    // - Has axial side support
19745    // - Has axial side values which match
19746    // - Has no values and the supported sides are balanced
19747    const hasMatchingAxialValues = top === bottom && left === right && (!!top || !!left);
19748    const hasNoValuesAndBalancedSides = !sideValues.length && hasBalancedSidesSupport(sides);
19749    const hasOnlyAxialSides = sides?.includes('horizontal') && sides?.includes('vertical') && sides?.length === 2;
19750    if (hasAxisSupport(sides) && (hasMatchingAxialValues || hasNoValuesAndBalancedSides)) {
19751      return VIEWS.axial;
19752    }
19753  
19754    // Only axial sides are supported and single value defined.
19755    // - Ensure the side returned is the first side that has a value.
19756    if (hasOnlyAxialSides && sideValues.length === 1) {
19757      let side;
19758      Object.entries(values).some(([key, value]) => {
19759        side = key;
19760        return value !== undefined;
19761      });
19762      return side;
19763    }
19764  
19765    // Only single side supported and no value defined.
19766    if (sides?.length === 1 && !sideValues.length) {
19767      return sides[0];
19768    }
19769  
19770    // Default to the Custom (separated sides) view.
19771    return VIEWS.custom;
19772  }
19773  
19774  ;// ./node_modules/@wordpress/block-editor/build-module/hooks/gap.js
19775  /**
19776   * Internal dependencies
19777   */
19778  
19779  
19780  /**
19781   * Returns a BoxControl object value from a given blockGap style value.
19782   * The string check is for backwards compatibility before Gutenberg supported
19783   * split gap values (row and column) and the value was a string n + unit.
19784   *
19785   * @param {?string | ?Object} blockGapValue A block gap string or axial object value, e.g., '10px' or { top: '10px', left: '10px'}.
19786   * @return {Object|null}                    A value to pass to the BoxControl component.
19787   */
19788  function getGapBoxControlValueFromStyle(blockGapValue) {
19789    if (!blockGapValue) {
19790      return null;
19791    }
19792    const isValueString = typeof blockGapValue === 'string';
19793    return {
19794      top: isValueString ? blockGapValue : blockGapValue?.top,
19795      left: isValueString ? blockGapValue : blockGapValue?.left
19796    };
19797  }
19798  
19799  /**
19800   * Returns a CSS value for the `gap` property from a given blockGap style.
19801   *
19802   * @param {?string | ?Object} blockGapValue A block gap string or axial object value, e.g., '10px' or { top: '10px', left: '10px'}.
19803   * @param {?string}           defaultValue  A default gap value.
19804   * @return {string|null}                    The concatenated gap value (row and column).
19805   */
19806  function getGapCSSValue(blockGapValue, defaultValue = '0') {
19807    const blockGapBoxControlValue = getGapBoxControlValueFromStyle(blockGapValue);
19808    if (!blockGapBoxControlValue) {
19809      return null;
19810    }
19811    const row = getSpacingPresetCssVar(blockGapBoxControlValue?.top) || defaultValue;
19812    const column = getSpacingPresetCssVar(blockGapBoxControlValue?.left) || defaultValue;
19813    return row === column ? row : `$row} $column}`;
19814  }
19815  
19816  ;// ./node_modules/@wordpress/icons/build-module/library/justify-top.js
19817  /**
19818   * WordPress dependencies
19819   */
19820  
19821  
19822  const justifyTop = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
19823    xmlns: "http://www.w3.org/2000/svg",
19824    viewBox: "0 0 24 24",
19825    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
19826      d: "M9 20h6V9H9v11zM4 4v1.5h16V4H4z"
19827    })
19828  });
19829  /* harmony default export */ const justify_top = (justifyTop);
19830  
19831  ;// ./node_modules/@wordpress/icons/build-module/library/justify-center-vertical.js
19832  /**
19833   * WordPress dependencies
19834   */
19835  
19836  
19837  const justifyCenterVertical = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
19838    xmlns: "http://www.w3.org/2000/svg",
19839    viewBox: "0 0 24 24",
19840    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
19841      d: "M20 11h-5V4H9v7H4v1.5h5V20h6v-7.5h5z"
19842    })
19843  });
19844  /* harmony default export */ const justify_center_vertical = (justifyCenterVertical);
19845  
19846  ;// ./node_modules/@wordpress/icons/build-module/library/justify-bottom.js
19847  /**
19848   * WordPress dependencies
19849   */
19850  
19851  
19852  const justifyBottom = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
19853    xmlns: "http://www.w3.org/2000/svg",
19854    viewBox: "0 0 24 24",
19855    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
19856      d: "M15 4H9v11h6V4zM4 18.5V20h16v-1.5H4z"
19857    })
19858  });
19859  /* harmony default export */ const justify_bottom = (justifyBottom);
19860  
19861  ;// ./node_modules/@wordpress/icons/build-module/library/justify-stretch-vertical.js
19862  /**
19863   * WordPress dependencies
19864   */
19865  
19866  
19867  const justifyStretchVertical = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
19868    xmlns: "http://www.w3.org/2000/svg",
19869    viewBox: "0 0 24 24",
19870    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
19871      d: "M4 4L20 4L20 5.5L4 5.5L4 4ZM10 7L14 7L14 17L10 17L10 7ZM20 18.5L4 18.5L4 20L20 20L20 18.5Z"
19872    })
19873  });
19874  /* harmony default export */ const justify_stretch_vertical = (justifyStretchVertical);
19875  
19876  ;// ./node_modules/@wordpress/icons/build-module/library/justify-space-between-vertical.js
19877  /**
19878   * WordPress dependencies
19879   */
19880  
19881  
19882  const justifySpaceBetweenVertical = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
19883    xmlns: "http://www.w3.org/2000/svg",
19884    viewBox: "0 0 24 24",
19885    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
19886      d: "M7 4H17V8L7 8V4ZM7 16L17 16V20L7 20V16ZM20 11.25H4V12.75H20V11.25Z"
19887    })
19888  });
19889  /* harmony default export */ const justify_space_between_vertical = (justifySpaceBetweenVertical);
19890  
19891  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-vertical-alignment-control/ui.js
19892  /**
19893   * WordPress dependencies
19894   */
19895  
19896  
19897  
19898  
19899  const BLOCK_ALIGNMENTS_CONTROLS = {
19900    top: {
19901      icon: justify_top,
19902      title: (0,external_wp_i18n_namespaceObject._x)('Align top', 'Block vertical alignment setting')
19903    },
19904    center: {
19905      icon: justify_center_vertical,
19906      title: (0,external_wp_i18n_namespaceObject._x)('Align middle', 'Block vertical alignment setting')
19907    },
19908    bottom: {
19909      icon: justify_bottom,
19910      title: (0,external_wp_i18n_namespaceObject._x)('Align bottom', 'Block vertical alignment setting')
19911    },
19912    stretch: {
19913      icon: justify_stretch_vertical,
19914      title: (0,external_wp_i18n_namespaceObject._x)('Stretch to fill', 'Block vertical alignment setting')
19915    },
19916    'space-between': {
19917      icon: justify_space_between_vertical,
19918      title: (0,external_wp_i18n_namespaceObject._x)('Space between', 'Block vertical alignment setting')
19919    }
19920  };
19921  const DEFAULT_CONTROLS = ['top', 'center', 'bottom'];
19922  const DEFAULT_CONTROL = 'top';
19923  function BlockVerticalAlignmentUI({
19924    value,
19925    onChange,
19926    controls = DEFAULT_CONTROLS,
19927    isCollapsed = true,
19928    isToolbar
19929  }) {
19930    function applyOrUnset(align) {
19931      return () => onChange(value === align ? undefined : align);
19932    }
19933    const activeAlignment = BLOCK_ALIGNMENTS_CONTROLS[value];
19934    const defaultAlignmentControl = BLOCK_ALIGNMENTS_CONTROLS[DEFAULT_CONTROL];
19935    const UIComponent = isToolbar ? external_wp_components_namespaceObject.ToolbarGroup : external_wp_components_namespaceObject.ToolbarDropdownMenu;
19936    const extraProps = isToolbar ? {
19937      isCollapsed
19938    } : {};
19939    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(UIComponent, {
19940      icon: activeAlignment ? activeAlignment.icon : defaultAlignmentControl.icon,
19941      label: (0,external_wp_i18n_namespaceObject._x)('Change vertical alignment', 'Block vertical alignment setting label'),
19942      controls: controls.map(control => {
19943        return {
19944          ...BLOCK_ALIGNMENTS_CONTROLS[control],
19945          isActive: value === control,
19946          role: isCollapsed ? 'menuitemradio' : undefined,
19947          onClick: applyOrUnset(control)
19948        };
19949      }),
19950      ...extraProps
19951    });
19952  }
19953  
19954  /**
19955   * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/block-vertical-alignment-toolbar/README.md
19956   */
19957  /* harmony default export */ const ui = (BlockVerticalAlignmentUI);
19958  
19959  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-vertical-alignment-control/index.js
19960  /**
19961   * Internal dependencies
19962   */
19963  
19964  
19965  const BlockVerticalAlignmentControl = props => {
19966    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ui, {
19967      ...props,
19968      isToolbar: false
19969    });
19970  };
19971  const BlockVerticalAlignmentToolbar = props => {
19972    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ui, {
19973      ...props,
19974      isToolbar: true
19975    });
19976  };
19977  
19978  /**
19979   * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/block-vertical-alignment-control/README.md
19980   */
19981  
19982  
19983  ;// ./node_modules/@wordpress/block-editor/build-module/components/justify-content-control/ui.js
19984  /**
19985   * WordPress dependencies
19986   */
19987  
19988  
19989  
19990  
19991  const icons = {
19992    left: justify_left,
19993    center: justify_center,
19994    right: justify_right,
19995    'space-between': justify_space_between,
19996    stretch: justify_stretch
19997  };
19998  function JustifyContentUI({
19999    allowedControls = ['left', 'center', 'right', 'space-between'],
20000    isCollapsed = true,
20001    onChange,
20002    value,
20003    popoverProps,
20004    isToolbar
20005  }) {
20006    // If the control is already selected we want a click
20007    // again on the control to deselect the item, so we
20008    // call onChange( undefined )
20009    const handleClick = next => {
20010      if (next === value) {
20011        onChange(undefined);
20012      } else {
20013        onChange(next);
20014      }
20015    };
20016    const icon = value ? icons[value] : icons.left;
20017    const allControls = [{
20018      name: 'left',
20019      icon: justify_left,
20020      title: (0,external_wp_i18n_namespaceObject.__)('Justify items left'),
20021      isActive: 'left' === value,
20022      onClick: () => handleClick('left')
20023    }, {
20024      name: 'center',
20025      icon: justify_center,
20026      title: (0,external_wp_i18n_namespaceObject.__)('Justify items center'),
20027      isActive: 'center' === value,
20028      onClick: () => handleClick('center')
20029    }, {
20030      name: 'right',
20031      icon: justify_right,
20032      title: (0,external_wp_i18n_namespaceObject.__)('Justify items right'),
20033      isActive: 'right' === value,
20034      onClick: () => handleClick('right')
20035    }, {
20036      name: 'space-between',
20037      icon: justify_space_between,
20038      title: (0,external_wp_i18n_namespaceObject.__)('Space between items'),
20039      isActive: 'space-between' === value,
20040      onClick: () => handleClick('space-between')
20041    }, {
20042      name: 'stretch',
20043      icon: justify_stretch,
20044      title: (0,external_wp_i18n_namespaceObject.__)('Stretch items'),
20045      isActive: 'stretch' === value,
20046      onClick: () => handleClick('stretch')
20047    }];
20048    const UIComponent = isToolbar ? external_wp_components_namespaceObject.ToolbarGroup : external_wp_components_namespaceObject.ToolbarDropdownMenu;
20049    const extraProps = isToolbar ? {
20050      isCollapsed
20051    } : {};
20052    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(UIComponent, {
20053      icon: icon,
20054      popoverProps: popoverProps,
20055      label: (0,external_wp_i18n_namespaceObject.__)('Change items justification'),
20056      controls: allControls.filter(elem => allowedControls.includes(elem.name)),
20057      ...extraProps
20058    });
20059  }
20060  /* harmony default export */ const justify_content_control_ui = (JustifyContentUI);
20061  
20062  ;// ./node_modules/@wordpress/block-editor/build-module/components/justify-content-control/index.js
20063  /**
20064   * Internal dependencies
20065   */
20066  
20067  
20068  const JustifyContentControl = props => {
20069    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(justify_content_control_ui, {
20070      ...props,
20071      isToolbar: false
20072    });
20073  };
20074  const JustifyToolbar = props => {
20075    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(justify_content_control_ui, {
20076      ...props,
20077      isToolbar: true
20078    });
20079  };
20080  
20081  /**
20082   * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/justify-content-control/README.md
20083   */
20084  
20085  
20086  ;// ./node_modules/@wordpress/block-editor/build-module/layouts/flex.js
20087  /**
20088   * WordPress dependencies
20089   */
20090  
20091  
20092  
20093  
20094  /**
20095   * Internal dependencies
20096   */
20097  
20098  
20099  
20100  
20101  
20102  
20103  // Used with the default, horizontal flex orientation.
20104  
20105  const justifyContentMap = {
20106    left: 'flex-start',
20107    right: 'flex-end',
20108    center: 'center',
20109    'space-between': 'space-between'
20110  };
20111  
20112  // Used with the vertical (column) flex orientation.
20113  const alignItemsMap = {
20114    left: 'flex-start',
20115    right: 'flex-end',
20116    center: 'center',
20117    stretch: 'stretch'
20118  };
20119  const verticalAlignmentMap = {
20120    top: 'flex-start',
20121    center: 'center',
20122    bottom: 'flex-end',
20123    stretch: 'stretch',
20124    'space-between': 'space-between'
20125  };
20126  const flexWrapOptions = ['wrap', 'nowrap'];
20127  /* harmony default export */ const flex = ({
20128    name: 'flex',
20129    label: (0,external_wp_i18n_namespaceObject.__)('Flex'),
20130    inspectorControls: function FlexLayoutInspectorControls({
20131      layout = {},
20132      onChange,
20133      layoutBlockSupport = {}
20134    }) {
20135      const {
20136        allowOrientation = true,
20137        allowJustification = true
20138      } = layoutBlockSupport;
20139      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
20140        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.Flex, {
20141          children: [allowJustification && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FlexItem, {
20142            children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(FlexLayoutJustifyContentControl, {
20143              layout: layout,
20144              onChange: onChange
20145            })
20146          }), allowOrientation && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FlexItem, {
20147            children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(OrientationControl, {
20148              layout: layout,
20149              onChange: onChange
20150            })
20151          })]
20152        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(FlexWrapControl, {
20153          layout: layout,
20154          onChange: onChange
20155        })]
20156      });
20157    },
20158    toolBarControls: function FlexLayoutToolbarControls({
20159      layout = {},
20160      onChange,
20161      layoutBlockSupport
20162    }) {
20163      const {
20164        allowVerticalAlignment = true,
20165        allowJustification = true
20166      } = layoutBlockSupport;
20167      if (!allowJustification && !allowVerticalAlignment) {
20168        return null;
20169      }
20170      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(block_controls, {
20171        group: "block",
20172        __experimentalShareWithChildBlocks: true,
20173        children: [allowJustification && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(FlexLayoutJustifyContentControl, {
20174          layout: layout,
20175          onChange: onChange,
20176          isToolbar: true
20177        }), allowVerticalAlignment && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(FlexLayoutVerticalAlignmentControl, {
20178          layout: layout,
20179          onChange: onChange
20180        })]
20181      });
20182    },
20183    getLayoutStyle: function getLayoutStyle({
20184      selector,
20185      layout,
20186      style,
20187      blockName,
20188      hasBlockGapSupport,
20189      layoutDefinitions = LAYOUT_DEFINITIONS
20190    }) {
20191      const {
20192        orientation = 'horizontal'
20193      } = layout;
20194  
20195      // If a block's block.json skips serialization for spacing or spacing.blockGap,
20196      // don't apply the user-defined value to the styles.
20197      const blockGapValue = style?.spacing?.blockGap && !shouldSkipSerialization(blockName, 'spacing', 'blockGap') ? getGapCSSValue(style?.spacing?.blockGap, '0.5em') : undefined;
20198      const justifyContent = justifyContentMap[layout.justifyContent];
20199      const flexWrap = flexWrapOptions.includes(layout.flexWrap) ? layout.flexWrap : 'wrap';
20200      const verticalAlignment = verticalAlignmentMap[layout.verticalAlignment];
20201      const alignItems = alignItemsMap[layout.justifyContent] || alignItemsMap.left;
20202      let output = '';
20203      const rules = [];
20204      if (flexWrap && flexWrap !== 'wrap') {
20205        rules.push(`flex-wrap: $flexWrap}`);
20206      }
20207      if (orientation === 'horizontal') {
20208        if (verticalAlignment) {
20209          rules.push(`align-items: $verticalAlignment}`);
20210        }
20211        if (justifyContent) {
20212          rules.push(`justify-content: $justifyContent}`);
20213        }
20214      } else {
20215        if (verticalAlignment) {
20216          rules.push(`justify-content: $verticalAlignment}`);
20217        }
20218        rules.push('flex-direction: column');
20219        rules.push(`align-items: $alignItems}`);
20220      }
20221      if (rules.length) {
20222        output = `$appendSelectors(selector)} {
20223                  $rules.join('; ')};
20224              }`;
20225      }
20226  
20227      // Output blockGap styles based on rules contained in layout definitions in theme.json.
20228      if (hasBlockGapSupport && blockGapValue) {
20229        output += getBlockGapCSS(selector, layoutDefinitions, 'flex', blockGapValue);
20230      }
20231      return output;
20232    },
20233    getOrientation(layout) {
20234      const {
20235        orientation = 'horizontal'
20236      } = layout;
20237      return orientation;
20238    },
20239    getAlignments() {
20240      return [];
20241    }
20242  });
20243  function FlexLayoutVerticalAlignmentControl({
20244    layout,
20245    onChange
20246  }) {
20247    const {
20248      orientation = 'horizontal'
20249    } = layout;
20250    const defaultVerticalAlignment = orientation === 'horizontal' ? verticalAlignmentMap.center : verticalAlignmentMap.top;
20251    const {
20252      verticalAlignment = defaultVerticalAlignment
20253    } = layout;
20254    const onVerticalAlignmentChange = value => {
20255      onChange({
20256        ...layout,
20257        verticalAlignment: value
20258      });
20259    };
20260    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockVerticalAlignmentControl, {
20261      onChange: onVerticalAlignmentChange,
20262      value: verticalAlignment,
20263      controls: orientation === 'horizontal' ? ['top', 'center', 'bottom', 'stretch'] : ['top', 'center', 'bottom', 'space-between']
20264    });
20265  }
20266  const POPOVER_PROPS = {
20267    placement: 'bottom-start'
20268  };
20269  function FlexLayoutJustifyContentControl({
20270    layout,
20271    onChange,
20272    isToolbar = false
20273  }) {
20274    const {
20275      justifyContent = 'left',
20276      orientation = 'horizontal'
20277    } = layout;
20278    const onJustificationChange = value => {
20279      onChange({
20280        ...layout,
20281        justifyContent: value
20282      });
20283    };
20284    const allowedControls = ['left', 'center', 'right'];
20285    if (orientation === 'horizontal') {
20286      allowedControls.push('space-between');
20287    } else {
20288      allowedControls.push('stretch');
20289    }
20290    if (isToolbar) {
20291      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(JustifyContentControl, {
20292        allowedControls: allowedControls,
20293        value: justifyContent,
20294        onChange: onJustificationChange,
20295        popoverProps: POPOVER_PROPS
20296      });
20297    }
20298    const justificationOptions = [{
20299      value: 'left',
20300      icon: justify_left,
20301      label: (0,external_wp_i18n_namespaceObject.__)('Justify items left')
20302    }, {
20303      value: 'center',
20304      icon: justify_center,
20305      label: (0,external_wp_i18n_namespaceObject.__)('Justify items center')
20306    }, {
20307      value: 'right',
20308      icon: justify_right,
20309      label: (0,external_wp_i18n_namespaceObject.__)('Justify items right')
20310    }];
20311    if (orientation === 'horizontal') {
20312      justificationOptions.push({
20313        value: 'space-between',
20314        icon: justify_space_between,
20315        label: (0,external_wp_i18n_namespaceObject.__)('Space between items')
20316      });
20317    } else {
20318      justificationOptions.push({
20319        value: 'stretch',
20320        icon: justify_stretch,
20321        label: (0,external_wp_i18n_namespaceObject.__)('Stretch items')
20322      });
20323    }
20324    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControl, {
20325      __next40pxDefaultSize: true,
20326      __nextHasNoMarginBottom: true,
20327      label: (0,external_wp_i18n_namespaceObject.__)('Justification'),
20328      value: justifyContent,
20329      onChange: onJustificationChange,
20330      className: "block-editor-hooks__flex-layout-justification-controls",
20331      children: justificationOptions.map(({
20332        value,
20333        icon,
20334        label
20335      }) => {
20336        return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControlOptionIcon, {
20337          value: value,
20338          icon: icon,
20339          label: label
20340        }, value);
20341      })
20342    });
20343  }
20344  function FlexWrapControl({
20345    layout,
20346    onChange
20347  }) {
20348    const {
20349      flexWrap = 'wrap'
20350    } = layout;
20351    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToggleControl, {
20352      __nextHasNoMarginBottom: true,
20353      label: (0,external_wp_i18n_namespaceObject.__)('Allow to wrap to multiple lines'),
20354      onChange: value => {
20355        onChange({
20356          ...layout,
20357          flexWrap: value ? 'wrap' : 'nowrap'
20358        });
20359      },
20360      checked: flexWrap === 'wrap'
20361    });
20362  }
20363  function OrientationControl({
20364    layout,
20365    onChange
20366  }) {
20367    const {
20368      orientation = 'horizontal',
20369      verticalAlignment,
20370      justifyContent
20371    } = layout;
20372    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalToggleGroupControl, {
20373      __next40pxDefaultSize: true,
20374      __nextHasNoMarginBottom: true,
20375      className: "block-editor-hooks__flex-layout-orientation-controls",
20376      label: (0,external_wp_i18n_namespaceObject.__)('Orientation'),
20377      value: orientation,
20378      onChange: value => {
20379        // Make sure the vertical alignment and justification are compatible with the new orientation.
20380        let newVerticalAlignment = verticalAlignment;
20381        let newJustification = justifyContent;
20382        if (value === 'horizontal') {
20383          if (verticalAlignment === 'space-between') {
20384            newVerticalAlignment = 'center';
20385          }
20386          if (justifyContent === 'stretch') {
20387            newJustification = 'left';
20388          }
20389        } else {
20390          if (verticalAlignment === 'stretch') {
20391            newVerticalAlignment = 'top';
20392          }
20393          if (justifyContent === 'space-between') {
20394            newJustification = 'left';
20395          }
20396        }
20397        return onChange({
20398          ...layout,
20399          orientation: value,
20400          verticalAlignment: newVerticalAlignment,
20401          justifyContent: newJustification
20402        });
20403      },
20404      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControlOptionIcon, {
20405        icon: arrow_right,
20406        value: "horizontal",
20407        label: (0,external_wp_i18n_namespaceObject.__)('Horizontal')
20408      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControlOptionIcon, {
20409        icon: arrow_down,
20410        value: "vertical",
20411        label: (0,external_wp_i18n_namespaceObject.__)('Vertical')
20412      })]
20413    });
20414  }
20415  
20416  ;// ./node_modules/@wordpress/block-editor/build-module/layouts/flow.js
20417  /**
20418   * WordPress dependencies
20419   */
20420  
20421  
20422  /**
20423   * Internal dependencies
20424   */
20425  
20426  
20427  
20428  
20429  /* harmony default export */ const flow = ({
20430    name: 'default',
20431    label: (0,external_wp_i18n_namespaceObject.__)('Flow'),
20432    inspectorControls: function DefaultLayoutInspectorControls() {
20433      return null;
20434    },
20435    toolBarControls: function DefaultLayoutToolbarControls() {
20436      return null;
20437    },
20438    getLayoutStyle: function getLayoutStyle({
20439      selector,
20440      style,
20441      blockName,
20442      hasBlockGapSupport,
20443      layoutDefinitions = LAYOUT_DEFINITIONS
20444    }) {
20445      const blockGapStyleValue = getGapCSSValue(style?.spacing?.blockGap);
20446  
20447      // If a block's block.json skips serialization for spacing or
20448      // spacing.blockGap, don't apply the user-defined value to the styles.
20449      let blockGapValue = '';
20450      if (!shouldSkipSerialization(blockName, 'spacing', 'blockGap')) {
20451        // If an object is provided only use the 'top' value for this kind of gap.
20452        if (blockGapStyleValue?.top) {
20453          blockGapValue = getGapCSSValue(blockGapStyleValue?.top);
20454        } else if (typeof blockGapStyleValue === 'string') {
20455          blockGapValue = getGapCSSValue(blockGapStyleValue);
20456        }
20457      }
20458      let output = '';
20459  
20460      // Output blockGap styles based on rules contained in layout definitions in theme.json.
20461      if (hasBlockGapSupport && blockGapValue) {
20462        output += getBlockGapCSS(selector, layoutDefinitions, 'default', blockGapValue);
20463      }
20464      return output;
20465    },
20466    getOrientation() {
20467      return 'vertical';
20468    },
20469    getAlignments(layout, isBlockBasedTheme) {
20470      const alignmentInfo = getAlignmentsInfo(layout);
20471      if (layout.alignments !== undefined) {
20472        if (!layout.alignments.includes('none')) {
20473          layout.alignments.unshift('none');
20474        }
20475        return layout.alignments.map(alignment => ({
20476          name: alignment,
20477          info: alignmentInfo[alignment]
20478        }));
20479      }
20480      const alignments = [{
20481        name: 'left'
20482      }, {
20483        name: 'center'
20484      }, {
20485        name: 'right'
20486      }];
20487  
20488      // This is for backwards compatibility with hybrid themes.
20489      if (!isBlockBasedTheme) {
20490        const {
20491          contentSize,
20492          wideSize
20493        } = layout;
20494        if (contentSize) {
20495          alignments.unshift({
20496            name: 'full'
20497          });
20498        }
20499        if (wideSize) {
20500          alignments.unshift({
20501            name: 'wide',
20502            info: alignmentInfo.wide
20503          });
20504        }
20505      }
20506      alignments.unshift({
20507        name: 'none',
20508        info: alignmentInfo.none
20509      });
20510      return alignments;
20511    }
20512  });
20513  
20514  ;// ./node_modules/@wordpress/icons/build-module/icon/index.js
20515  /**
20516   * WordPress dependencies
20517   */
20518  
20519  
20520  /** @typedef {{icon: JSX.Element, size?: number} & import('@wordpress/primitives').SVGProps} IconProps */
20521  
20522  /**
20523   * Return an SVG icon.
20524   *
20525   * @param {IconProps}                                 props icon is the SVG component to render
20526   *                                                          size is a number specifying the icon size in pixels
20527   *                                                          Other props will be passed to wrapped SVG component
20528   * @param {import('react').ForwardedRef<HTMLElement>} ref   The forwarded ref to the SVG element.
20529   *
20530   * @return {JSX.Element}  Icon component
20531   */
20532  function Icon({
20533    icon,
20534    size = 24,
20535    ...props
20536  }, ref) {
20537    return (0,external_wp_element_namespaceObject.cloneElement)(icon, {
20538      width: size,
20539      height: size,
20540      ...props,
20541      ref
20542    });
20543  }
20544  /* harmony default export */ const build_module_icon = ((0,external_wp_element_namespaceObject.forwardRef)(Icon));
20545  
20546  ;// ./node_modules/@wordpress/icons/build-module/library/align-none.js
20547  /**
20548   * WordPress dependencies
20549   */
20550  
20551  
20552  const alignNone = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
20553    xmlns: "http://www.w3.org/2000/svg",
20554    viewBox: "0 0 24 24",
20555    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
20556      d: "M19 5.5H5V4h14v1.5ZM19 20H5v-1.5h14V20ZM5 9h14v6H5V9Z"
20557    })
20558  });
20559  /* harmony default export */ const align_none = (alignNone);
20560  
20561  ;// ./node_modules/@wordpress/icons/build-module/library/stretch-wide.js
20562  /**
20563   * WordPress dependencies
20564   */
20565  
20566  
20567  const stretchWide = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
20568    xmlns: "http://www.w3.org/2000/svg",
20569    viewBox: "0 0 24 24",
20570    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
20571      d: "M16 5.5H8V4h8v1.5ZM16 20H8v-1.5h8V20ZM5 9h14v6H5V9Z"
20572    })
20573  });
20574  /* harmony default export */ const stretch_wide = (stretchWide);
20575  
20576  ;// ./node_modules/@wordpress/block-editor/build-module/layouts/constrained.js
20577  /**
20578   * WordPress dependencies
20579   */
20580  
20581  
20582  
20583  
20584  
20585  /**
20586   * Internal dependencies
20587   */
20588  
20589  
20590  
20591  
20592  
20593  
20594  
20595  /* harmony default export */ const constrained = ({
20596    name: 'constrained',
20597    label: (0,external_wp_i18n_namespaceObject.__)('Constrained'),
20598    inspectorControls: function DefaultLayoutInspectorControls({
20599      layout,
20600      onChange,
20601      layoutBlockSupport = {}
20602    }) {
20603      const {
20604        wideSize,
20605        contentSize,
20606        justifyContent = 'center'
20607      } = layout;
20608      const {
20609        allowJustification = true,
20610        allowCustomContentAndWideSize = true
20611      } = layoutBlockSupport;
20612      const onJustificationChange = value => {
20613        onChange({
20614          ...layout,
20615          justifyContent: value
20616        });
20617      };
20618      const justificationOptions = [{
20619        value: 'left',
20620        icon: justify_left,
20621        label: (0,external_wp_i18n_namespaceObject.__)('Justify items left')
20622      }, {
20623        value: 'center',
20624        icon: justify_center,
20625        label: (0,external_wp_i18n_namespaceObject.__)('Justify items center')
20626      }, {
20627        value: 'right',
20628        icon: justify_right,
20629        label: (0,external_wp_i18n_namespaceObject.__)('Justify items right')
20630      }];
20631      const [availableUnits] = use_settings_useSettings('spacing.units');
20632      const units = (0,external_wp_components_namespaceObject.__experimentalUseCustomUnits)({
20633        availableUnits: availableUnits || ['%', 'px', 'em', 'rem', 'vw']
20634      });
20635      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalVStack, {
20636        spacing: 4,
20637        className: "block-editor-hooks__layout-constrained",
20638        children: [allowCustomContentAndWideSize && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
20639          children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalUnitControl, {
20640            __next40pxDefaultSize: true,
20641            label: (0,external_wp_i18n_namespaceObject.__)('Content width'),
20642            labelPosition: "top",
20643            value: contentSize || wideSize || '',
20644            onChange: nextWidth => {
20645              nextWidth = 0 > parseFloat(nextWidth) ? '0' : nextWidth;
20646              onChange({
20647                ...layout,
20648                contentSize: nextWidth
20649              });
20650            },
20651            units: units,
20652            prefix: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalInputControlPrefixWrapper, {
20653              variant: "icon",
20654              children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(build_module_icon, {
20655                icon: align_none
20656              })
20657            })
20658          }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalUnitControl, {
20659            __next40pxDefaultSize: true,
20660            label: (0,external_wp_i18n_namespaceObject.__)('Wide width'),
20661            labelPosition: "top",
20662            value: wideSize || contentSize || '',
20663            onChange: nextWidth => {
20664              nextWidth = 0 > parseFloat(nextWidth) ? '0' : nextWidth;
20665              onChange({
20666                ...layout,
20667                wideSize: nextWidth
20668              });
20669            },
20670            units: units,
20671            prefix: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalInputControlPrefixWrapper, {
20672              variant: "icon",
20673              children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(build_module_icon, {
20674                icon: stretch_wide
20675              })
20676            })
20677          }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("p", {
20678            className: "block-editor-hooks__layout-constrained-helptext",
20679            children: (0,external_wp_i18n_namespaceObject.__)('Customize the width for all elements that are assigned to the center or wide columns.')
20680          })]
20681        }), allowJustification && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControl, {
20682          __next40pxDefaultSize: true,
20683          __nextHasNoMarginBottom: true,
20684          label: (0,external_wp_i18n_namespaceObject.__)('Justification'),
20685          value: justifyContent,
20686          onChange: onJustificationChange,
20687          children: justificationOptions.map(({
20688            value,
20689            icon,
20690            label
20691          }) => {
20692            return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControlOptionIcon, {
20693              value: value,
20694              icon: icon,
20695              label: label
20696            }, value);
20697          })
20698        })]
20699      });
20700    },
20701    toolBarControls: function DefaultLayoutToolbarControls({
20702      layout = {},
20703      onChange,
20704      layoutBlockSupport
20705    }) {
20706      const {
20707        allowJustification = true
20708      } = layoutBlockSupport;
20709      if (!allowJustification) {
20710        return null;
20711      }
20712      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_controls, {
20713        group: "block",
20714        __experimentalShareWithChildBlocks: true,
20715        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(DefaultLayoutJustifyContentControl, {
20716          layout: layout,
20717          onChange: onChange
20718        })
20719      });
20720    },
20721    getLayoutStyle: function getLayoutStyle({
20722      selector,
20723      layout = {},
20724      style,
20725      blockName,
20726      hasBlockGapSupport,
20727      layoutDefinitions = LAYOUT_DEFINITIONS
20728    }) {
20729      const {
20730        contentSize,
20731        wideSize,
20732        justifyContent
20733      } = layout;
20734      const blockGapStyleValue = getGapCSSValue(style?.spacing?.blockGap);
20735  
20736      // If a block's block.json skips serialization for spacing or
20737      // spacing.blockGap, don't apply the user-defined value to the styles.
20738      let blockGapValue = '';
20739      if (!shouldSkipSerialization(blockName, 'spacing', 'blockGap')) {
20740        // If an object is provided only use the 'top' value for this kind of gap.
20741        if (blockGapStyleValue?.top) {
20742          blockGapValue = getGapCSSValue(blockGapStyleValue?.top);
20743        } else if (typeof blockGapStyleValue === 'string') {
20744          blockGapValue = getGapCSSValue(blockGapStyleValue);
20745        }
20746      }
20747      const marginLeft = justifyContent === 'left' ? '0 !important' : 'auto !important';
20748      const marginRight = justifyContent === 'right' ? '0 !important' : 'auto !important';
20749      let output = !!contentSize || !!wideSize ? `
20750                      $appendSelectors(selector, '> :where(:not(.alignleft):not(.alignright):not(.alignfull))')} {
20751                          max-width: $contentSize !== null && contentSize !== void 0 ? contentSize : wideSize};
20752                          margin-left: $marginLeft};
20753                          margin-right: $marginRight};
20754                      }
20755                      $appendSelectors(selector, '> .alignwide')}  {
20756                          max-width: $wideSize !== null && wideSize !== void 0 ? wideSize : contentSize};
20757                      }
20758                      $appendSelectors(selector, '> .alignfull')} {
20759                          max-width: none;
20760                      }
20761                  ` : '';
20762      if (justifyContent === 'left') {
20763        output += `$appendSelectors(selector, '> :where(:not(.alignleft):not(.alignright):not(.alignfull))')}
20764              { margin-left: $marginLeft}; }`;
20765      } else if (justifyContent === 'right') {
20766        output += `$appendSelectors(selector, '> :where(:not(.alignleft):not(.alignright):not(.alignfull))')}
20767              { margin-right: $marginRight}; }`;
20768      }
20769  
20770      // If there is custom padding, add negative margins for alignfull blocks.
20771      if (style?.spacing?.padding) {
20772        // The style object might be storing a preset so we need to make sure we get a usable value.
20773        const paddingValues = (0,external_wp_styleEngine_namespaceObject.getCSSRules)(style);
20774        paddingValues.forEach(rule => {
20775          if (rule.key === 'paddingRight') {
20776            // Add unit if 0, to avoid calc(0 * -1) which is invalid.
20777            const paddingRightValue = rule.value === '0' ? '0px' : rule.value;
20778            output += `
20779                      $appendSelectors(selector, '> .alignfull')} {
20780                          margin-right: calc($paddingRightValue} * -1);
20781                      }
20782                      `;
20783          } else if (rule.key === 'paddingLeft') {
20784            // Add unit if 0, to avoid calc(0 * -1) which is invalid.
20785            const paddingLeftValue = rule.value === '0' ? '0px' : rule.value;
20786            output += `
20787                      $appendSelectors(selector, '> .alignfull')} {
20788                          margin-left: calc($paddingLeftValue} * -1);
20789                      }
20790                      `;
20791          }
20792        });
20793      }
20794  
20795      // Output blockGap styles based on rules contained in layout definitions in theme.json.
20796      if (hasBlockGapSupport && blockGapValue) {
20797        output += getBlockGapCSS(selector, layoutDefinitions, 'constrained', blockGapValue);
20798      }
20799      return output;
20800    },
20801    getOrientation() {
20802      return 'vertical';
20803    },
20804    getAlignments(layout) {
20805      const alignmentInfo = getAlignmentsInfo(layout);
20806      if (layout.alignments !== undefined) {
20807        if (!layout.alignments.includes('none')) {
20808          layout.alignments.unshift('none');
20809        }
20810        return layout.alignments.map(alignment => ({
20811          name: alignment,
20812          info: alignmentInfo[alignment]
20813        }));
20814      }
20815      const {
20816        contentSize,
20817        wideSize
20818      } = layout;
20819      const alignments = [{
20820        name: 'left'
20821      }, {
20822        name: 'center'
20823      }, {
20824        name: 'right'
20825      }];
20826      if (contentSize) {
20827        alignments.unshift({
20828          name: 'full'
20829        });
20830      }
20831      if (wideSize) {
20832        alignments.unshift({
20833          name: 'wide',
20834          info: alignmentInfo.wide
20835        });
20836      }
20837      alignments.unshift({
20838        name: 'none',
20839        info: alignmentInfo.none
20840      });
20841      return alignments;
20842    }
20843  });
20844  const constrained_POPOVER_PROPS = {
20845    placement: 'bottom-start'
20846  };
20847  function DefaultLayoutJustifyContentControl({
20848    layout,
20849    onChange
20850  }) {
20851    const {
20852      justifyContent = 'center'
20853    } = layout;
20854    const onJustificationChange = value => {
20855      onChange({
20856        ...layout,
20857        justifyContent: value
20858      });
20859    };
20860    const allowedControls = ['left', 'center', 'right'];
20861    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(JustifyContentControl, {
20862      allowedControls: allowedControls,
20863      value: justifyContent,
20864      onChange: onJustificationChange,
20865      popoverProps: constrained_POPOVER_PROPS
20866    });
20867  }
20868  
20869  ;// ./node_modules/@wordpress/block-editor/build-module/layouts/grid.js
20870  /**
20871   * WordPress dependencies
20872   */
20873  
20874  
20875  
20876  
20877  /**
20878   * Internal dependencies
20879   */
20880  
20881  
20882  
20883  
20884  
20885  const RANGE_CONTROL_MAX_VALUES = {
20886    px: 600,
20887    '%': 100,
20888    vw: 100,
20889    vh: 100,
20890    em: 38,
20891    rem: 38,
20892    svw: 100,
20893    lvw: 100,
20894    dvw: 100,
20895    svh: 100,
20896    lvh: 100,
20897    dvh: 100,
20898    vi: 100,
20899    svi: 100,
20900    lvi: 100,
20901    dvi: 100,
20902    vb: 100,
20903    svb: 100,
20904    lvb: 100,
20905    dvb: 100,
20906    vmin: 100,
20907    svmin: 100,
20908    lvmin: 100,
20909    dvmin: 100,
20910    vmax: 100,
20911    svmax: 100,
20912    lvmax: 100,
20913    dvmax: 100
20914  };
20915  const units = [{
20916    value: 'px',
20917    label: 'px',
20918    default: 0
20919  }, {
20920    value: 'rem',
20921    label: 'rem',
20922    default: 0
20923  }, {
20924    value: 'em',
20925    label: 'em',
20926    default: 0
20927  }];
20928  /* harmony default export */ const grid = ({
20929    name: 'grid',
20930    label: (0,external_wp_i18n_namespaceObject.__)('Grid'),
20931    inspectorControls: function GridLayoutInspectorControls({
20932      layout = {},
20933      onChange,
20934      layoutBlockSupport = {}
20935    }) {
20936      const {
20937        allowSizingOnChildren = false
20938      } = layoutBlockSupport;
20939  
20940      // In the experiment we want to also show column control in Auto mode, and
20941      // the minimum width control in Manual mode.
20942      const showColumnsControl = window.__experimentalEnableGridInteractivity || !!layout?.columnCount;
20943      const showMinWidthControl = window.__experimentalEnableGridInteractivity || !layout?.columnCount;
20944      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
20945        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(GridLayoutTypeControl, {
20946          layout: layout,
20947          onChange: onChange
20948        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalVStack, {
20949          spacing: 4,
20950          children: [showColumnsControl && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(GridLayoutColumnsAndRowsControl, {
20951            layout: layout,
20952            onChange: onChange,
20953            allowSizingOnChildren: allowSizingOnChildren
20954          }), showMinWidthControl && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(GridLayoutMinimumWidthControl, {
20955            layout: layout,
20956            onChange: onChange
20957          })]
20958        })]
20959      });
20960    },
20961    toolBarControls: function GridLayoutToolbarControls() {
20962      return null;
20963    },
20964    getLayoutStyle: function getLayoutStyle({
20965      selector,
20966      layout,
20967      style,
20968      blockName,
20969      hasBlockGapSupport,
20970      layoutDefinitions = LAYOUT_DEFINITIONS
20971    }) {
20972      const {
20973        minimumColumnWidth = null,
20974        columnCount = null,
20975        rowCount = null
20976      } = layout;
20977  
20978      // Check that the grid layout attributes are of the correct type, so that we don't accidentally
20979      // write code that stores a string attribute instead of a number.
20980      if (false) {}
20981  
20982      // If a block's block.json skips serialization for spacing or spacing.blockGap,
20983      // don't apply the user-defined value to the styles.
20984      const blockGapValue = style?.spacing?.blockGap && !shouldSkipSerialization(blockName, 'spacing', 'blockGap') ? getGapCSSValue(style?.spacing?.blockGap, '0.5em') : undefined;
20985      let output = '';
20986      const rules = [];
20987      if (minimumColumnWidth && columnCount > 0) {
20988        const maxValue = `max($minimumColumnWidth}, ( 100% - ($blockGapValue || '1.2rem'}*$columnCount - 1}) ) / $columnCount})`;
20989        rules.push(`grid-template-columns: repeat(auto-fill, minmax($maxValue}, 1fr))`, `container-type: inline-size`);
20990        if (rowCount) {
20991          rules.push(`grid-template-rows: repeat($rowCount}, minmax(1rem, auto))`);
20992        }
20993      } else if (columnCount) {
20994        rules.push(`grid-template-columns: repeat($columnCount}, minmax(0, 1fr))`);
20995        if (rowCount) {
20996          rules.push(`grid-template-rows: repeat($rowCount}, minmax(1rem, auto))`);
20997        }
20998      } else {
20999        rules.push(`grid-template-columns: repeat(auto-fill, minmax(min($minimumColumnWidth || '12rem'}, 100%), 1fr))`, 'container-type: inline-size');
21000      }
21001      if (rules.length) {
21002        // Reason to disable: the extra line breaks added by prettier mess with the unit tests.
21003        // eslint-disable-next-line prettier/prettier
21004        output = `$appendSelectors(selector)} { $rules.join('; ')}; }`;
21005      }
21006  
21007      // Output blockGap styles based on rules contained in layout definitions in theme.json.
21008      if (hasBlockGapSupport && blockGapValue) {
21009        output += getBlockGapCSS(selector, layoutDefinitions, 'grid', blockGapValue);
21010      }
21011      return output;
21012    },
21013    getOrientation() {
21014      return 'horizontal';
21015    },
21016    getAlignments() {
21017      return [];
21018    }
21019  });
21020  
21021  // Enables setting minimum width of grid items.
21022  function GridLayoutMinimumWidthControl({
21023    layout,
21024    onChange
21025  }) {
21026    const {
21027      minimumColumnWidth,
21028      columnCount,
21029      isManualPlacement
21030    } = layout;
21031    const defaultValue = isManualPlacement || columnCount ? null : '12rem';
21032    const value = minimumColumnWidth || defaultValue;
21033    const [quantity, unit = 'rem'] = (0,external_wp_components_namespaceObject.__experimentalParseQuantityAndUnitFromRawValue)(value);
21034    const handleSliderChange = next => {
21035      onChange({
21036        ...layout,
21037        minimumColumnWidth: [next, unit].join('')
21038      });
21039    };
21040  
21041    // Mostly copied from HeightControl.
21042    const handleUnitChange = newUnit => {
21043      // Attempt to smooth over differences between currentUnit and newUnit.
21044      // This should slightly improve the experience of switching between unit types.
21045      let newValue;
21046      if (['em', 'rem'].includes(newUnit) && unit === 'px') {
21047        // Convert pixel value to an approximate of the new unit, assuming a root size of 16px.
21048        newValue = (quantity / 16).toFixed(2) + newUnit;
21049      } else if (['em', 'rem'].includes(unit) && newUnit === 'px') {
21050        // Convert to pixel value assuming a root size of 16px.
21051        newValue = Math.round(quantity * 16) + newUnit;
21052      }
21053      onChange({
21054        ...layout,
21055        minimumColumnWidth: newValue
21056      });
21057    };
21058    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("fieldset", {
21059      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.BaseControl.VisualLabel, {
21060        as: "legend",
21061        children: (0,external_wp_i18n_namespaceObject.__)('Minimum column width')
21062      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.Flex, {
21063        gap: 4,
21064        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FlexItem, {
21065          isBlock: true,
21066          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalUnitControl, {
21067            size: "__unstable-large",
21068            onChange: newValue => {
21069              onChange({
21070                ...layout,
21071                minimumColumnWidth: newValue === '' ? undefined : newValue
21072              });
21073            },
21074            onUnitChange: handleUnitChange,
21075            value: value,
21076            units: units,
21077            min: 0,
21078            label: (0,external_wp_i18n_namespaceObject.__)('Minimum column width'),
21079            hideLabelFromVision: true
21080          })
21081        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FlexItem, {
21082          isBlock: true,
21083          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.RangeControl, {
21084            __next40pxDefaultSize: true,
21085            __nextHasNoMarginBottom: true,
21086            onChange: handleSliderChange,
21087            value: quantity || 0,
21088            min: 0,
21089            max: RANGE_CONTROL_MAX_VALUES[unit] || 600,
21090            withInputField: false,
21091            label: (0,external_wp_i18n_namespaceObject.__)('Minimum column width'),
21092            hideLabelFromVision: true
21093          })
21094        })]
21095      })]
21096    });
21097  }
21098  
21099  // Enables setting number of grid columns
21100  function GridLayoutColumnsAndRowsControl({
21101    layout,
21102    onChange,
21103    allowSizingOnChildren
21104  }) {
21105    // If the grid interactivity experiment is enabled, allow unsetting the column count.
21106    const defaultColumnCount = window.__experimentalEnableGridInteractivity ? undefined : 3;
21107    const {
21108      columnCount = defaultColumnCount,
21109      rowCount,
21110      isManualPlacement
21111    } = layout;
21112    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_ReactJSXRuntime_namespaceObject.Fragment, {
21113      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("fieldset", {
21114        children: [(!window.__experimentalEnableGridInteractivity || !isManualPlacement) && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.BaseControl.VisualLabel, {
21115          as: "legend",
21116          children: (0,external_wp_i18n_namespaceObject.__)('Columns')
21117        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.Flex, {
21118          gap: 4,
21119          children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FlexItem, {
21120            isBlock: true,
21121            children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalNumberControl, {
21122              size: "__unstable-large",
21123              onChange: value => {
21124                if (window.__experimentalEnableGridInteractivity) {
21125                  // Allow unsetting the column count when in auto mode.
21126                  const defaultNewColumnCount = isManualPlacement ? 1 : undefined;
21127                  const newColumnCount = value === '' || value === '0' ? defaultNewColumnCount : parseInt(value, 10);
21128                  onChange({
21129                    ...layout,
21130                    columnCount: newColumnCount
21131                  });
21132                } else {
21133                  // Don't allow unsetting the column count.
21134                  const newColumnCount = value === '' || value === '0' ? 1 : parseInt(value, 10);
21135                  onChange({
21136                    ...layout,
21137                    columnCount: newColumnCount
21138                  });
21139                }
21140              },
21141              value: columnCount,
21142              min: 1,
21143              label: (0,external_wp_i18n_namespaceObject.__)('Columns'),
21144              hideLabelFromVision: !window.__experimentalEnableGridInteractivity || !isManualPlacement
21145            })
21146          }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FlexItem, {
21147            isBlock: true,
21148            children: window.__experimentalEnableGridInteractivity && allowSizingOnChildren && isManualPlacement ? /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalNumberControl, {
21149              size: "__unstable-large",
21150              onChange: value => {
21151                // Don't allow unsetting the row count.
21152                const newRowCount = value === '' || value === '0' ? 1 : parseInt(value, 10);
21153                onChange({
21154                  ...layout,
21155                  rowCount: newRowCount
21156                });
21157              },
21158              value: rowCount,
21159              min: 1,
21160              label: (0,external_wp_i18n_namespaceObject.__)('Rows')
21161            }) : /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.RangeControl, {
21162              __next40pxDefaultSize: true,
21163              __nextHasNoMarginBottom: true,
21164              value: columnCount !== null && columnCount !== void 0 ? columnCount : 1,
21165              onChange: value => onChange({
21166                ...layout,
21167                columnCount: value === '' || value === '0' ? 1 : value
21168              }),
21169              min: 1,
21170              max: 16,
21171              withInputField: false,
21172              label: (0,external_wp_i18n_namespaceObject.__)('Columns'),
21173              hideLabelFromVision: true
21174            })
21175          })]
21176        })]
21177      })
21178    });
21179  }
21180  
21181  // Enables switching between grid types
21182  function GridLayoutTypeControl({
21183    layout,
21184    onChange
21185  }) {
21186    const {
21187      columnCount,
21188      rowCount,
21189      minimumColumnWidth,
21190      isManualPlacement
21191    } = layout;
21192  
21193    /**
21194     * When switching, temporarily save any custom values set on the
21195     * previous type so we can switch back without loss.
21196     */
21197    const [tempColumnCount, setTempColumnCount] = (0,external_wp_element_namespaceObject.useState)(columnCount || 3);
21198    const [tempRowCount, setTempRowCount] = (0,external_wp_element_namespaceObject.useState)(rowCount);
21199    const [tempMinimumColumnWidth, setTempMinimumColumnWidth] = (0,external_wp_element_namespaceObject.useState)(minimumColumnWidth || '12rem');
21200    const gridPlacement = isManualPlacement || !!columnCount && !window.__experimentalEnableGridInteractivity ? 'manual' : 'auto';
21201    const onChangeType = value => {
21202      if (value === 'manual') {
21203        setTempMinimumColumnWidth(minimumColumnWidth || '12rem');
21204      } else {
21205        setTempColumnCount(columnCount || 3);
21206        setTempRowCount(rowCount);
21207      }
21208      onChange({
21209        ...layout,
21210        columnCount: value === 'manual' ? tempColumnCount : null,
21211        rowCount: value === 'manual' && window.__experimentalEnableGridInteractivity ? tempRowCount : undefined,
21212        isManualPlacement: value === 'manual' && window.__experimentalEnableGridInteractivity ? true : undefined,
21213        minimumColumnWidth: value === 'auto' ? tempMinimumColumnWidth : null
21214      });
21215    };
21216    const helpText = gridPlacement === 'manual' ? (0,external_wp_i18n_namespaceObject.__)('Grid items can be manually placed in any position on the grid.') : (0,external_wp_i18n_namespaceObject.__)('Grid items are placed automatically depending on their order.');
21217    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalToggleGroupControl, {
21218      __next40pxDefaultSize: true,
21219      __nextHasNoMarginBottom: true,
21220      label: (0,external_wp_i18n_namespaceObject.__)('Grid item position'),
21221      value: gridPlacement,
21222      onChange: onChangeType,
21223      isBlock: true,
21224      help: window.__experimentalEnableGridInteractivity ? helpText : undefined,
21225      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControlOption, {
21226        value: "auto",
21227        label: (0,external_wp_i18n_namespaceObject.__)('Auto')
21228      }, "auto"), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControlOption, {
21229        value: "manual",
21230        label: (0,external_wp_i18n_namespaceObject.__)('Manual')
21231      }, "manual")]
21232    });
21233  }
21234  
21235  ;// ./node_modules/@wordpress/block-editor/build-module/layouts/index.js
21236  /**
21237   * Internal dependencies
21238   */
21239  
21240  
21241  
21242  
21243  const layoutTypes = [flow, flex, constrained, grid];
21244  
21245  /**
21246   * Retrieves a layout type by name.
21247   *
21248   * @param {string} name - The name of the layout type.
21249   * @return {Object} Layout type.
21250   */
21251  function getLayoutType(name = 'default') {
21252    return layoutTypes.find(layoutType => layoutType.name === name);
21253  }
21254  
21255  /**
21256   * Retrieves the available layout types.
21257   *
21258   * @return {Array} Layout types.
21259   */
21260  function getLayoutTypes() {
21261    return layoutTypes;
21262  }
21263  
21264  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-list/layout.js
21265  /**
21266   * WordPress dependencies
21267   */
21268  
21269  
21270  /**
21271   * Internal dependencies
21272   */
21273  
21274  
21275  
21276  const defaultLayout = {
21277    type: 'default'
21278  };
21279  const Layout = (0,external_wp_element_namespaceObject.createContext)(defaultLayout);
21280  
21281  /**
21282   * Allows to define the layout.
21283   */
21284  const LayoutProvider = Layout.Provider;
21285  
21286  /**
21287   * React hook used to retrieve the layout config.
21288   */
21289  function useLayout() {
21290    return (0,external_wp_element_namespaceObject.useContext)(Layout);
21291  }
21292  function LayoutStyle({
21293    layout = {},
21294    css,
21295    ...props
21296  }) {
21297    const layoutType = getLayoutType(layout.type);
21298    const [blockGapSupport] = use_settings_useSettings('spacing.blockGap');
21299    const hasBlockGapSupport = blockGapSupport !== null;
21300    if (layoutType) {
21301      if (css) {
21302        return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("style", {
21303          children: css
21304        });
21305      }
21306      const layoutStyle = layoutType.getLayoutStyle?.({
21307        hasBlockGapSupport,
21308        layout,
21309        ...props
21310      });
21311      if (layoutStyle) {
21312        return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("style", {
21313          children: layoutStyle
21314        });
21315      }
21316    }
21317    return null;
21318  }
21319  
21320  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-alignment-control/use-available-alignments.js
21321  /**
21322   * WordPress dependencies
21323   */
21324  
21325  
21326  /**
21327   * Internal dependencies
21328   */
21329  
21330  
21331  
21332  const use_available_alignments_EMPTY_ARRAY = [];
21333  const use_available_alignments_DEFAULT_CONTROLS = ['none', 'left', 'center', 'right', 'wide', 'full'];
21334  const WIDE_CONTROLS = ['wide', 'full'];
21335  function useAvailableAlignments(controls = use_available_alignments_DEFAULT_CONTROLS) {
21336    // Always add the `none` option if not exists.
21337    if (!controls.includes('none')) {
21338      controls = ['none', ...controls];
21339    }
21340    const isNoneOnly = controls.length === 1 && controls[0] === 'none';
21341    const [wideControlsEnabled, themeSupportsLayout, isBlockBasedTheme] = (0,external_wp_data_namespaceObject.useSelect)(select => {
21342      var _settings$alignWide;
21343      // If `isNoneOnly` is true, we'll be returning early because there is
21344      // nothing to filter on an empty array. We won't need the info from
21345      // the `useSelect` but we must call it anyway because Rules of Hooks.
21346      // So the callback returns early to avoid block editor subscription.
21347      if (isNoneOnly) {
21348        return [false, false, false];
21349      }
21350      const settings = select(store).getSettings();
21351      return [(_settings$alignWide = settings.alignWide) !== null && _settings$alignWide !== void 0 ? _settings$alignWide : false, settings.supportsLayout, settings.__unstableIsBlockBasedTheme];
21352    }, [isNoneOnly]);
21353    const layout = useLayout();
21354    if (isNoneOnly) {
21355      return use_available_alignments_EMPTY_ARRAY;
21356    }
21357    const layoutType = getLayoutType(layout?.type);
21358    if (themeSupportsLayout) {
21359      const layoutAlignments = layoutType.getAlignments(layout, isBlockBasedTheme);
21360      const alignments = layoutAlignments.filter(alignment => controls.includes(alignment.name));
21361      // While we treat `none` as an alignment, we shouldn't return it if no
21362      // other alignments exist.
21363      if (alignments.length === 1 && alignments[0].name === 'none') {
21364        return use_available_alignments_EMPTY_ARRAY;
21365      }
21366      return alignments;
21367    }
21368  
21369    // Starting here, it's the fallback for themes not supporting the layout config.
21370    if (layoutType.name !== 'default' && layoutType.name !== 'constrained') {
21371      return use_available_alignments_EMPTY_ARRAY;
21372    }
21373    const alignments = controls.filter(control => {
21374      if (layout.alignments) {
21375        return layout.alignments.includes(control);
21376      }
21377      if (!wideControlsEnabled && WIDE_CONTROLS.includes(control)) {
21378        return false;
21379      }
21380      return use_available_alignments_DEFAULT_CONTROLS.includes(control);
21381    }).map(name => ({
21382      name
21383    }));
21384  
21385    // While we treat `none` as an alignment, we shouldn't return it if no
21386    // other alignments exist.
21387    if (alignments.length === 1 && alignments[0].name === 'none') {
21388      return use_available_alignments_EMPTY_ARRAY;
21389    }
21390    return alignments;
21391  }
21392  
21393  ;// ./node_modules/@wordpress/icons/build-module/library/position-left.js
21394  /**
21395   * WordPress dependencies
21396   */
21397  
21398  
21399  const positionLeft = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
21400    xmlns: "http://www.w3.org/2000/svg",
21401    viewBox: "0 0 24 24",
21402    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
21403      d: "M5 5.5h8V4H5v1.5ZM5 20h8v-1.5H5V20ZM19 9H5v6h14V9Z"
21404    })
21405  });
21406  /* harmony default export */ const position_left = (positionLeft);
21407  
21408  ;// ./node_modules/@wordpress/icons/build-module/library/position-center.js
21409  /**
21410   * WordPress dependencies
21411   */
21412  
21413  
21414  const positionCenter = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
21415    xmlns: "http://www.w3.org/2000/svg",
21416    viewBox: "0 0 24 24",
21417    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
21418      d: "M19 5.5H5V4h14v1.5ZM19 20H5v-1.5h14V20ZM7 9h10v6H7V9Z"
21419    })
21420  });
21421  /* harmony default export */ const position_center = (positionCenter);
21422  
21423  ;// ./node_modules/@wordpress/icons/build-module/library/position-right.js
21424  /**
21425   * WordPress dependencies
21426   */
21427  
21428  
21429  const positionRight = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
21430    xmlns: "http://www.w3.org/2000/svg",
21431    viewBox: "0 0 24 24",
21432    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
21433      d: "M19 5.5h-8V4h8v1.5ZM19 20h-8v-1.5h8V20ZM5 9h14v6H5V9Z"
21434    })
21435  });
21436  /* harmony default export */ const position_right = (positionRight);
21437  
21438  ;// ./node_modules/@wordpress/icons/build-module/library/stretch-full-width.js
21439  /**
21440   * WordPress dependencies
21441   */
21442  
21443  
21444  const stretchFullWidth = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
21445    xmlns: "http://www.w3.org/2000/svg",
21446    viewBox: "0 0 24 24",
21447    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
21448      d: "M5 4h14v11H5V4Zm11 16H8v-1.5h8V20Z"
21449    })
21450  });
21451  /* harmony default export */ const stretch_full_width = (stretchFullWidth);
21452  
21453  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-alignment-control/constants.js
21454  /**
21455   * WordPress dependencies
21456   */
21457  
21458  
21459  const constants_BLOCK_ALIGNMENTS_CONTROLS = {
21460    none: {
21461      icon: align_none,
21462      title: (0,external_wp_i18n_namespaceObject._x)('None', 'Alignment option')
21463    },
21464    left: {
21465      icon: position_left,
21466      title: (0,external_wp_i18n_namespaceObject.__)('Align left')
21467    },
21468    center: {
21469      icon: position_center,
21470      title: (0,external_wp_i18n_namespaceObject.__)('Align center')
21471    },
21472    right: {
21473      icon: position_right,
21474      title: (0,external_wp_i18n_namespaceObject.__)('Align right')
21475    },
21476    wide: {
21477      icon: stretch_wide,
21478      title: (0,external_wp_i18n_namespaceObject.__)('Wide width')
21479    },
21480    full: {
21481      icon: stretch_full_width,
21482      title: (0,external_wp_i18n_namespaceObject.__)('Full width')
21483    }
21484  };
21485  const constants_DEFAULT_CONTROL = 'none';
21486  
21487  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-alignment-control/ui.js
21488  /**
21489   * External dependencies
21490   */
21491  
21492  
21493  /**
21494   * WordPress dependencies
21495   */
21496  
21497  
21498  
21499  /**
21500   * Internal dependencies
21501   */
21502  
21503  
21504  
21505  function BlockAlignmentUI({
21506    value,
21507    onChange,
21508    controls,
21509    isToolbar,
21510    isCollapsed = true
21511  }) {
21512    const enabledControls = useAvailableAlignments(controls);
21513    const hasEnabledControls = !!enabledControls.length;
21514    if (!hasEnabledControls) {
21515      return null;
21516    }
21517    function onChangeAlignment(align) {
21518      onChange([value, 'none'].includes(align) ? undefined : align);
21519    }
21520    const activeAlignmentControl = constants_BLOCK_ALIGNMENTS_CONTROLS[value];
21521    const defaultAlignmentControl = constants_BLOCK_ALIGNMENTS_CONTROLS[constants_DEFAULT_CONTROL];
21522    const UIComponent = isToolbar ? external_wp_components_namespaceObject.ToolbarGroup : external_wp_components_namespaceObject.ToolbarDropdownMenu;
21523    const commonProps = {
21524      icon: activeAlignmentControl ? activeAlignmentControl.icon : defaultAlignmentControl.icon,
21525      label: (0,external_wp_i18n_namespaceObject.__)('Align')
21526    };
21527    const extraProps = isToolbar ? {
21528      isCollapsed,
21529      controls: enabledControls.map(({
21530        name: controlName
21531      }) => {
21532        return {
21533          ...constants_BLOCK_ALIGNMENTS_CONTROLS[controlName],
21534          isActive: value === controlName || !value && controlName === 'none',
21535          role: isCollapsed ? 'menuitemradio' : undefined,
21536          onClick: () => onChangeAlignment(controlName)
21537        };
21538      })
21539    } : {
21540      toggleProps: {
21541        description: (0,external_wp_i18n_namespaceObject.__)('Change alignment')
21542      },
21543      children: ({
21544        onClose
21545      }) => {
21546        return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_ReactJSXRuntime_namespaceObject.Fragment, {
21547          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuGroup, {
21548            className: "block-editor-block-alignment-control__menu-group",
21549            children: enabledControls.map(({
21550              name: controlName,
21551              info
21552            }) => {
21553              const {
21554                icon,
21555                title
21556              } = constants_BLOCK_ALIGNMENTS_CONTROLS[controlName];
21557              // If no value is provided, mark as selected the `none` option.
21558              const isSelected = controlName === value || !value && controlName === 'none';
21559              return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, {
21560                icon: icon,
21561                iconPosition: "left",
21562                className: dist_clsx('components-dropdown-menu__menu-item', {
21563                  'is-active': isSelected
21564                }),
21565                isSelected: isSelected,
21566                onClick: () => {
21567                  onChangeAlignment(controlName);
21568                  onClose();
21569                },
21570                role: "menuitemradio",
21571                info: info,
21572                children: title
21573              }, controlName);
21574            })
21575          })
21576        });
21577      }
21578    };
21579    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(UIComponent, {
21580      ...commonProps,
21581      ...extraProps
21582    });
21583  }
21584  /* harmony default export */ const block_alignment_control_ui = (BlockAlignmentUI);
21585  
21586  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-alignment-control/index.js
21587  /**
21588   * Internal dependencies
21589   */
21590  
21591  
21592  const BlockAlignmentControl = props => {
21593    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_alignment_control_ui, {
21594      ...props,
21595      isToolbar: false
21596    });
21597  };
21598  const BlockAlignmentToolbar = props => {
21599    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_alignment_control_ui, {
21600      ...props,
21601      isToolbar: true
21602    });
21603  };
21604  
21605  /**
21606   * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/block-alignment-control/README.md
21607   */
21608  
21609  
21610  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-editing-mode/index.js
21611  /**
21612   * WordPress dependencies
21613   */
21614  
21615  
21616  
21617  /**
21618   * Internal dependencies
21619   */
21620  
21621  
21622  
21623  /**
21624   * @typedef {'disabled'|'contentOnly'|'default'} BlockEditingMode
21625   */
21626  
21627  /**
21628   * Allows a block to restrict the user interface that is displayed for editing
21629   * that block and its inner blocks.
21630   *
21631   * @example
21632   * ```js
21633   * function MyBlock( { attributes, setAttributes } ) {
21634   *     useBlockEditingMode( 'disabled' );
21635   *     return <div { ...useBlockProps() }></div>;
21636   * }
21637   * ```
21638   *
21639   * `mode` can be one of three options:
21640   *
21641   * - `'disabled'`: Prevents editing the block entirely, i.e. it cannot be
21642   *   selected.
21643   * - `'contentOnly'`: Hides all non-content UI, e.g. auxiliary controls in the
21644   *   toolbar, the block movers, block settings.
21645   * - `'default'`: Allows editing the block as normal.
21646   *
21647   * The mode is inherited by all of the block's inner blocks, unless they have
21648   * their own mode.
21649   *
21650   * If called outside of a block context, the mode is applied to all blocks.
21651   *
21652   * @param {?BlockEditingMode} mode The editing mode to apply. If undefined, the
21653   *                                 current editing mode is not changed.
21654   *
21655   * @return {BlockEditingMode} The current editing mode.
21656   */
21657  function useBlockEditingMode(mode) {
21658    const context = useBlockEditContext();
21659    const {
21660      clientId = ''
21661    } = context;
21662    const {
21663      setBlockEditingMode,
21664      unsetBlockEditingMode
21665    } = (0,external_wp_data_namespaceObject.useDispatch)(store);
21666    const globalBlockEditingMode = (0,external_wp_data_namespaceObject.useSelect)(select =>
21667    // Avoid adding the subscription if not needed!
21668    clientId ? null : select(store).getBlockEditingMode(), [clientId]);
21669    (0,external_wp_element_namespaceObject.useEffect)(() => {
21670      if (mode) {
21671        setBlockEditingMode(clientId, mode);
21672      }
21673      return () => {
21674        if (mode) {
21675          unsetBlockEditingMode(clientId);
21676        }
21677      };
21678    }, [clientId, mode, setBlockEditingMode, unsetBlockEditingMode]);
21679    return clientId ? context[blockEditingModeKey] : globalBlockEditingMode;
21680  }
21681  
21682  ;// ./node_modules/@wordpress/block-editor/build-module/hooks/align.js
21683  /**
21684   * External dependencies
21685   */
21686  
21687  
21688  /**
21689   * WordPress dependencies
21690   */
21691  
21692  
21693  
21694  /**
21695   * Internal dependencies
21696   */
21697  
21698  
21699  
21700  
21701  /**
21702   * An array which includes all possible valid alignments,
21703   * used to validate if an alignment is valid or not.
21704   *
21705   * @constant
21706   * @type {string[]}
21707   */
21708  
21709  const ALL_ALIGNMENTS = ['left', 'center', 'right', 'wide', 'full'];
21710  
21711  /**
21712   * An array which includes all wide alignments.
21713   * In order for this alignments to be valid they need to be supported by the block,
21714   * and by the theme.
21715   *
21716   * @constant
21717   * @type {string[]}
21718   */
21719  const WIDE_ALIGNMENTS = ['wide', 'full'];
21720  
21721  /**
21722   * Returns the valid alignments.
21723   * Takes into consideration the aligns supported by a block, if the block supports wide controls or not and if theme supports wide controls or not.
21724   * Exported just for testing purposes, not exported outside the module.
21725   *
21726   * @param {?boolean|string[]} blockAlign          Aligns supported by the block.
21727   * @param {?boolean}          hasWideBlockSupport True if block supports wide alignments. And False otherwise.
21728   * @param {?boolean}          hasWideEnabled      True if theme supports wide alignments. And False otherwise.
21729   *
21730   * @return {string[]} Valid alignments.
21731   */
21732  function getValidAlignments(blockAlign, hasWideBlockSupport = true, hasWideEnabled = true) {
21733    let validAlignments;
21734    if (Array.isArray(blockAlign)) {
21735      validAlignments = ALL_ALIGNMENTS.filter(value => blockAlign.includes(value));
21736    } else if (blockAlign === true) {
21737      // `true` includes all alignments...
21738      validAlignments = [...ALL_ALIGNMENTS];
21739    } else {
21740      validAlignments = [];
21741    }
21742    if (!hasWideEnabled || blockAlign === true && !hasWideBlockSupport) {
21743      return validAlignments.filter(alignment => !WIDE_ALIGNMENTS.includes(alignment));
21744    }
21745    return validAlignments;
21746  }
21747  
21748  /**
21749   * Filters registered block settings, extending attributes to include `align`.
21750   *
21751   * @param {Object} settings Original block settings.
21752   *
21753   * @return {Object} Filtered block settings.
21754   */
21755  function addAttribute(settings) {
21756    var _settings$attributes$;
21757    // Allow blocks to specify their own attribute definition with default values if needed.
21758    if ('type' in ((_settings$attributes$ = settings.attributes?.align) !== null && _settings$attributes$ !== void 0 ? _settings$attributes$ : {})) {
21759      return settings;
21760    }
21761    if ((0,external_wp_blocks_namespaceObject.hasBlockSupport)(settings, 'align')) {
21762      // Gracefully handle if settings.attributes is undefined.
21763      settings.attributes = {
21764        ...settings.attributes,
21765        align: {
21766          type: 'string',
21767          // Allow for '' since it is used by the `updateAlignment` function
21768          // in toolbar controls for special cases with defined default values.
21769          enum: [...ALL_ALIGNMENTS, '']
21770        }
21771      };
21772    }
21773    return settings;
21774  }
21775  function BlockEditAlignmentToolbarControlsPure({
21776    name: blockName,
21777    align,
21778    setAttributes
21779  }) {
21780    // Compute the block valid alignments by taking into account,
21781    // if the theme supports wide alignments or not and the layout's
21782    // available alignments. We do that for conditionally rendering
21783    // Slot.
21784    const blockAllowedAlignments = getValidAlignments((0,external_wp_blocks_namespaceObject.getBlockSupport)(blockName, 'align'), (0,external_wp_blocks_namespaceObject.hasBlockSupport)(blockName, 'alignWide', true));
21785    const validAlignments = useAvailableAlignments(blockAllowedAlignments).map(({
21786      name
21787    }) => name);
21788    const blockEditingMode = useBlockEditingMode();
21789    if (!validAlignments.length || blockEditingMode !== 'default') {
21790      return null;
21791    }
21792    const updateAlignment = nextAlign => {
21793      if (!nextAlign) {
21794        const blockType = (0,external_wp_blocks_namespaceObject.getBlockType)(blockName);
21795        const blockDefaultAlign = blockType?.attributes?.align?.default;
21796        if (blockDefaultAlign) {
21797          nextAlign = '';
21798        }
21799      }
21800      setAttributes({
21801        align: nextAlign
21802      });
21803    };
21804    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_controls, {
21805      group: "block",
21806      __experimentalShareWithChildBlocks: true,
21807      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockAlignmentControl, {
21808        value: align,
21809        onChange: updateAlignment,
21810        controls: validAlignments
21811      })
21812    });
21813  }
21814  /* harmony default export */ const align = ({
21815    shareWithChildBlocks: true,
21816    edit: BlockEditAlignmentToolbarControlsPure,
21817    useBlockProps,
21818    addSaveProps: addAssignedAlign,
21819    attributeKeys: ['align'],
21820    hasSupport(name) {
21821      return (0,external_wp_blocks_namespaceObject.hasBlockSupport)(name, 'align', false);
21822    }
21823  });
21824  function useBlockProps({
21825    name,
21826    align
21827  }) {
21828    const blockAllowedAlignments = getValidAlignments((0,external_wp_blocks_namespaceObject.getBlockSupport)(name, 'align'), (0,external_wp_blocks_namespaceObject.hasBlockSupport)(name, 'alignWide', true));
21829    const validAlignments = useAvailableAlignments(blockAllowedAlignments);
21830    if (validAlignments.some(alignment => alignment.name === align)) {
21831      return {
21832        'data-align': align
21833      };
21834    }
21835    return {};
21836  }
21837  
21838  /**
21839   * Override props assigned to save component to inject alignment class name if
21840   * block supports it.
21841   *
21842   * @param {Object} props      Additional props applied to save element.
21843   * @param {Object} blockType  Block type.
21844   * @param {Object} attributes Block attributes.
21845   *
21846   * @return {Object} Filtered props applied to save element.
21847   */
21848  function addAssignedAlign(props, blockType, attributes) {
21849    const {
21850      align
21851    } = attributes;
21852    const blockAlign = (0,external_wp_blocks_namespaceObject.getBlockSupport)(blockType, 'align');
21853    const hasWideBlockSupport = (0,external_wp_blocks_namespaceObject.hasBlockSupport)(blockType, 'alignWide', true);
21854  
21855    // Compute valid alignments without taking into account if
21856    // the theme supports wide alignments or not.
21857    // This way changing themes does not impact the block save.
21858    const isAlignValid = getValidAlignments(blockAlign, hasWideBlockSupport).includes(align);
21859    if (isAlignValid) {
21860      props.className = dist_clsx(`align$align}`, props.className);
21861    }
21862    return props;
21863  }
21864  (0,external_wp_hooks_namespaceObject.addFilter)('blocks.registerBlockType', 'core/editor/align/addAttribute', addAttribute);
21865  
21866  ;// ./node_modules/@wordpress/block-editor/build-module/components/inspector-controls/groups.js
21867  /**
21868   * WordPress dependencies
21869   */
21870  
21871  const InspectorControlsDefault = (0,external_wp_components_namespaceObject.createSlotFill)('InspectorControls');
21872  const InspectorControlsAdvanced = (0,external_wp_components_namespaceObject.createSlotFill)('InspectorAdvancedControls');
21873  const InspectorControlsBindings = (0,external_wp_components_namespaceObject.createSlotFill)('InspectorControlsBindings');
21874  const InspectorControlsBackground = (0,external_wp_components_namespaceObject.createSlotFill)('InspectorControlsBackground');
21875  const InspectorControlsBorder = (0,external_wp_components_namespaceObject.createSlotFill)('InspectorControlsBorder');
21876  const InspectorControlsColor = (0,external_wp_components_namespaceObject.createSlotFill)('InspectorControlsColor');
21877  const InspectorControlsFilter = (0,external_wp_components_namespaceObject.createSlotFill)('InspectorControlsFilter');
21878  const InspectorControlsDimensions = (0,external_wp_components_namespaceObject.createSlotFill)('InspectorControlsDimensions');
21879  const InspectorControlsPosition = (0,external_wp_components_namespaceObject.createSlotFill)('InspectorControlsPosition');
21880  const InspectorControlsTypography = (0,external_wp_components_namespaceObject.createSlotFill)('InspectorControlsTypography');
21881  const InspectorControlsListView = (0,external_wp_components_namespaceObject.createSlotFill)('InspectorControlsListView');
21882  const InspectorControlsStyles = (0,external_wp_components_namespaceObject.createSlotFill)('InspectorControlsStyles');
21883  const InspectorControlsEffects = (0,external_wp_components_namespaceObject.createSlotFill)('InspectorControlsEffects');
21884  const groups_groups = {
21885    default: InspectorControlsDefault,
21886    advanced: InspectorControlsAdvanced,
21887    background: InspectorControlsBackground,
21888    bindings: InspectorControlsBindings,
21889    border: InspectorControlsBorder,
21890    color: InspectorControlsColor,
21891    dimensions: InspectorControlsDimensions,
21892    effects: InspectorControlsEffects,
21893    filter: InspectorControlsFilter,
21894    list: InspectorControlsListView,
21895    position: InspectorControlsPosition,
21896    settings: InspectorControlsDefault,
21897    // Alias for default.
21898    styles: InspectorControlsStyles,
21899    typography: InspectorControlsTypography
21900  };
21901  /* harmony default export */ const inspector_controls_groups = (groups_groups);
21902  
21903  ;// ./node_modules/@wordpress/block-editor/build-module/components/inspector-controls/fill.js
21904  /**
21905   * WordPress dependencies
21906   */
21907  
21908  
21909  
21910  
21911  
21912  /**
21913   * Internal dependencies
21914   */
21915  
21916  
21917  
21918  function InspectorControlsFill({
21919    children,
21920    group = 'default',
21921    __experimentalGroup,
21922    resetAllFilter
21923  }) {
21924    if (__experimentalGroup) {
21925      external_wp_deprecated_default()('`__experimentalGroup` property in `InspectorControlsFill`', {
21926        since: '6.2',
21927        version: '6.4',
21928        alternative: '`group`'
21929      });
21930      group = __experimentalGroup;
21931    }
21932    const context = useBlockEditContext();
21933    const Fill = inspector_controls_groups[group]?.Fill;
21934    if (!Fill) {
21935       true ? external_wp_warning_default()(`Unknown InspectorControls group "$group}" provided.`) : 0;
21936      return null;
21937    }
21938    if (!context[mayDisplayControlsKey]) {
21939      return null;
21940    }
21941    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalStyleProvider, {
21942      document: document,
21943      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Fill, {
21944        children: fillProps => {
21945          return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ToolsPanelInspectorControl, {
21946            fillProps: fillProps,
21947            children: children,
21948            resetAllFilter: resetAllFilter
21949          });
21950        }
21951      })
21952    });
21953  }
21954  function RegisterResetAll({
21955    resetAllFilter,
21956    children
21957  }) {
21958    const {
21959      registerResetAllFilter,
21960      deregisterResetAllFilter
21961    } = (0,external_wp_element_namespaceObject.useContext)(external_wp_components_namespaceObject.__experimentalToolsPanelContext);
21962    (0,external_wp_element_namespaceObject.useEffect)(() => {
21963      if (resetAllFilter && registerResetAllFilter && deregisterResetAllFilter) {
21964        registerResetAllFilter(resetAllFilter);
21965        return () => {
21966          deregisterResetAllFilter(resetAllFilter);
21967        };
21968      }
21969    }, [resetAllFilter, registerResetAllFilter, deregisterResetAllFilter]);
21970    return children;
21971  }
21972  function ToolsPanelInspectorControl({
21973    children,
21974    resetAllFilter,
21975    fillProps
21976  }) {
21977    // `fillProps.forwardedContext` is an array of context provider entries, provided by slot,
21978    // that should wrap the fill markup.
21979    const {
21980      forwardedContext = []
21981    } = fillProps;
21982  
21983    // Children passed to InspectorControlsFill will not have
21984    // access to any React Context whose Provider is part of
21985    // the InspectorControlsSlot tree. So we re-create the
21986    // Provider in this subtree.
21987    const innerMarkup = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(RegisterResetAll, {
21988      resetAllFilter: resetAllFilter,
21989      children: children
21990    });
21991    return forwardedContext.reduce((inner, [Provider, props]) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Provider, {
21992      ...props,
21993      children: inner
21994    }), innerMarkup);
21995  }
21996  
21997  ;// ./node_modules/@wordpress/block-editor/build-module/components/inspector-controls/block-support-tools-panel.js
21998  /**
21999   * WordPress dependencies
22000   */
22001  
22002  
22003  
22004  
22005  /**
22006   * Internal dependencies
22007   */
22008  
22009  
22010  
22011  
22012  function BlockSupportToolsPanel({
22013    children,
22014    group,
22015    label
22016  }) {
22017    const {
22018      updateBlockAttributes
22019    } = (0,external_wp_data_namespaceObject.useDispatch)(store);
22020    const {
22021      getBlockAttributes,
22022      getMultiSelectedBlockClientIds,
22023      getSelectedBlockClientId,
22024      hasMultiSelection
22025    } = (0,external_wp_data_namespaceObject.useSelect)(store);
22026    const dropdownMenuProps = useToolsPanelDropdownMenuProps();
22027    const panelId = getSelectedBlockClientId();
22028    const resetAll = (0,external_wp_element_namespaceObject.useCallback)((resetFilters = []) => {
22029      const newAttributes = {};
22030      const clientIds = hasMultiSelection() ? getMultiSelectedBlockClientIds() : [panelId];
22031      clientIds.forEach(clientId => {
22032        const {
22033          style
22034        } = getBlockAttributes(clientId);
22035        let newBlockAttributes = {
22036          style
22037        };
22038        resetFilters.forEach(resetFilter => {
22039          newBlockAttributes = {
22040            ...newBlockAttributes,
22041            ...resetFilter(newBlockAttributes)
22042          };
22043        });
22044  
22045        // Enforce a cleaned style object.
22046        newBlockAttributes = {
22047          ...newBlockAttributes,
22048          style: utils_cleanEmptyObject(newBlockAttributes.style)
22049        };
22050        newAttributes[clientId] = newBlockAttributes;
22051      });
22052      updateBlockAttributes(clientIds, newAttributes, true);
22053    }, [getBlockAttributes, getMultiSelectedBlockClientIds, hasMultiSelection, panelId, updateBlockAttributes]);
22054    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanel, {
22055      className: `$group}-block-support-panel`,
22056      label: label,
22057      resetAll: resetAll,
22058      panelId: panelId,
22059      hasInnerWrapper: true,
22060      shouldRenderPlaceholderItems: true // Required to maintain fills ordering.
22061      ,
22062      __experimentalFirstVisibleItemClass: "first",
22063      __experimentalLastVisibleItemClass: "last",
22064      dropdownMenuProps: dropdownMenuProps,
22065      children: children
22066    }, panelId);
22067  }
22068  
22069  ;// ./node_modules/@wordpress/block-editor/build-module/components/inspector-controls/block-support-slot-container.js
22070  /**
22071   * WordPress dependencies
22072   */
22073  
22074  
22075  
22076  function BlockSupportSlotContainer({
22077    Slot,
22078    fillProps,
22079    ...props
22080  }) {
22081    // Add the toolspanel context provider and value to existing fill props
22082    const toolsPanelContext = (0,external_wp_element_namespaceObject.useContext)(external_wp_components_namespaceObject.__experimentalToolsPanelContext);
22083    const computedFillProps = (0,external_wp_element_namespaceObject.useMemo)(() => {
22084      var _fillProps$forwardedC;
22085      return {
22086        ...(fillProps !== null && fillProps !== void 0 ? fillProps : {}),
22087        forwardedContext: [...((_fillProps$forwardedC = fillProps?.forwardedContext) !== null && _fillProps$forwardedC !== void 0 ? _fillProps$forwardedC : []), [external_wp_components_namespaceObject.__experimentalToolsPanelContext.Provider, {
22088          value: toolsPanelContext
22089        }]]
22090      };
22091    }, [toolsPanelContext, fillProps]);
22092    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Slot, {
22093      ...props,
22094      fillProps: computedFillProps,
22095      bubblesVirtually: true
22096    });
22097  }
22098  
22099  ;// ./node_modules/@wordpress/block-editor/build-module/components/inspector-controls/slot.js
22100  /**
22101   * WordPress dependencies
22102   */
22103  
22104  
22105  
22106  
22107  /**
22108   * Internal dependencies
22109   */
22110  
22111  
22112  
22113  
22114  function InspectorControlsSlot({
22115    __experimentalGroup,
22116    group = 'default',
22117    label,
22118    fillProps,
22119    ...props
22120  }) {
22121    if (__experimentalGroup) {
22122      external_wp_deprecated_default()('`__experimentalGroup` property in `InspectorControlsSlot`', {
22123        since: '6.2',
22124        version: '6.4',
22125        alternative: '`group`'
22126      });
22127      group = __experimentalGroup;
22128    }
22129    const slotFill = inspector_controls_groups[group];
22130    const fills = (0,external_wp_components_namespaceObject.__experimentalUseSlotFills)(slotFill?.name);
22131    if (!slotFill) {
22132       true ? external_wp_warning_default()(`Unknown InspectorControls group "$group}" provided.`) : 0;
22133      return null;
22134    }
22135    if (!fills?.length) {
22136      return null;
22137    }
22138    const {
22139      Slot
22140    } = slotFill;
22141    if (label) {
22142      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockSupportToolsPanel, {
22143        group: group,
22144        label: label,
22145        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockSupportSlotContainer, {
22146          ...props,
22147          fillProps: fillProps,
22148          Slot: Slot
22149        })
22150      });
22151    }
22152    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Slot, {
22153      ...props,
22154      fillProps: fillProps,
22155      bubblesVirtually: true
22156    });
22157  }
22158  
22159  ;// ./node_modules/@wordpress/block-editor/build-module/components/inspector-controls/index.js
22160  /**
22161   * Internal dependencies
22162   */
22163  
22164  
22165  
22166  const InspectorControls = InspectorControlsFill;
22167  InspectorControls.Slot = InspectorControlsSlot;
22168  
22169  // This is just here for backward compatibility.
22170  const InspectorAdvancedControls = props => {
22171    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(InspectorControlsFill, {
22172      ...props,
22173      group: "advanced"
22174    });
22175  };
22176  InspectorAdvancedControls.Slot = props => {
22177    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(InspectorControlsSlot, {
22178      ...props,
22179      group: "advanced"
22180    });
22181  };
22182  InspectorAdvancedControls.slotName = 'InspectorAdvancedControls';
22183  
22184  /**
22185   * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/inspector-controls/README.md
22186   */
22187  /* harmony default export */ const inspector_controls = (InspectorControls);
22188  
22189  ;// external ["wp","url"]
22190  const external_wp_url_namespaceObject = window["wp"]["url"];
22191  ;// external ["wp","dom"]
22192  const external_wp_dom_namespaceObject = window["wp"]["dom"];
22193  ;// external ["wp","blob"]
22194  const external_wp_blob_namespaceObject = window["wp"]["blob"];
22195  ;// external ["wp","keycodes"]
22196  const external_wp_keycodes_namespaceObject = window["wp"]["keycodes"];
22197  ;// ./node_modules/@wordpress/icons/build-module/library/media.js
22198  /**
22199   * WordPress dependencies
22200   */
22201  
22202  
22203  const media = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_primitives_namespaceObject.SVG, {
22204    xmlns: "http://www.w3.org/2000/svg",
22205    viewBox: "0 0 24 24",
22206    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
22207      d: "m7 6.5 4 2.5-4 2.5z"
22208    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
22209      fillRule: "evenodd",
22210      clipRule: "evenodd",
22211      d: "m5 3c-1.10457 0-2 .89543-2 2v14c0 1.1046.89543 2 2 2h14c1.1046 0 2-.8954 2-2v-14c0-1.10457-.8954-2-2-2zm14 1.5h-14c-.27614 0-.5.22386-.5.5v10.7072l3.62953-2.6465c.25108-.1831.58905-.1924.84981-.0234l2.92666 1.8969 3.5712-3.4719c.2911-.2831.7545-.2831 1.0456 0l2.9772 2.8945v-9.3568c0-.27614-.2239-.5-.5-.5zm-14.5 14.5v-1.4364l4.09643-2.987 2.99567 1.9417c.2936.1903.6798.1523.9307-.0917l3.4772-3.3806 3.4772 3.3806.0228-.0234v2.5968c0 .2761-.2239.5-.5.5h-14c-.27614 0-.5-.2239-.5-.5z"
22212    })]
22213  });
22214  /* harmony default export */ const library_media = (media);
22215  
22216  ;// ./node_modules/@wordpress/icons/build-module/library/upload.js
22217  /**
22218   * WordPress dependencies
22219   */
22220  
22221  
22222  const upload = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
22223    xmlns: "http://www.w3.org/2000/svg",
22224    viewBox: "0 0 24 24",
22225    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
22226      d: "M18.5 15v3.5H13V6.7l4.5 4.1 1-1.1-6.2-5.8-5.8 5.8 1 1.1 4-4v11.7h-6V15H4v5h16v-5z"
22227    })
22228  });
22229  /* harmony default export */ const library_upload = (upload);
22230  
22231  ;// ./node_modules/@wordpress/icons/build-module/library/post-featured-image.js
22232  /**
22233   * WordPress dependencies
22234   */
22235  
22236  
22237  const postFeaturedImage = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
22238    xmlns: "http://www.w3.org/2000/svg",
22239    viewBox: "0 0 24 24",
22240    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
22241      d: "M19 3H5c-.6 0-1 .4-1 1v7c0 .5.4 1 1 1h14c.5 0 1-.4 1-1V4c0-.6-.4-1-1-1zM5.5 10.5v-.4l1.8-1.3 1.3.8c.3.2.7.2.9-.1L11 8.1l2.4 2.4H5.5zm13 0h-2.9l-4-4c-.3-.3-.8-.3-1.1 0L8.9 8l-1.2-.8c-.3-.2-.6-.2-.9 0l-1.3 1V4.5h13v6zM4 20h9v-1.5H4V20zm0-4h16v-1.5H4V16z"
22242    })
22243  });
22244  /* harmony default export */ const post_featured_image = (postFeaturedImage);
22245  
22246  ;// ./node_modules/@wordpress/block-editor/build-module/components/media-upload/index.js
22247  /**
22248   * WordPress dependencies
22249   */
22250  
22251  
22252  /**
22253   * This is a placeholder for the media upload component necessary to make it possible to provide
22254   * an integration with the core blocks that handle media files. By default it renders nothing but
22255   * it provides a way to have it overridden with the `editor.MediaUpload` filter.
22256   *
22257   * @return {Component} The component to be rendered.
22258   */
22259  const MediaUpload = () => null;
22260  
22261  /**
22262   * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/media-upload/README.md
22263   */
22264  /* harmony default export */ const media_upload = ((0,external_wp_components_namespaceObject.withFilters)('editor.MediaUpload')(MediaUpload));
22265  
22266  ;// ./node_modules/@wordpress/block-editor/build-module/components/media-upload/check.js
22267  /**
22268   * WordPress dependencies
22269   */
22270  
22271  
22272  /**
22273   * Internal dependencies
22274   */
22275  
22276  function MediaUploadCheck({
22277    fallback = null,
22278    children
22279  }) {
22280    const hasUploadPermissions = (0,external_wp_data_namespaceObject.useSelect)(select => {
22281      const {
22282        getSettings
22283      } = select(store);
22284      return !!getSettings().mediaUpload;
22285    }, []);
22286    return hasUploadPermissions ? children : fallback;
22287  }
22288  
22289  /**
22290   * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/media-upload/README.md
22291   */
22292  /* harmony default export */ const check = (MediaUploadCheck);
22293  
22294  ;// external ["wp","isShallowEqual"]
22295  const external_wp_isShallowEqual_namespaceObject = window["wp"]["isShallowEqual"];
22296  var external_wp_isShallowEqual_default = /*#__PURE__*/__webpack_require__.n(external_wp_isShallowEqual_namespaceObject);
22297  ;// ./node_modules/@wordpress/icons/build-module/library/keyboard-return.js
22298  /**
22299   * WordPress dependencies
22300   */
22301  
22302  
22303  const keyboardReturn = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
22304    xmlns: "http://www.w3.org/2000/svg",
22305    viewBox: "0 0 24 24",
22306    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
22307      d: "m6.734 16.106 2.176-2.38-1.093-1.028-3.846 4.158 3.846 4.158 1.093-1.028-2.176-2.38h2.811c1.125 0 2.25.03 3.374 0 1.428-.001 3.362-.25 4.963-1.277 1.66-1.065 2.868-2.906 2.868-5.859 0-2.479-1.327-4.896-3.65-5.93-1.82-.813-3.044-.8-4.806-.788l-.567.002v1.5c.184 0 .368 0 .553-.002 1.82-.007 2.704-.014 4.21.657 1.854.827 2.76 2.657 2.76 4.561 0 2.472-.973 3.824-2.178 4.596-1.258.807-2.864 1.04-4.163 1.04h-.02c-1.115.03-2.229 0-3.344 0H6.734Z"
22308    })
22309  });
22310  /* harmony default export */ const keyboard_return = (keyboardReturn);
22311  
22312  ;// ./node_modules/@wordpress/icons/build-module/library/chevron-left-small.js
22313  /**
22314   * WordPress dependencies
22315   */
22316  
22317  
22318  const chevronLeftSmall = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
22319    xmlns: "http://www.w3.org/2000/svg",
22320    viewBox: "0 0 24 24",
22321    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
22322      d: "m13.1 16-3.4-4 3.4-4 1.1 1-2.6 3 2.6 3-1.1 1z"
22323    })
22324  });
22325  /* harmony default export */ const chevron_left_small = (chevronLeftSmall);
22326  
22327  ;// ./node_modules/@wordpress/icons/build-module/library/chevron-right-small.js
22328  /**
22329   * WordPress dependencies
22330   */
22331  
22332  
22333  const chevronRightSmall = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
22334    xmlns: "http://www.w3.org/2000/svg",
22335    viewBox: "0 0 24 24",
22336    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
22337      d: "M10.8622 8.04053L14.2805 12.0286L10.8622 16.0167L9.72327 15.0405L12.3049 12.0286L9.72327 9.01672L10.8622 8.04053Z"
22338    })
22339  });
22340  /* harmony default export */ const chevron_right_small = (chevronRightSmall);
22341  
22342  ;// ./node_modules/@wordpress/block-editor/build-module/components/link-control/settings-drawer.js
22343  /**
22344   * WordPress dependencies
22345   */
22346  
22347  
22348  
22349  
22350  
22351  
22352  function LinkSettingsDrawer({
22353    children,
22354    settingsOpen,
22355    setSettingsOpen
22356  }) {
22357    const prefersReducedMotion = (0,external_wp_compose_namespaceObject.useReducedMotion)();
22358    const MaybeAnimatePresence = prefersReducedMotion ? external_wp_element_namespaceObject.Fragment : external_wp_components_namespaceObject.__unstableAnimatePresence;
22359    const MaybeMotionDiv = prefersReducedMotion ? 'div' : external_wp_components_namespaceObject.__unstableMotion.div;
22360    const id = (0,external_wp_compose_namespaceObject.useInstanceId)(LinkSettingsDrawer);
22361    const settingsDrawerId = `link-control-settings-drawer-$id}`;
22362    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
22363      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
22364        __next40pxDefaultSize: true,
22365        className: "block-editor-link-control__drawer-toggle",
22366        "aria-expanded": settingsOpen,
22367        onClick: () => setSettingsOpen(!settingsOpen),
22368        icon: (0,external_wp_i18n_namespaceObject.isRTL)() ? chevron_left_small : chevron_right_small,
22369        "aria-controls": settingsDrawerId,
22370        children: (0,external_wp_i18n_namespaceObject._x)('Advanced', 'Additional link settings')
22371      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(MaybeAnimatePresence, {
22372        children: settingsOpen && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(MaybeMotionDiv, {
22373          className: "block-editor-link-control__drawer",
22374          hidden: !settingsOpen,
22375          id: settingsDrawerId,
22376          initial: "collapsed",
22377          animate: "open",
22378          exit: "collapsed",
22379          variants: {
22380            open: {
22381              opacity: 1,
22382              height: 'auto'
22383            },
22384            collapsed: {
22385              opacity: 0,
22386              height: 0
22387            }
22388          },
22389          transition: {
22390            duration: 0.1
22391          },
22392          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
22393            className: "block-editor-link-control__drawer-inner",
22394            children: children
22395          })
22396        })
22397      })]
22398    });
22399  }
22400  /* harmony default export */ const settings_drawer = (LinkSettingsDrawer);
22401  
22402  // EXTERNAL MODULE: external "React"
22403  var external_React_ = __webpack_require__(1609);
22404  ;// ./node_modules/@wordpress/block-editor/build-module/components/url-input/index.js
22405  /**
22406   * External dependencies
22407   */
22408  
22409  
22410  /**
22411   * WordPress dependencies
22412   */
22413  
22414  
22415  
22416  
22417  
22418  
22419  
22420  
22421  /**
22422   * Internal dependencies
22423   */
22424  
22425  
22426  /**
22427   * Whether the argument is a function.
22428   *
22429   * @param {*} maybeFunc The argument to check.
22430   * @return {boolean} True if the argument is a function, false otherwise.
22431   */
22432  
22433  
22434  function isFunction(maybeFunc) {
22435    return typeof maybeFunc === 'function';
22436  }
22437  class URLInput extends external_wp_element_namespaceObject.Component {
22438    constructor(props) {
22439      super(props);
22440      this.onChange = this.onChange.bind(this);
22441      this.onFocus = this.onFocus.bind(this);
22442      this.onKeyDown = this.onKeyDown.bind(this);
22443      this.selectLink = this.selectLink.bind(this);
22444      this.handleOnClick = this.handleOnClick.bind(this);
22445      this.bindSuggestionNode = this.bindSuggestionNode.bind(this);
22446      this.autocompleteRef = props.autocompleteRef || (0,external_wp_element_namespaceObject.createRef)();
22447      this.inputRef = (0,external_wp_element_namespaceObject.createRef)();
22448      this.updateSuggestions = (0,external_wp_compose_namespaceObject.debounce)(this.updateSuggestions.bind(this), 200);
22449      this.suggestionNodes = [];
22450      this.suggestionsRequest = null;
22451      this.state = {
22452        suggestions: [],
22453        showSuggestions: false,
22454        suggestionsValue: null,
22455        selectedSuggestion: null,
22456        suggestionsListboxId: '',
22457        suggestionOptionIdPrefix: ''
22458      };
22459    }
22460    componentDidUpdate(prevProps) {
22461      const {
22462        showSuggestions,
22463        selectedSuggestion
22464      } = this.state;
22465      const {
22466        value,
22467        __experimentalShowInitialSuggestions = false
22468      } = this.props;
22469  
22470      // Only have to worry about scrolling selected suggestion into view
22471      // when already expanded.
22472      if (showSuggestions && selectedSuggestion !== null && this.suggestionNodes[selectedSuggestion]) {
22473        this.suggestionNodes[selectedSuggestion].scrollIntoView({
22474          behavior: 'instant',
22475          block: 'nearest',
22476          inline: 'nearest'
22477        });
22478      }
22479  
22480      // Update suggestions when the value changes.
22481      if (prevProps.value !== value && !this.props.disableSuggestions) {
22482        if (value?.length) {
22483          // If the new value is not empty we need to update with suggestions for it.
22484          this.updateSuggestions(value);
22485        } else if (__experimentalShowInitialSuggestions) {
22486          // If the new value is empty and we can show initial suggestions, then show initial suggestions.
22487          this.updateSuggestions();
22488        }
22489      }
22490    }
22491    componentDidMount() {
22492      if (this.shouldShowInitialSuggestions()) {
22493        this.updateSuggestions();
22494      }
22495    }
22496    componentWillUnmount() {
22497      this.suggestionsRequest?.cancel?.();
22498      this.suggestionsRequest = null;
22499    }
22500    bindSuggestionNode(index) {
22501      return ref => {
22502        this.suggestionNodes[index] = ref;
22503      };
22504    }
22505    shouldShowInitialSuggestions() {
22506      const {
22507        __experimentalShowInitialSuggestions = false,
22508        value
22509      } = this.props;
22510      return __experimentalShowInitialSuggestions && !(value && value.length);
22511    }
22512    updateSuggestions(value = '') {
22513      const {
22514        __experimentalFetchLinkSuggestions: fetchLinkSuggestions,
22515        __experimentalHandleURLSuggestions: handleURLSuggestions
22516      } = this.props;
22517      if (!fetchLinkSuggestions) {
22518        return;
22519      }
22520  
22521      // Initial suggestions may only show if there is no value
22522      // (note: this includes whitespace).
22523      const isInitialSuggestions = !value?.length;
22524  
22525      // Trim only now we've determined whether or not it originally had a "length"
22526      // (even if that value was all whitespace).
22527      value = value.trim();
22528  
22529      // Allow a suggestions request if:
22530      // - there are at least 2 characters in the search input (except manual searches where
22531      //   search input length is not required to trigger a fetch)
22532      // - this is a direct entry (eg: a URL)
22533      if (!isInitialSuggestions && (value.length < 2 || !handleURLSuggestions && (0,external_wp_url_namespaceObject.isURL)(value))) {
22534        this.suggestionsRequest?.cancel?.();
22535        this.suggestionsRequest = null;
22536        this.setState({
22537          suggestions: [],
22538          showSuggestions: false,
22539          suggestionsValue: value,
22540          selectedSuggestion: null,
22541          loading: false
22542        });
22543        return;
22544      }
22545      this.setState({
22546        selectedSuggestion: null,
22547        loading: true
22548      });
22549      const request = fetchLinkSuggestions(value, {
22550        isInitialSuggestions
22551      });
22552      request.then(suggestions => {
22553        // A fetch Promise doesn't have an abort option. It's mimicked by
22554        // comparing the request reference in on the instance, which is
22555        // reset or deleted on subsequent requests or unmounting.
22556        if (this.suggestionsRequest !== request) {
22557          return;
22558        }
22559        this.setState({
22560          suggestions,
22561          suggestionsValue: value,
22562          loading: false,
22563          showSuggestions: !!suggestions.length
22564        });
22565        if (!!suggestions.length) {
22566          this.props.debouncedSpeak((0,external_wp_i18n_namespaceObject.sprintf)(/* translators: %d: number of results. */
22567          (0,external_wp_i18n_namespaceObject._n)('%d result found, use up and down arrow keys to navigate.', '%d results found, use up and down arrow keys to navigate.', suggestions.length), suggestions.length), 'assertive');
22568        } else {
22569          this.props.debouncedSpeak((0,external_wp_i18n_namespaceObject.__)('No results.'), 'assertive');
22570        }
22571      }).catch(() => {
22572        if (this.suggestionsRequest !== request) {
22573          return;
22574        }
22575        this.setState({
22576          loading: false
22577        });
22578      }).finally(() => {
22579        // If this is the current promise then reset the reference
22580        // to allow for checking if a new request is made.
22581        if (this.suggestionsRequest === request) {
22582          this.suggestionsRequest = null;
22583        }
22584      });
22585  
22586      // Note that this assignment is handled *before* the async search request
22587      // as a Promise always resolves on the next tick of the event loop.
22588      this.suggestionsRequest = request;
22589    }
22590    onChange(newValue) {
22591      this.props.onChange(newValue);
22592    }
22593    onFocus() {
22594      const {
22595        suggestions
22596      } = this.state;
22597      const {
22598        disableSuggestions,
22599        value
22600      } = this.props;
22601  
22602      // When opening the link editor, if there's a value present, we want to load the suggestions pane with the results for this input search value
22603      // Don't re-run the suggestions on focus if there are already suggestions present (prevents searching again when tabbing between the input and buttons)
22604      // or there is already a request in progress.
22605      if (value && !disableSuggestions && !(suggestions && suggestions.length) && this.suggestionsRequest === null) {
22606        // Ensure the suggestions are updated with the current input value.
22607        this.updateSuggestions(value);
22608      }
22609    }
22610    onKeyDown(event) {
22611      this.props.onKeyDown?.(event);
22612      const {
22613        showSuggestions,
22614        selectedSuggestion,
22615        suggestions,
22616        loading
22617      } = this.state;
22618  
22619      // If the suggestions are not shown or loading, we shouldn't handle the arrow keys
22620      // We shouldn't preventDefault to allow block arrow keys navigation.
22621      if (!showSuggestions || !suggestions.length || loading) {
22622        // In the Windows version of Firefox the up and down arrows don't move the caret
22623        // within an input field like they do for Mac Firefox/Chrome/Safari. This causes
22624        // a form of focus trapping that is disruptive to the user experience. This disruption
22625        // only happens if the caret is not in the first or last position in the text input.
22626        // See: https://github.com/WordPress/gutenberg/issues/5693#issuecomment-436684747
22627        switch (event.keyCode) {
22628          // When UP is pressed, if the caret is at the start of the text, move it to the 0
22629          // position.
22630          case external_wp_keycodes_namespaceObject.UP:
22631            {
22632              if (0 !== event.target.selectionStart) {
22633                event.preventDefault();
22634  
22635                // Set the input caret to position 0.
22636                event.target.setSelectionRange(0, 0);
22637              }
22638              break;
22639            }
22640          // When DOWN is pressed, if the caret is not at the end of the text, move it to the
22641          // last position.
22642          case external_wp_keycodes_namespaceObject.DOWN:
22643            {
22644              if (this.props.value.length !== event.target.selectionStart) {
22645                event.preventDefault();
22646  
22647                // Set the input caret to the last position.
22648                event.target.setSelectionRange(this.props.value.length, this.props.value.length);
22649              }
22650              break;
22651            }
22652  
22653          // Submitting while loading should trigger onSubmit.
22654          case external_wp_keycodes_namespaceObject.ENTER:
22655            {
22656              if (this.props.onSubmit) {
22657                event.preventDefault();
22658                this.props.onSubmit(null, event);
22659              }
22660              break;
22661            }
22662        }
22663        return;
22664      }
22665      const suggestion = this.state.suggestions[this.state.selectedSuggestion];
22666      switch (event.keyCode) {
22667        case external_wp_keycodes_namespaceObject.UP:
22668          {
22669            event.preventDefault();
22670            const previousIndex = !selectedSuggestion ? suggestions.length - 1 : selectedSuggestion - 1;
22671            this.setState({
22672              selectedSuggestion: previousIndex
22673            });
22674            break;
22675          }
22676        case external_wp_keycodes_namespaceObject.DOWN:
22677          {
22678            event.preventDefault();
22679            const nextIndex = selectedSuggestion === null || selectedSuggestion === suggestions.length - 1 ? 0 : selectedSuggestion + 1;
22680            this.setState({
22681              selectedSuggestion: nextIndex
22682            });
22683            break;
22684          }
22685        case external_wp_keycodes_namespaceObject.TAB:
22686          {
22687            if (this.state.selectedSuggestion !== null) {
22688              this.selectLink(suggestion);
22689              // Announce a link has been selected when tabbing away from the input field.
22690              this.props.speak((0,external_wp_i18n_namespaceObject.__)('Link selected.'));
22691            }
22692            break;
22693          }
22694        case external_wp_keycodes_namespaceObject.ENTER:
22695          {
22696            event.preventDefault();
22697            if (this.state.selectedSuggestion !== null) {
22698              this.selectLink(suggestion);
22699              if (this.props.onSubmit) {
22700                this.props.onSubmit(suggestion, event);
22701              }
22702            } else if (this.props.onSubmit) {
22703              this.props.onSubmit(null, event);
22704            }
22705            break;
22706          }
22707      }
22708    }
22709    selectLink(suggestion) {
22710      this.props.onChange(suggestion.url, suggestion);
22711      this.setState({
22712        selectedSuggestion: null,
22713        showSuggestions: false
22714      });
22715    }
22716    handleOnClick(suggestion) {
22717      this.selectLink(suggestion);
22718      // Move focus to the input field when a link suggestion is clicked.
22719      this.inputRef.current.focus();
22720    }
22721    static getDerivedStateFromProps({
22722      value,
22723      instanceId,
22724      disableSuggestions,
22725      __experimentalShowInitialSuggestions = false
22726    }, {
22727      showSuggestions
22728    }) {
22729      let shouldShowSuggestions = showSuggestions;
22730      const hasValue = value && value.length;
22731      if (!__experimentalShowInitialSuggestions && !hasValue) {
22732        shouldShowSuggestions = false;
22733      }
22734      if (disableSuggestions === true) {
22735        shouldShowSuggestions = false;
22736      }
22737      return {
22738        showSuggestions: shouldShowSuggestions,
22739        suggestionsListboxId: `block-editor-url-input-suggestions-$instanceId}`,
22740        suggestionOptionIdPrefix: `block-editor-url-input-suggestion-$instanceId}`
22741      };
22742    }
22743    render() {
22744      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
22745        children: [this.renderControl(), this.renderSuggestions()]
22746      });
22747    }
22748    renderControl() {
22749      const {
22750        label = null,
22751        className,
22752        isFullWidth,
22753        instanceId,
22754        placeholder = (0,external_wp_i18n_namespaceObject.__)('Paste URL or type to search'),
22755        __experimentalRenderControl: renderControl,
22756        value = '',
22757        hideLabelFromVision = false
22758      } = this.props;
22759      const {
22760        loading,
22761        showSuggestions,
22762        selectedSuggestion,
22763        suggestionsListboxId,
22764        suggestionOptionIdPrefix
22765      } = this.state;
22766      const inputId = `url-input-control-$instanceId}`;
22767      const controlProps = {
22768        id: inputId,
22769        // Passes attribute to label for the for attribute
22770        label,
22771        className: dist_clsx('block-editor-url-input', className, {
22772          'is-full-width': isFullWidth
22773        }),
22774        hideLabelFromVision
22775      };
22776      const inputProps = {
22777        id: inputId,
22778        value,
22779        required: true,
22780        type: 'text',
22781        onChange: this.onChange,
22782        onFocus: this.onFocus,
22783        placeholder,
22784        onKeyDown: this.onKeyDown,
22785        role: 'combobox',
22786        'aria-label': label ? undefined : (0,external_wp_i18n_namespaceObject.__)('URL'),
22787        // Ensure input always has an accessible label
22788        'aria-expanded': showSuggestions,
22789        'aria-autocomplete': 'list',
22790        'aria-owns': suggestionsListboxId,
22791        'aria-activedescendant': selectedSuggestion !== null ? `$suggestionOptionIdPrefix}-$selectedSuggestion}` : undefined,
22792        ref: this.inputRef,
22793        suffix: this.props.suffix
22794      };
22795      if (renderControl) {
22796        return renderControl(controlProps, inputProps, loading);
22797      }
22798      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.BaseControl, {
22799        __nextHasNoMarginBottom: true,
22800        ...controlProps,
22801        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalInputControl, {
22802          ...inputProps,
22803          __next40pxDefaultSize: true
22804        }), loading && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Spinner, {})]
22805      });
22806    }
22807    renderSuggestions() {
22808      const {
22809        className,
22810        __experimentalRenderSuggestions: renderSuggestions
22811      } = this.props;
22812      const {
22813        showSuggestions,
22814        suggestions,
22815        suggestionsValue,
22816        selectedSuggestion,
22817        suggestionsListboxId,
22818        suggestionOptionIdPrefix,
22819        loading
22820      } = this.state;
22821      if (!showSuggestions || suggestions.length === 0) {
22822        return null;
22823      }
22824      const suggestionsListProps = {
22825        id: suggestionsListboxId,
22826        ref: this.autocompleteRef,
22827        role: 'listbox'
22828      };
22829      const buildSuggestionItemProps = (suggestion, index) => {
22830        return {
22831          role: 'option',
22832          tabIndex: '-1',
22833          id: `$suggestionOptionIdPrefix}-$index}`,
22834          ref: this.bindSuggestionNode(index),
22835          'aria-selected': index === selectedSuggestion ? true : undefined
22836        };
22837      };
22838      if (isFunction(renderSuggestions)) {
22839        return renderSuggestions({
22840          suggestions,
22841          selectedSuggestion,
22842          suggestionsListProps,
22843          buildSuggestionItemProps,
22844          isLoading: loading,
22845          handleSuggestionClick: this.handleOnClick,
22846          isInitialSuggestions: !suggestionsValue?.length,
22847          currentInputValue: suggestionsValue
22848        });
22849      }
22850      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Popover, {
22851        placement: "bottom",
22852        focusOnMount: false,
22853        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
22854          ...suggestionsListProps,
22855          className: dist_clsx('block-editor-url-input__suggestions', {
22856            [`$className}__suggestions`]: className
22857          }),
22858          children: suggestions.map((suggestion, index) => /*#__PURE__*/(0,external_React_.createElement)(external_wp_components_namespaceObject.Button, {
22859            __next40pxDefaultSize: true,
22860            ...buildSuggestionItemProps(suggestion, index),
22861            key: suggestion.id,
22862            className: dist_clsx('block-editor-url-input__suggestion', {
22863              'is-selected': index === selectedSuggestion
22864            }),
22865            onClick: () => this.handleOnClick(suggestion)
22866          }, suggestion.title))
22867        })
22868      });
22869    }
22870  }
22871  
22872  /**
22873   * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/url-input/README.md
22874   */
22875  /* harmony default export */ const url_input = ((0,external_wp_compose_namespaceObject.compose)(external_wp_compose_namespaceObject.withSafeTimeout, external_wp_components_namespaceObject.withSpokenMessages, external_wp_compose_namespaceObject.withInstanceId, (0,external_wp_data_namespaceObject.withSelect)((select, props) => {
22876    // If a link suggestions handler is already provided then
22877    // bail.
22878    if (isFunction(props.__experimentalFetchLinkSuggestions)) {
22879      return;
22880    }
22881    const {
22882      getSettings
22883    } = select(store);
22884    return {
22885      __experimentalFetchLinkSuggestions: getSettings().__experimentalFetchLinkSuggestions
22886    };
22887  }))(URLInput));
22888  
22889  ;// ./node_modules/@wordpress/icons/build-module/library/plus.js
22890  /**
22891   * WordPress dependencies
22892   */
22893  
22894  
22895  const plus = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
22896    xmlns: "http://www.w3.org/2000/svg",
22897    viewBox: "0 0 24 24",
22898    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
22899      d: "M11 12.5V17.5H12.5V12.5H17.5V11H12.5V6H11V11H6V12.5H11Z"
22900    })
22901  });
22902  /* harmony default export */ const library_plus = (plus);
22903  
22904  ;// ./node_modules/@wordpress/block-editor/build-module/components/link-control/search-create-button.js
22905  /**
22906   * WordPress dependencies
22907   */
22908  
22909  
22910  
22911  
22912  
22913  const LinkControlSearchCreate = ({
22914    searchTerm,
22915    onClick,
22916    itemProps,
22917    buttonText
22918  }) => {
22919    if (!searchTerm) {
22920      return null;
22921    }
22922    let text;
22923    if (buttonText) {
22924      text = typeof buttonText === 'function' ? buttonText(searchTerm) : buttonText;
22925    } else {
22926      text = (0,external_wp_element_namespaceObject.createInterpolateElement)((0,external_wp_i18n_namespaceObject.sprintf)(/* translators: %s: search term. */
22927      (0,external_wp_i18n_namespaceObject.__)('Create: <mark>%s</mark>'), searchTerm), {
22928        mark: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("mark", {})
22929      });
22930    }
22931    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, {
22932      ...itemProps,
22933      iconPosition: "left",
22934      icon: library_plus,
22935      className: "block-editor-link-control__search-item",
22936      onClick: onClick,
22937      children: text
22938    });
22939  };
22940  /* harmony default export */ const search_create_button = (LinkControlSearchCreate);
22941  
22942  ;// ./node_modules/@wordpress/icons/build-module/library/post-list.js
22943  /**
22944   * WordPress dependencies
22945   */
22946  
22947  
22948  const postList = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
22949    viewBox: "0 0 24 24",
22950    xmlns: "http://www.w3.org/2000/svg",
22951    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
22952      d: "M18 5.5H6a.5.5 0 0 0-.5.5v12a.5.5 0 0 0 .5.5h12a.5.5 0 0 0 .5-.5V6a.5.5 0 0 0-.5-.5ZM6 4h12a2 2 0 0 1 2 2v12a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2V6a2 2 0 0 1 2-2Zm1 5h1.5v1.5H7V9Zm1.5 4.5H7V15h1.5v-1.5ZM10 9h7v1.5h-7V9Zm7 4.5h-7V15h7v-1.5Z"
22953    })
22954  });
22955  /* harmony default export */ const post_list = (postList);
22956  
22957  ;// ./node_modules/@wordpress/icons/build-module/library/page.js
22958  /**
22959   * WordPress dependencies
22960   */
22961  
22962  
22963  const page = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_primitives_namespaceObject.SVG, {
22964    xmlns: "http://www.w3.org/2000/svg",
22965    viewBox: "0 0 24 24",
22966    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
22967      d: "M15.5 7.5h-7V9h7V7.5Zm-7 3.5h7v1.5h-7V11Zm7 3.5h-7V16h7v-1.5Z"
22968    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
22969      d: "M17 4H7a2 2 0 0 0-2 2v12a2 2 0 0 0 2 2h10a2 2 0 0 0 2-2V6a2 2 0 0 0-2-2ZM7 5.5h10a.5.5 0 0 1 .5.5v12a.5.5 0 0 1-.5.5H7a.5.5 0 0 1-.5-.5V6a.5.5 0 0 1 .5-.5Z"
22970    })]
22971  });
22972  /* harmony default export */ const library_page = (page);
22973  
22974  ;// ./node_modules/@wordpress/icons/build-module/library/tag.js
22975  /**
22976   * WordPress dependencies
22977   */
22978  
22979  
22980  const tag = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
22981    xmlns: "http://www.w3.org/2000/svg",
22982    viewBox: "0 0 24 24",
22983    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
22984      d: "M4.75 4a.75.75 0 0 0-.75.75v7.826c0 .2.08.39.22.53l6.72 6.716a2.313 2.313 0 0 0 3.276-.001l5.61-5.611-.531-.53.532.528a2.315 2.315 0 0 0 0-3.264L13.104 4.22a.75.75 0 0 0-.53-.22H4.75ZM19 12.576a.815.815 0 0 1-.236.574l-5.61 5.611a.814.814 0 0 1-1.153 0L5.5 12.264V5.5h6.763l6.5 6.502a.816.816 0 0 1 .237.574ZM8.75 9.75a1 1 0 1 0 0-2 1 1 0 0 0 0 2Z"
22985    })
22986  });
22987  /* harmony default export */ const library_tag = (tag);
22988  
22989  ;// ./node_modules/@wordpress/icons/build-module/library/category.js
22990  /**
22991   * WordPress dependencies
22992   */
22993  
22994  
22995  const category = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
22996    viewBox: "0 0 24 24",
22997    xmlns: "http://www.w3.org/2000/svg",
22998    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
22999      d: "M6 5.5h3a.5.5 0 01.5.5v3a.5.5 0 01-.5.5H6a.5.5 0 01-.5-.5V6a.5.5 0 01.5-.5zM4 6a2 2 0 012-2h3a2 2 0 012 2v3a2 2 0 01-2 2H6a2 2 0 01-2-2V6zm11-.5h3a.5.5 0 01.5.5v3a.5.5 0 01-.5.5h-3a.5.5 0 01-.5-.5V6a.5.5 0 01.5-.5zM13 6a2 2 0 012-2h3a2 2 0 012 2v3a2 2 0 01-2 2h-3a2 2 0 01-2-2V6zm5 8.5h-3a.5.5 0 00-.5.5v3a.5.5 0 00.5.5h3a.5.5 0 00.5-.5v-3a.5.5 0 00-.5-.5zM15 13a2 2 0 00-2 2v3a2 2 0 002 2h3a2 2 0 002-2v-3a2 2 0 00-2-2h-3zm-9 1.5h3a.5.5 0 01.5.5v3a.5.5 0 01-.5.5H6a.5.5 0 01-.5-.5v-3a.5.5 0 01.5-.5zM4 15a2 2 0 012-2h3a2 2 0 012 2v3a2 2 0 01-2 2H6a2 2 0 01-2-2v-3z",
23000      fillRule: "evenodd",
23001      clipRule: "evenodd"
23002    })
23003  });
23004  /* harmony default export */ const library_category = (category);
23005  
23006  ;// ./node_modules/@wordpress/icons/build-module/library/file.js
23007  /**
23008   * WordPress dependencies
23009   */
23010  
23011  
23012  const file = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
23013    viewBox: "0 0 24 24",
23014    xmlns: "http://www.w3.org/2000/svg",
23015    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
23016      fillRule: "evenodd",
23017      clipRule: "evenodd",
23018      d: "M12.848 8a1 1 0 0 1-.914-.594l-.723-1.63a.5.5 0 0 0-.447-.276H5a.5.5 0 0 0-.5.5v11.5a.5.5 0 0 0 .5.5h14a.5.5 0 0 0 .5-.5v-9A.5.5 0 0 0 19 8h-6.152Zm.612-1.5a.5.5 0 0 1-.462-.31l-.445-1.084A2 2 0 0 0 10.763 4H5a2 2 0 0 0-2 2v11.5a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2v-9a2 2 0 0 0-2-2h-5.54Z"
23019    })
23020  });
23021  /* harmony default export */ const library_file = (file);
23022  
23023  ;// ./node_modules/@wordpress/icons/build-module/library/globe.js
23024  /**
23025   * WordPress dependencies
23026   */
23027  
23028  
23029  const globe = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
23030    xmlns: "http://www.w3.org/2000/svg",
23031    viewBox: "0 0 24 24",
23032    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
23033      d: "M12 3.3c-4.8 0-8.8 3.9-8.8 8.8 0 4.8 3.9 8.8 8.8 8.8 4.8 0 8.8-3.9 8.8-8.8s-4-8.8-8.8-8.8zm6.5 5.5h-2.6C15.4 7.3 14.8 6 14 5c2 .6 3.6 2 4.5 3.8zm.7 3.2c0 .6-.1 1.2-.2 1.8h-2.9c.1-.6.1-1.2.1-1.8s-.1-1.2-.1-1.8H19c.2.6.2 1.2.2 1.8zM12 18.7c-1-.7-1.8-1.9-2.3-3.5h4.6c-.5 1.6-1.3 2.9-2.3 3.5zm-2.6-4.9c-.1-.6-.1-1.1-.1-1.8 0-.6.1-1.2.1-1.8h5.2c.1.6.1 1.1.1 1.8s-.1 1.2-.1 1.8H9.4zM4.8 12c0-.6.1-1.2.2-1.8h2.9c-.1.6-.1 1.2-.1 1.8 0 .6.1 1.2.1 1.8H5c-.2-.6-.2-1.2-.2-1.8zM12 5.3c1 .7 1.8 1.9 2.3 3.5H9.7c.5-1.6 1.3-2.9 2.3-3.5zM10 5c-.8 1-1.4 2.3-1.8 3.8H5.5C6.4 7 8 5.6 10 5zM5.5 15.3h2.6c.4 1.5 1 2.8 1.8 3.7-1.8-.6-3.5-2-4.4-3.7zM14 19c.8-1 1.4-2.2 1.8-3.7h2.6C17.6 17 16 18.4 14 19z"
23034    })
23035  });
23036  /* harmony default export */ const library_globe = (globe);
23037  
23038  ;// ./node_modules/@wordpress/icons/build-module/library/home.js
23039  /**
23040   * WordPress dependencies
23041   */
23042  
23043  
23044  const home = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
23045    xmlns: "http://www.w3.org/2000/svg",
23046    viewBox: "0 0 24 24",
23047    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
23048      d: "M12 4L4 7.9V20h16V7.9L12 4zm6.5 14.5H14V13h-4v5.5H5.5V8.8L12 5.7l6.5 3.1v9.7z"
23049    })
23050  });
23051  /* harmony default export */ const library_home = (home);
23052  
23053  ;// ./node_modules/@wordpress/icons/build-module/library/verse.js
23054  /**
23055   * WordPress dependencies
23056   */
23057  
23058  
23059  const verse = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
23060    viewBox: "0 0 24 24",
23061    xmlns: "http://www.w3.org/2000/svg",
23062    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
23063      d: "M17.8 2l-.9.3c-.1 0-3.6 1-5.2 2.1C10 5.5 9.3 6.5 8.9 7.1c-.6.9-1.7 4.7-1.7 6.3l-.9 2.3c-.2.4 0 .8.4 1 .1 0 .2.1.3.1.3 0 .6-.2.7-.5l.6-1.5c.3 0 .7-.1 1.2-.2.7-.1 1.4-.3 2.2-.5.8-.2 1.6-.5 2.4-.8.7-.3 1.4-.7 1.9-1.2s.8-1.2 1-1.9c.2-.7.3-1.6.4-2.4.1-.8.1-1.7.2-2.5 0-.8.1-1.5.2-2.1V2zm-1.9 5.6c-.1.8-.2 1.5-.3 2.1-.2.6-.4 1-.6 1.3-.3.3-.8.6-1.4.9-.7.3-1.4.5-2.2.8-.6.2-1.3.3-1.8.4L15 7.5c.3-.3.6-.7 1-1.1 0 .4 0 .8-.1 1.2zM6 20h8v-1.5H6V20z"
23064    })
23065  });
23066  /* harmony default export */ const library_verse = (verse);
23067  
23068  ;// ./node_modules/@wordpress/block-editor/build-module/components/link-control/search-item.js
23069  /**
23070   * WordPress dependencies
23071   */
23072  
23073  
23074  
23075  
23076  
23077  
23078  
23079  
23080  const ICONS_MAP = {
23081    post: post_list,
23082    page: library_page,
23083    post_tag: library_tag,
23084    category: library_category,
23085    attachment: library_file
23086  };
23087  function SearchItemIcon({
23088    isURL,
23089    suggestion
23090  }) {
23091    let icon = null;
23092    if (isURL) {
23093      icon = library_globe;
23094    } else if (suggestion.type in ICONS_MAP) {
23095      icon = ICONS_MAP[suggestion.type];
23096      if (suggestion.type === 'page') {
23097        if (suggestion.isFrontPage) {
23098          icon = library_home;
23099        }
23100        if (suggestion.isBlogHome) {
23101          icon = library_verse;
23102        }
23103      }
23104    }
23105    if (icon) {
23106      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(build_module_icon, {
23107        className: "block-editor-link-control__search-item-icon",
23108        icon: icon
23109      });
23110    }
23111    return null;
23112  }
23113  
23114  /**
23115   * Adds a leading slash to a url if it doesn't already have one.
23116   * @param {string} url the url to add a leading slash to.
23117   * @return {string} the url with a leading slash.
23118   */
23119  function addLeadingSlash(url) {
23120    const trimmedURL = url?.trim();
23121    if (!trimmedURL?.length) {
23122      return url;
23123    }
23124    return url?.replace(/^\/?/, '/');
23125  }
23126  function removeTrailingSlash(url) {
23127    const trimmedURL = url?.trim();
23128    if (!trimmedURL?.length) {
23129      return url;
23130    }
23131    return url?.replace(/\/$/, '');
23132  }
23133  const partialRight = (fn, ...partialArgs) => (...args) => fn(...args, ...partialArgs);
23134  const defaultTo = d => v => {
23135    return v === null || v === undefined || v !== v ? d : v;
23136  };
23137  
23138  /**
23139   * Prepares a URL for display in the UI.
23140   * - decodes the URL.
23141   * - filters it (removes protocol, www, etc.).
23142   * - truncates it if necessary.
23143   * - adds a leading slash.
23144   * @param {string} url the url.
23145   * @return {string} the processed url to display.
23146   */
23147  function getURLForDisplay(url) {
23148    if (!url) {
23149      return url;
23150    }
23151    return (0,external_wp_compose_namespaceObject.pipe)(external_wp_url_namespaceObject.safeDecodeURI, external_wp_url_namespaceObject.getPath, defaultTo(''), partialRight(external_wp_url_namespaceObject.filterURLForDisplay, 24), removeTrailingSlash, addLeadingSlash)(url);
23152  }
23153  const LinkControlSearchItem = ({
23154    itemProps,
23155    suggestion,
23156    searchTerm,
23157    onClick,
23158    isURL = false,
23159    shouldShowType = false
23160  }) => {
23161    const info = isURL ? (0,external_wp_i18n_namespaceObject.__)('Press ENTER to add this link') : getURLForDisplay(suggestion.url);
23162    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, {
23163      ...itemProps,
23164      info: info,
23165      iconPosition: "left",
23166      icon: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(SearchItemIcon, {
23167        suggestion: suggestion,
23168        isURL: isURL
23169      }),
23170      onClick: onClick,
23171      shortcut: shouldShowType && getVisualTypeName(suggestion),
23172      className: "block-editor-link-control__search-item",
23173      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.TextHighlight
23174      // The component expects a plain text string.
23175      , {
23176        text: (0,external_wp_dom_namespaceObject.__unstableStripHTML)(suggestion.title),
23177        highlight: searchTerm
23178      })
23179    });
23180  };
23181  function getVisualTypeName(suggestion) {
23182    if (suggestion.isFrontPage) {
23183      return 'front page';
23184    }
23185    if (suggestion.isBlogHome) {
23186      return 'blog home';
23187    }
23188  
23189    // Rename 'post_tag' to 'tag'. Ideally, the API would return the localised CPT or taxonomy label.
23190    return suggestion.type === 'post_tag' ? 'tag' : suggestion.type;
23191  }
23192  /* harmony default export */ const search_item = (LinkControlSearchItem);
23193  const __experimentalLinkControlSearchItem = props => {
23194    external_wp_deprecated_default()('wp.blockEditor.__experimentalLinkControlSearchItem', {
23195      since: '6.8'
23196    });
23197    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(LinkControlSearchItem, {
23198      ...props
23199    });
23200  };
23201  
23202  ;// ./node_modules/@wordpress/block-editor/build-module/components/link-control/constants.js
23203  /**
23204   * WordPress dependencies
23205   */
23206  
23207  
23208  // Used as a unique identifier for the "Create" option within search results.
23209  // Used to help distinguish the "Create" suggestion within the search results in
23210  // order to handle it as a unique case.
23211  const CREATE_TYPE = '__CREATE__';
23212  const TEL_TYPE = 'tel';
23213  const URL_TYPE = 'link';
23214  const MAILTO_TYPE = 'mailto';
23215  const INTERNAL_TYPE = 'internal';
23216  const LINK_ENTRY_TYPES = [URL_TYPE, MAILTO_TYPE, TEL_TYPE, INTERNAL_TYPE];
23217  const DEFAULT_LINK_SETTINGS = [{
23218    id: 'opensInNewTab',
23219    title: (0,external_wp_i18n_namespaceObject.__)('Open in new tab')
23220  }];
23221  
23222  ;// ./node_modules/@wordpress/block-editor/build-module/components/link-control/search-results.js
23223  /**
23224   * WordPress dependencies
23225   */
23226  
23227  
23228  
23229  /**
23230   * External dependencies
23231   */
23232  
23233  
23234  /**
23235   * Internal dependencies
23236   */
23237  
23238  
23239  
23240  
23241  
23242  function LinkControlSearchResults({
23243    withCreateSuggestion,
23244    currentInputValue,
23245    handleSuggestionClick,
23246    suggestionsListProps,
23247    buildSuggestionItemProps,
23248    suggestions,
23249    selectedSuggestion,
23250    isLoading,
23251    isInitialSuggestions,
23252    createSuggestionButtonText,
23253    suggestionsQuery
23254  }) {
23255    const resultsListClasses = dist_clsx('block-editor-link-control__search-results', {
23256      'is-loading': isLoading
23257    });
23258    const isSingleDirectEntryResult = suggestions.length === 1 && LINK_ENTRY_TYPES.includes(suggestions[0].type);
23259    const shouldShowCreateSuggestion = withCreateSuggestion && !isSingleDirectEntryResult && !isInitialSuggestions;
23260    // If the query has a specified type, then we can skip showing them in the result. See #24839.
23261    const shouldShowSuggestionsTypes = !suggestionsQuery?.type;
23262    const labelText = isInitialSuggestions ? (0,external_wp_i18n_namespaceObject.__)('Suggestions') : (0,external_wp_i18n_namespaceObject.sprintf)(/* translators: %s: search term. */
23263    (0,external_wp_i18n_namespaceObject.__)('Search results for "%s"'), currentInputValue);
23264    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
23265      className: "block-editor-link-control__search-results-wrapper",
23266      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
23267        ...suggestionsListProps,
23268        className: resultsListClasses,
23269        "aria-label": labelText,
23270        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuGroup, {
23271          children: suggestions.map((suggestion, index) => {
23272            if (shouldShowCreateSuggestion && CREATE_TYPE === suggestion.type) {
23273              return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(search_create_button, {
23274                searchTerm: currentInputValue,
23275                buttonText: createSuggestionButtonText,
23276                onClick: () => handleSuggestionClick(suggestion)
23277                // Intentionally only using `type` here as
23278                // the constant is enough to uniquely
23279                // identify the single "CREATE" suggestion.
23280                ,
23281  
23282                itemProps: buildSuggestionItemProps(suggestion, index),
23283                isSelected: index === selectedSuggestion
23284              }, suggestion.type);
23285            }
23286  
23287            // If we're not handling "Create" suggestions above then
23288            // we don't want them in the main results so exit early.
23289            if (CREATE_TYPE === suggestion.type) {
23290              return null;
23291            }
23292            return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(search_item, {
23293              itemProps: buildSuggestionItemProps(suggestion, index),
23294              suggestion: suggestion,
23295              index: index,
23296              onClick: () => {
23297                handleSuggestionClick(suggestion);
23298              },
23299              isSelected: index === selectedSuggestion,
23300              isURL: LINK_ENTRY_TYPES.includes(suggestion.type),
23301              searchTerm: currentInputValue,
23302              shouldShowType: shouldShowSuggestionsTypes,
23303              isFrontPage: suggestion?.isFrontPage,
23304              isBlogHome: suggestion?.isBlogHome
23305            }, `$suggestion.id}-$suggestion.type}`);
23306          })
23307        })
23308      })
23309    });
23310  }
23311  /* harmony default export */ const search_results = (LinkControlSearchResults);
23312  const __experimentalLinkControlSearchResults = props => {
23313    external_wp_deprecated_default()('wp.blockEditor.__experimentalLinkControlSearchResults', {
23314      since: '6.8'
23315    });
23316    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(LinkControlSearchResults, {
23317      ...props
23318    });
23319  };
23320  
23321  ;// ./node_modules/@wordpress/block-editor/build-module/components/link-control/is-url-like.js
23322  /**
23323   * WordPress dependencies
23324   */
23325  
23326  
23327  /**
23328   * Determines whether a given value could be a URL. Note this does not
23329   * guarantee the value is a URL only that it looks like it might be one. For
23330   * example, just because a string has `www.` in it doesn't make it a URL,
23331   * but it does make it highly likely that it will be so in the context of
23332   * creating a link it makes sense to treat it like one.
23333   *
23334   * @param {string} val the candidate for being URL-like (or not).
23335   *
23336   * @return {boolean} whether or not the value is potentially a URL.
23337   */
23338  function isURLLike(val) {
23339    const hasSpaces = val.includes(' ');
23340    if (hasSpaces) {
23341      return false;
23342    }
23343    const protocol = (0,external_wp_url_namespaceObject.getProtocol)(val);
23344    const protocolIsValid = (0,external_wp_url_namespaceObject.isValidProtocol)(protocol);
23345    const mayBeTLD = hasPossibleTLD(val);
23346    const isWWW = val?.startsWith('www.');
23347    const isInternal = val?.startsWith('#') && (0,external_wp_url_namespaceObject.isValidFragment)(val);
23348    return protocolIsValid || isWWW || isInternal || mayBeTLD;
23349  }
23350  
23351  /**
23352   * Checks if a given URL has a valid Top-Level Domain (TLD).
23353   *
23354   * @param {string} url       - The URL to check.
23355   * @param {number} maxLength - The maximum length of the TLD.
23356   * @return {boolean} Returns true if the URL has a valid TLD, false otherwise.
23357   */
23358  function hasPossibleTLD(url, maxLength = 6) {
23359    // Clean the URL by removing anything after the first occurrence of "?" or "#".
23360    const cleanedURL = url.split(/[?#]/)[0];
23361  
23362    // Regular expression explanation:
23363    // - (?<=\S)                  : Positive lookbehind assertion to ensure there is at least one non-whitespace character before the TLD
23364    // - \.                       : Matches a literal dot (.)
23365    // - [a-zA-Z_]{2,maxLength}   : Matches 2 to maxLength letters or underscores, representing the TLD
23366    // - (?:\/|$)                 : Non-capturing group that matches either a forward slash (/) or the end of the string
23367    const regex = new RegExp(`(?<=\\S)\\.(?:[a-zA-Z_]{2,$maxLength}})(?:\\/|$)`);
23368    return regex.test(cleanedURL);
23369  }
23370  
23371  ;// ./node_modules/@wordpress/block-editor/build-module/components/link-control/use-search-handler.js
23372  /**
23373   * WordPress dependencies
23374   */
23375  
23376  
23377  
23378  
23379  /**
23380   * Internal dependencies
23381   */
23382  
23383  
23384  
23385  const handleNoop = () => Promise.resolve([]);
23386  const handleDirectEntry = val => {
23387    let type = URL_TYPE;
23388    const protocol = (0,external_wp_url_namespaceObject.getProtocol)(val) || '';
23389    if (protocol.includes('mailto')) {
23390      type = MAILTO_TYPE;
23391    }
23392    if (protocol.includes('tel')) {
23393      type = TEL_TYPE;
23394    }
23395    if (val?.startsWith('#')) {
23396      type = INTERNAL_TYPE;
23397    }
23398    return Promise.resolve([{
23399      id: val,
23400      title: val,
23401      url: type === 'URL' ? (0,external_wp_url_namespaceObject.prependHTTP)(val) : val,
23402      type
23403    }]);
23404  };
23405  const handleEntitySearch = async (val, suggestionsQuery, fetchSearchSuggestions, withCreateSuggestion, pageOnFront, pageForPosts) => {
23406    const {
23407      isInitialSuggestions
23408    } = suggestionsQuery;
23409    const results = await fetchSearchSuggestions(val, suggestionsQuery);
23410  
23411    // Identify front page and update type to match.
23412    results.map(result => {
23413      if (Number(result.id) === pageOnFront) {
23414        result.isFrontPage = true;
23415        return result;
23416      } else if (Number(result.id) === pageForPosts) {
23417        result.isBlogHome = true;
23418        return result;
23419      }
23420      return result;
23421    });
23422  
23423    // If displaying initial suggestions just return plain results.
23424    if (isInitialSuggestions) {
23425      return results;
23426    }
23427  
23428    // Here we append a faux suggestion to represent a "CREATE" option. This
23429    // is detected in the rendering of the search results and handled as a
23430    // special case. This is currently necessary because the suggestions
23431    // dropdown will only appear if there are valid suggestions and
23432    // therefore unless the create option is a suggestion it will not
23433    // display in scenarios where there are no results returned from the
23434    // API. In addition promoting CREATE to a first class suggestion affords
23435    // the a11y benefits afforded by `URLInput` to all suggestions (eg:
23436    // keyboard handling, ARIA roles...etc).
23437    //
23438    // Note also that the value of the `title` and `url` properties must correspond
23439    // to the text value of the `<input>`. This is because `title` is used
23440    // when creating the suggestion. Similarly `url` is used when using keyboard to select
23441    // the suggestion (the <form> `onSubmit` handler falls-back to `url`).
23442    return isURLLike(val) || !withCreateSuggestion ? results : results.concat({
23443      // the `id` prop is intentionally omitted here because it
23444      // is never exposed as part of the component's public API.
23445      // see: https://github.com/WordPress/gutenberg/pull/19775#discussion_r378931316.
23446      title: val,
23447      // Must match the existing `<input>`s text value.
23448      url: val,
23449      // Must match the existing `<input>`s text value.
23450      type: CREATE_TYPE
23451    });
23452  };
23453  function useSearchHandler(suggestionsQuery, allowDirectEntry, withCreateSuggestion) {
23454    const {
23455      fetchSearchSuggestions,
23456      pageOnFront,
23457      pageForPosts
23458    } = (0,external_wp_data_namespaceObject.useSelect)(select => {
23459      const {
23460        getSettings
23461      } = select(store);
23462      return {
23463        pageOnFront: getSettings().pageOnFront,
23464        pageForPosts: getSettings().pageForPosts,
23465        fetchSearchSuggestions: getSettings().__experimentalFetchLinkSuggestions
23466      };
23467    }, []);
23468    const directEntryHandler = allowDirectEntry ? handleDirectEntry : handleNoop;
23469    return (0,external_wp_element_namespaceObject.useCallback)((val, {
23470      isInitialSuggestions
23471    }) => {
23472      return isURLLike(val) ? directEntryHandler(val, {
23473        isInitialSuggestions
23474      }) : handleEntitySearch(val, {
23475        ...suggestionsQuery,
23476        isInitialSuggestions
23477      }, fetchSearchSuggestions, withCreateSuggestion, pageOnFront, pageForPosts);
23478    }, [directEntryHandler, fetchSearchSuggestions, pageOnFront, pageForPosts, suggestionsQuery, withCreateSuggestion]);
23479  }
23480  
23481  ;// ./node_modules/@wordpress/block-editor/build-module/components/link-control/search-input.js
23482  /**
23483   * WordPress dependencies
23484   */
23485  
23486  
23487  
23488  /**
23489   * Internal dependencies
23490   */
23491  
23492  
23493  
23494  
23495  
23496  
23497  // Must be a function as otherwise URLInput will default
23498  // to the fetchLinkSuggestions passed in block editor settings
23499  // which will cause an unintended http request.
23500  
23501  const noopSearchHandler = () => Promise.resolve([]);
23502  const noop = () => {};
23503  const LinkControlSearchInput = (0,external_wp_element_namespaceObject.forwardRef)(({
23504    value,
23505    children,
23506    currentLink = {},
23507    className = null,
23508    placeholder = null,
23509    withCreateSuggestion = false,
23510    onCreateSuggestion = noop,
23511    onChange = noop,
23512    onSelect = noop,
23513    showSuggestions = true,
23514    renderSuggestions = props => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(search_results, {
23515      ...props
23516    }),
23517    fetchSuggestions = null,
23518    allowDirectEntry = true,
23519    showInitialSuggestions = false,
23520    suggestionsQuery = {},
23521    withURLSuggestion = true,
23522    createSuggestionButtonText,
23523    hideLabelFromVision = false,
23524    suffix
23525  }, ref) => {
23526    const genericSearchHandler = useSearchHandler(suggestionsQuery, allowDirectEntry, withCreateSuggestion, withURLSuggestion);
23527    const searchHandler = showSuggestions ? fetchSuggestions || genericSearchHandler : noopSearchHandler;
23528    const [focusedSuggestion, setFocusedSuggestion] = (0,external_wp_element_namespaceObject.useState)();
23529  
23530    /**
23531     * Handles the user moving between different suggestions. Does not handle
23532     * choosing an individual item.
23533     *
23534     * @param {string} selection  the url of the selected suggestion.
23535     * @param {Object} suggestion the suggestion object.
23536     */
23537    const onInputChange = (selection, suggestion) => {
23538      onChange(selection);
23539      setFocusedSuggestion(suggestion);
23540    };
23541    const handleRenderSuggestions = props => renderSuggestions({
23542      ...props,
23543      withCreateSuggestion,
23544      createSuggestionButtonText,
23545      suggestionsQuery,
23546      handleSuggestionClick: suggestion => {
23547        if (props.handleSuggestionClick) {
23548          props.handleSuggestionClick(suggestion);
23549        }
23550        onSuggestionSelected(suggestion);
23551      }
23552    });
23553    const onSuggestionSelected = async selectedSuggestion => {
23554      let suggestion = selectedSuggestion;
23555      if (CREATE_TYPE === selectedSuggestion.type) {
23556        // Create a new page and call onSelect with the output from the onCreateSuggestion callback.
23557        try {
23558          suggestion = await onCreateSuggestion(selectedSuggestion.title);
23559          if (suggestion?.url) {
23560            onSelect(suggestion);
23561          }
23562        } catch (e) {}
23563        return;
23564      }
23565      if (allowDirectEntry || suggestion && Object.keys(suggestion).length >= 1) {
23566        const {
23567          id,
23568          url,
23569          ...restLinkProps
23570        } = currentLink !== null && currentLink !== void 0 ? currentLink : {};
23571        onSelect(
23572        // Some direct entries don't have types or IDs, and we still need to clear the previous ones.
23573        {
23574          ...restLinkProps,
23575          ...suggestion
23576        }, suggestion);
23577      }
23578    };
23579    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
23580      className: "block-editor-link-control__search-input-container",
23581      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(url_input, {
23582        disableSuggestions: currentLink?.url === value,
23583        label: (0,external_wp_i18n_namespaceObject.__)('Link'),
23584        hideLabelFromVision: hideLabelFromVision,
23585        className: className,
23586        value: value,
23587        onChange: onInputChange,
23588        placeholder: placeholder !== null && placeholder !== void 0 ? placeholder : (0,external_wp_i18n_namespaceObject.__)('Search or type URL'),
23589        __experimentalRenderSuggestions: showSuggestions ? handleRenderSuggestions : null,
23590        __experimentalFetchLinkSuggestions: searchHandler,
23591        __experimentalHandleURLSuggestions: true,
23592        __experimentalShowInitialSuggestions: showInitialSuggestions,
23593        onSubmit: (suggestion, event) => {
23594          const hasSuggestion = suggestion || focusedSuggestion;
23595  
23596          // If there is no suggestion and the value (ie: any manually entered URL) is empty
23597          // then don't allow submission otherwise we get empty links.
23598          if (!hasSuggestion && !value?.trim()?.length) {
23599            event.preventDefault();
23600          } else {
23601            onSuggestionSelected(hasSuggestion || {
23602              url: value
23603            });
23604          }
23605        },
23606        ref: ref,
23607        suffix: suffix
23608      }), children]
23609    });
23610  });
23611  /* harmony default export */ const search_input = (LinkControlSearchInput);
23612  const __experimentalLinkControlSearchInput = props => {
23613    external_wp_deprecated_default()('wp.blockEditor.__experimentalLinkControlSearchInput', {
23614      since: '6.8'
23615    });
23616    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(LinkControlSearchInput, {
23617      ...props
23618    });
23619  };
23620  
23621  ;// ./node_modules/@wordpress/icons/build-module/library/info.js
23622  /**
23623   * WordPress dependencies
23624   */
23625  
23626  
23627  const info = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
23628    viewBox: "0 0 24 24",
23629    xmlns: "http://www.w3.org/2000/svg",
23630    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
23631      fillRule: "evenodd",
23632      clipRule: "evenodd",
23633      d: "M5.5 12a6.5 6.5 0 1 0 13 0 6.5 6.5 0 0 0-13 0ZM12 4a8 8 0 1 0 0 16 8 8 0 0 0 0-16Zm.75 4v1.5h-1.5V8h1.5Zm0 8v-5h-1.5v5h1.5Z"
23634    })
23635  });
23636  /* harmony default export */ const library_info = (info);
23637  
23638  ;// ./node_modules/@wordpress/icons/build-module/library/pencil.js
23639  /**
23640   * WordPress dependencies
23641   */
23642  
23643  
23644  const pencil = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
23645    xmlns: "http://www.w3.org/2000/svg",
23646    viewBox: "0 0 24 24",
23647    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
23648      d: "m19 7-3-3-8.5 8.5-1 4 4-1L19 7Zm-7 11.5H5V20h7v-1.5Z"
23649    })
23650  });
23651  /* harmony default export */ const library_pencil = (pencil);
23652  
23653  ;// ./node_modules/@wordpress/icons/build-module/library/edit.js
23654  /**
23655   * Internal dependencies
23656   */
23657  
23658  
23659  /* harmony default export */ const edit = (library_pencil);
23660  
23661  ;// ./node_modules/@wordpress/icons/build-module/library/link-off.js
23662  /**
23663   * WordPress dependencies
23664   */
23665  
23666  
23667  const linkOff = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
23668    xmlns: "http://www.w3.org/2000/svg",
23669    viewBox: "0 0 24 24",
23670    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
23671      d: "M17.031 4.703 15.576 4l-1.56 3H14v.03l-2.324 4.47H9.5V13h1.396l-1.502 2.889h-.95a3.694 3.694 0 0 1 0-7.389H10V7H8.444a5.194 5.194 0 1 0 0 10.389h.17L7.5 19.53l1.416.719L15.049 8.5h.507a3.694 3.694 0 0 1 0 7.39H14v1.5h1.556a5.194 5.194 0 0 0 .273-10.383l1.202-2.304Z"
23672    })
23673  });
23674  /* harmony default export */ const link_off = (linkOff);
23675  
23676  ;// ./node_modules/@wordpress/icons/build-module/library/copy-small.js
23677  /**
23678   * WordPress dependencies
23679   */
23680  
23681  
23682  const copySmall = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
23683    xmlns: "http://www.w3.org/2000/svg",
23684    viewBox: "0 0 24 24",
23685    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
23686      fillRule: "evenodd",
23687      clipRule: "evenodd",
23688      d: "M5.625 5.5h9.75c.069 0 .125.056.125.125v9.75a.125.125 0 0 1-.125.125h-9.75a.125.125 0 0 1-.125-.125v-9.75c0-.069.056-.125.125-.125ZM4 5.625C4 4.728 4.728 4 5.625 4h9.75C16.273 4 17 4.728 17 5.625v9.75c0 .898-.727 1.625-1.625 1.625h-9.75A1.625 1.625 0 0 1 4 15.375v-9.75Zm14.5 11.656v-9H20v9C20 18.8 18.77 20 17.251 20H6.25v-1.5h11.001c.69 0 1.249-.528 1.249-1.219Z"
23689    })
23690  });
23691  /* harmony default export */ const copy_small = (copySmall);
23692  
23693  ;// ./node_modules/@wordpress/block-editor/build-module/components/link-control/viewer-slot.js
23694  /**
23695   * WordPress dependencies
23696   */
23697  
23698  const {
23699    Slot: ViewerSlot,
23700    Fill: ViewerFill
23701  } = (0,external_wp_components_namespaceObject.createSlotFill)('BlockEditorLinkControlViewer');
23702  
23703  /* harmony default export */ const viewer_slot = ((/* unused pure expression or super */ null && (ViewerSlot)));
23704  
23705  ;// ./node_modules/@wordpress/block-editor/build-module/components/link-control/use-rich-url-data.js
23706  /**
23707   * Internal dependencies
23708   */
23709  
23710  
23711  /**
23712   * WordPress dependencies
23713   */
23714  
23715  
23716  function use_rich_url_data_reducer(state, action) {
23717    switch (action.type) {
23718      case 'RESOLVED':
23719        return {
23720          ...state,
23721          isFetching: false,
23722          richData: action.richData
23723        };
23724      case 'ERROR':
23725        return {
23726          ...state,
23727          isFetching: false,
23728          richData: null
23729        };
23730      case 'LOADING':
23731        return {
23732          ...state,
23733          isFetching: true
23734        };
23735      default:
23736        throw new Error(`Unexpected action type $action.type}`);
23737    }
23738  }
23739  function useRemoteUrlData(url) {
23740    const [state, dispatch] = (0,external_wp_element_namespaceObject.useReducer)(use_rich_url_data_reducer, {
23741      richData: null,
23742      isFetching: false
23743    });
23744    const {
23745      fetchRichUrlData
23746    } = (0,external_wp_data_namespaceObject.useSelect)(select => {
23747      const {
23748        getSettings
23749      } = select(store);
23750      return {
23751        fetchRichUrlData: getSettings().__experimentalFetchRichUrlData
23752      };
23753    }, []);
23754    (0,external_wp_element_namespaceObject.useEffect)(() => {
23755      // Only make the request if we have an actual URL
23756      // and the fetching util is available. In some editors
23757      // there may not be such a util.
23758      if (url?.length && fetchRichUrlData && typeof AbortController !== 'undefined') {
23759        dispatch({
23760          type: 'LOADING'
23761        });
23762        const controller = new window.AbortController();
23763        const signal = controller.signal;
23764        fetchRichUrlData(url, {
23765          signal
23766        }).then(urlData => {
23767          dispatch({
23768            type: 'RESOLVED',
23769            richData: urlData
23770          });
23771        }).catch(() => {
23772          // Avoid setting state on unmounted component
23773          if (!signal.aborted) {
23774            dispatch({
23775              type: 'ERROR'
23776            });
23777          }
23778        });
23779        // Cleanup: when the URL changes the abort the current request.
23780        return () => {
23781          controller.abort();
23782        };
23783      }
23784    }, [url]);
23785    return state;
23786  }
23787  /* harmony default export */ const use_rich_url_data = (useRemoteUrlData);
23788  
23789  ;// ./node_modules/@wordpress/block-editor/build-module/components/link-control/link-preview.js
23790  /**
23791   * External dependencies
23792   */
23793  
23794  
23795  /**
23796   * WordPress dependencies
23797   */
23798  
23799  
23800  
23801  
23802  
23803  
23804  
23805  
23806  
23807  
23808  /**
23809   * Internal dependencies
23810   */
23811  
23812  
23813  
23814  /**
23815   * Filters the title for display. Removes the protocol and www prefix.
23816   *
23817   * @param {string} title The title to be filtered.
23818   *
23819   * @return {string} The filtered title.
23820   */
23821  
23822  function filterTitleForDisplay(title) {
23823    // Derived from `filterURLForDisplay` in `@wordpress/url`.
23824    return title.replace(/^[a-z\-.\+]+[0-9]*:(\/\/)?/i, '').replace(/^www\./i, '');
23825  }
23826  function LinkPreview({
23827    value,
23828    onEditClick,
23829    hasRichPreviews = false,
23830    hasUnlinkControl = false,
23831    onRemove
23832  }) {
23833    const showIconLabels = (0,external_wp_data_namespaceObject.useSelect)(select => select(external_wp_preferences_namespaceObject.store).get('core', 'showIconLabels'), []);
23834  
23835    // Avoid fetching if rich previews are not desired.
23836    const showRichPreviews = hasRichPreviews ? value?.url : null;
23837    const {
23838      richData,
23839      isFetching
23840    } = use_rich_url_data(showRichPreviews);
23841  
23842    // Rich data may be an empty object so test for that.
23843    const hasRichData = richData && Object.keys(richData).length;
23844    const displayURL = value && (0,external_wp_url_namespaceObject.filterURLForDisplay)((0,external_wp_url_namespaceObject.safeDecodeURI)(value.url), 24) || '';
23845  
23846    // url can be undefined if the href attribute is unset
23847    const isEmptyURL = !value?.url?.length;
23848    const displayTitle = !isEmptyURL && (0,external_wp_dom_namespaceObject.__unstableStripHTML)(richData?.title || value?.title || displayURL);
23849    const isUrlRedundant = !value?.url || filterTitleForDisplay(displayTitle) === displayURL;
23850    let icon;
23851    if (richData?.icon) {
23852      icon = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("img", {
23853        src: richData?.icon,
23854        alt: ""
23855      });
23856    } else if (isEmptyURL) {
23857      icon = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(build_module_icon, {
23858        icon: library_info,
23859        size: 32
23860      });
23861    } else {
23862      icon = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(build_module_icon, {
23863        icon: library_globe
23864      });
23865    }
23866    const {
23867      createNotice
23868    } = (0,external_wp_data_namespaceObject.useDispatch)(external_wp_notices_namespaceObject.store);
23869    const ref = (0,external_wp_compose_namespaceObject.useCopyToClipboard)(value.url, () => {
23870      createNotice('info', (0,external_wp_i18n_namespaceObject.__)('Link copied to clipboard.'), {
23871        isDismissible: true,
23872        type: 'snackbar'
23873      });
23874    });
23875    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
23876      role: "group",
23877      "aria-label": (0,external_wp_i18n_namespaceObject.__)('Manage link'),
23878      className: dist_clsx('block-editor-link-control__search-item', {
23879        'is-current': true,
23880        'is-rich': hasRichData,
23881        'is-fetching': !!isFetching,
23882        'is-preview': true,
23883        'is-error': isEmptyURL,
23884        'is-url-title': displayTitle === displayURL
23885      }),
23886      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
23887        className: "block-editor-link-control__search-item-top",
23888        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("span", {
23889          className: "block-editor-link-control__search-item-header",
23890          role: "figure",
23891          "aria-label": /* translators: Accessibility text for the link preview when editing a link. */
23892          (0,external_wp_i18n_namespaceObject.__)('Link information'),
23893          children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("span", {
23894            className: dist_clsx('block-editor-link-control__search-item-icon', {
23895              'is-image': richData?.icon
23896            }),
23897            children: icon
23898          }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("span", {
23899            className: "block-editor-link-control__search-item-details",
23900            children: !isEmptyURL ? /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
23901              children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ExternalLink, {
23902                className: "block-editor-link-control__search-item-title",
23903                href: value.url,
23904                children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalTruncate, {
23905                  numberOfLines: 1,
23906                  children: displayTitle
23907                })
23908              }), !isUrlRedundant && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("span", {
23909                className: "block-editor-link-control__search-item-info",
23910                children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalTruncate, {
23911                  numberOfLines: 1,
23912                  children: displayURL
23913                })
23914              })]
23915            }) : /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("span", {
23916              className: "block-editor-link-control__search-item-error-notice",
23917              children: (0,external_wp_i18n_namespaceObject.__)('Link is empty')
23918            })
23919          })]
23920        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
23921          icon: edit,
23922          label: (0,external_wp_i18n_namespaceObject.__)('Edit link'),
23923          onClick: onEditClick,
23924          size: "compact",
23925          showTooltip: !showIconLabels
23926        }), hasUnlinkControl && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
23927          icon: link_off,
23928          label: (0,external_wp_i18n_namespaceObject.__)('Remove link'),
23929          onClick: onRemove,
23930          size: "compact",
23931          showTooltip: !showIconLabels
23932        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
23933          icon: copy_small,
23934          label: (0,external_wp_i18n_namespaceObject.__)('Copy link'),
23935          ref: ref,
23936          accessibleWhenDisabled: true,
23937          disabled: isEmptyURL,
23938          size: "compact",
23939          showTooltip: !showIconLabels
23940        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ViewerSlot, {
23941          fillProps: value
23942        })]
23943      })
23944    });
23945  }
23946  
23947  ;// ./node_modules/@wordpress/block-editor/build-module/components/link-control/settings.js
23948  /**
23949   * WordPress dependencies
23950   */
23951  
23952  
23953  
23954  const settings_noop = () => {};
23955  const LinkControlSettings = ({
23956    value,
23957    onChange = settings_noop,
23958    settings
23959  }) => {
23960    if (!settings || !settings.length) {
23961      return null;
23962    }
23963    const handleSettingChange = setting => newValue => {
23964      onChange({
23965        ...value,
23966        [setting.id]: newValue
23967      });
23968    };
23969    const theSettings = settings.map(setting => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.CheckboxControl, {
23970      __nextHasNoMarginBottom: true,
23971      className: "block-editor-link-control__setting",
23972      label: setting.title,
23973      onChange: handleSettingChange(setting),
23974      checked: value ? !!value[setting.id] : false,
23975      help: setting?.help
23976    }, setting.id));
23977    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("fieldset", {
23978      className: "block-editor-link-control__settings",
23979      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.VisuallyHidden, {
23980        as: "legend",
23981        children: (0,external_wp_i18n_namespaceObject.__)('Currently selected link settings')
23982      }), theSettings]
23983    });
23984  };
23985  /* harmony default export */ const link_control_settings = (LinkControlSettings);
23986  
23987  ;// ./node_modules/@wordpress/block-editor/build-module/components/link-control/use-create-page.js
23988  /**
23989   * WordPress dependencies
23990   */
23991  
23992  
23993  function useCreatePage(handleCreatePage) {
23994    const cancelableCreateSuggestion = (0,external_wp_element_namespaceObject.useRef)();
23995    const [isCreatingPage, setIsCreatingPage] = (0,external_wp_element_namespaceObject.useState)(false);
23996    const [errorMessage, setErrorMessage] = (0,external_wp_element_namespaceObject.useState)(null);
23997    const createPage = async function (suggestionTitle) {
23998      setIsCreatingPage(true);
23999      setErrorMessage(null);
24000      try {
24001        // Make cancellable in order that we can avoid setting State
24002        // if the component unmounts during the call to `createSuggestion`
24003        cancelableCreateSuggestion.current = makeCancelable(
24004        // Using Promise.resolve to allow createSuggestion to return a
24005        // non-Promise based value.
24006        Promise.resolve(handleCreatePage(suggestionTitle)));
24007        return await cancelableCreateSuggestion.current.promise;
24008      } catch (error) {
24009        if (error && error.isCanceled) {
24010          return; // bail if canceled to avoid setting state
24011        }
24012        setErrorMessage(error.message || (0,external_wp_i18n_namespaceObject.__)('An unknown error occurred during creation. Please try again.'));
24013        throw error;
24014      } finally {
24015        setIsCreatingPage(false);
24016      }
24017    };
24018  
24019    /**
24020     * Handles cancelling any pending Promises that have been made cancelable.
24021     */
24022    (0,external_wp_element_namespaceObject.useEffect)(() => {
24023      return () => {
24024        // componentDidUnmount
24025        if (cancelableCreateSuggestion.current) {
24026          cancelableCreateSuggestion.current.cancel();
24027        }
24028      };
24029    }, []);
24030    return {
24031      createPage,
24032      isCreatingPage,
24033      errorMessage
24034    };
24035  }
24036  
24037  /**
24038   * Creates a wrapper around a promise which allows it to be programmatically
24039   * cancelled.
24040   * See: https://reactjs.org/blog/2015/12/16/ismounted-antipattern.html
24041   *
24042   * @param {Promise} promise the Promise to make cancelable
24043   */
24044  const makeCancelable = promise => {
24045    let hasCanceled_ = false;
24046    const wrappedPromise = new Promise((resolve, reject) => {
24047      promise.then(val => hasCanceled_ ? reject({
24048        isCanceled: true
24049      }) : resolve(val), error => hasCanceled_ ? reject({
24050        isCanceled: true
24051      }) : reject(error));
24052    });
24053    return {
24054      promise: wrappedPromise,
24055      cancel() {
24056        hasCanceled_ = true;
24057      }
24058    };
24059  };
24060  
24061  // EXTERNAL MODULE: ./node_modules/fast-deep-equal/index.js
24062  var fast_deep_equal = __webpack_require__(5215);
24063  var fast_deep_equal_default = /*#__PURE__*/__webpack_require__.n(fast_deep_equal);
24064  ;// ./node_modules/@wordpress/block-editor/build-module/components/link-control/use-internal-value.js
24065  /**
24066   * WordPress dependencies
24067   */
24068  
24069  
24070  /**
24071   * External dependencies
24072   */
24073  
24074  function useInternalValue(value) {
24075    const [internalValue, setInternalValue] = (0,external_wp_element_namespaceObject.useState)(value || {});
24076    const [previousValue, setPreviousValue] = (0,external_wp_element_namespaceObject.useState)(value);
24077  
24078    // If the value prop changes, update the internal state.
24079    // See:
24080    // - https://github.com/WordPress/gutenberg/pull/51387#issuecomment-1722927384.
24081    // - https://react.dev/reference/react/useState#storing-information-from-previous-renders.
24082    if (!fast_deep_equal_default()(value, previousValue)) {
24083      setPreviousValue(value);
24084      setInternalValue(value);
24085    }
24086    const setInternalURLInputValue = nextValue => {
24087      setInternalValue({
24088        ...internalValue,
24089        url: nextValue
24090      });
24091    };
24092    const setInternalTextInputValue = nextValue => {
24093      setInternalValue({
24094        ...internalValue,
24095        title: nextValue
24096      });
24097    };
24098    const createSetInternalSettingValueHandler = settingsKeys => nextValue => {
24099      // Only apply settings values which are defined in the settings prop.
24100      const settingsUpdates = Object.keys(nextValue).reduce((acc, key) => {
24101        if (settingsKeys.includes(key)) {
24102          acc[key] = nextValue[key];
24103        }
24104        return acc;
24105      }, {});
24106      setInternalValue({
24107        ...internalValue,
24108        ...settingsUpdates
24109      });
24110    };
24111    return [internalValue, setInternalValue, setInternalURLInputValue, setInternalTextInputValue, createSetInternalSettingValueHandler];
24112  }
24113  
24114  ;// ./node_modules/@wordpress/block-editor/build-module/components/link-control/index.js
24115  /**
24116   * External dependencies
24117   */
24118  
24119  
24120  /**
24121   * WordPress dependencies
24122   */
24123  
24124  
24125  
24126  
24127  
24128  
24129  
24130  
24131  
24132  
24133  /**
24134   * Internal dependencies
24135   */
24136  
24137  
24138  
24139  
24140  
24141  
24142  
24143  
24144  
24145  
24146  /**
24147   * Default properties associated with a link control value.
24148   *
24149   * @typedef WPLinkControlDefaultValue
24150   *
24151   * @property {string}   url           Link URL.
24152   * @property {string=}  title         Link title.
24153   * @property {boolean=} opensInNewTab Whether link should open in a new browser
24154   *                                    tab. This value is only assigned if not
24155   *                                    providing a custom `settings` prop.
24156   */
24157  
24158  /* eslint-disable jsdoc/valid-types */
24159  /**
24160   * Custom settings values associated with a link.
24161   *
24162   * @typedef {{[setting:string]:any}} WPLinkControlSettingsValue
24163   */
24164  /* eslint-enable */
24165  
24166  /**
24167   * Custom settings values associated with a link.
24168   *
24169   * @typedef WPLinkControlSetting
24170   *
24171   * @property {string} id    Identifier to use as property for setting value.
24172   * @property {string} title Human-readable label to show in user interface.
24173   */
24174  
24175  /**
24176   * Properties associated with a link control value, composed as a union of the
24177   * default properties and any custom settings values.
24178   *
24179   * @typedef {WPLinkControlDefaultValue&WPLinkControlSettingsValue} WPLinkControlValue
24180   */
24181  
24182  /** @typedef {(nextValue:WPLinkControlValue)=>void} WPLinkControlOnChangeProp */
24183  
24184  /**
24185   * Properties associated with a search suggestion used within the LinkControl.
24186   *
24187   * @typedef WPLinkControlSuggestion
24188   *
24189   * @property {string} id    Identifier to use to uniquely identify the suggestion.
24190   * @property {string} type  Identifies the type of the suggestion (eg: `post`,
24191   *                          `page`, `url`...etc)
24192   * @property {string} title Human-readable label to show in user interface.
24193   * @property {string} url   A URL for the suggestion.
24194   */
24195  
24196  /** @typedef {(title:string)=>WPLinkControlSuggestion} WPLinkControlCreateSuggestionProp */
24197  
24198  /**
24199   * @typedef WPLinkControlProps
24200   *
24201   * @property {(WPLinkControlSetting[])=}  settings                   An array of settings objects. Each object will used to
24202   *                                                                   render a `ToggleControl` for that setting.
24203   * @property {boolean=}                   forceIsEditingLink         If passed as either `true` or `false`, controls the
24204   *                                                                   internal editing state of the component to respective
24205   *                                                                   show or not show the URL input field.
24206   * @property {WPLinkControlValue=}        value                      Current link value.
24207   * @property {WPLinkControlOnChangeProp=} onChange                   Value change handler, called with the updated value if
24208   *                                                                   the user selects a new link or updates settings.
24209   * @property {boolean=}                   noDirectEntry              Whether to allow turning a URL-like search query directly into a link.
24210   * @property {boolean=}                   showSuggestions            Whether to present suggestions when typing the URL.
24211   * @property {boolean=}                   showInitialSuggestions     Whether to present initial suggestions immediately.
24212   * @property {boolean=}                   withCreateSuggestion       Whether to allow creation of link value from suggestion.
24213   * @property {Object=}                    suggestionsQuery           Query parameters to pass along to wp.blockEditor.__experimentalFetchLinkSuggestions.
24214   * @property {boolean=}                   noURLSuggestion            Whether to add a fallback suggestion which treats the search query as a URL.
24215   * @property {boolean=}                   hasTextControl             Whether to add a text field to the UI to update the value.title.
24216   * @property {string|Function|undefined}  createSuggestionButtonText The text to use in the button that calls createSuggestion.
24217   * @property {Function}                   renderControlBottom        Optional controls to be rendered at the bottom of the component.
24218   */
24219  
24220  const link_control_noop = () => {};
24221  const PREFERENCE_SCOPE = 'core/block-editor';
24222  const PREFERENCE_KEY = 'linkControlSettingsDrawer';
24223  
24224  /**
24225   * Renders a link control. A link control is a controlled input which maintains
24226   * a value associated with a link (HTML anchor element) and relevant settings
24227   * for how that link is expected to behave.
24228   *
24229   * @param {WPLinkControlProps} props Component props.
24230   */
24231  function LinkControl({
24232    searchInputPlaceholder,
24233    value,
24234    settings = DEFAULT_LINK_SETTINGS,
24235    onChange = link_control_noop,
24236    onRemove,
24237    onCancel,
24238    noDirectEntry = false,
24239    showSuggestions = true,
24240    showInitialSuggestions,
24241    forceIsEditingLink,
24242    createSuggestion,
24243    withCreateSuggestion,
24244    inputValue: propInputValue = '',
24245    suggestionsQuery = {},
24246    noURLSuggestion = false,
24247    createSuggestionButtonText,
24248    hasRichPreviews = false,
24249    hasTextControl = false,
24250    renderControlBottom = null
24251  }) {
24252    if (withCreateSuggestion === undefined && createSuggestion) {
24253      withCreateSuggestion = true;
24254    }
24255    const [settingsOpen, setSettingsOpen] = (0,external_wp_element_namespaceObject.useState)(false);
24256    const {
24257      advancedSettingsPreference
24258    } = (0,external_wp_data_namespaceObject.useSelect)(select => {
24259      var _prefsStore$get;
24260      const prefsStore = select(external_wp_preferences_namespaceObject.store);
24261      return {
24262        advancedSettingsPreference: (_prefsStore$get = prefsStore.get(PREFERENCE_SCOPE, PREFERENCE_KEY)) !== null && _prefsStore$get !== void 0 ? _prefsStore$get : false
24263      };
24264    }, []);
24265    const {
24266      set: setPreference
24267    } = (0,external_wp_data_namespaceObject.useDispatch)(external_wp_preferences_namespaceObject.store);
24268  
24269    /**
24270     * Sets the open/closed state of the Advanced Settings Drawer,
24271     * optionlly persisting the state to the user's preferences.
24272     *
24273     * Note that Block Editor components can be consumed by non-WordPress
24274     * environments which may not have preferences setup.
24275     * Therefore a local state is also  used as a fallback.
24276     *
24277     * @param {boolean} prefVal the open/closed state of the Advanced Settings Drawer.
24278     */
24279    const setSettingsOpenWithPreference = prefVal => {
24280      if (setPreference) {
24281        setPreference(PREFERENCE_SCOPE, PREFERENCE_KEY, prefVal);
24282      }
24283      setSettingsOpen(prefVal);
24284    };
24285  
24286    // Block Editor components can be consumed by non-WordPress environments
24287    // which may not have these preferences setup.
24288    // Therefore a local state is used as a fallback.
24289    const isSettingsOpen = advancedSettingsPreference || settingsOpen;
24290    const isMountingRef = (0,external_wp_element_namespaceObject.useRef)(true);
24291    const wrapperNode = (0,external_wp_element_namespaceObject.useRef)();
24292    const textInputRef = (0,external_wp_element_namespaceObject.useRef)();
24293    const isEndingEditWithFocusRef = (0,external_wp_element_namespaceObject.useRef)(false);
24294    const settingsKeys = settings.map(({
24295      id
24296    }) => id);
24297    const [internalControlValue, setInternalControlValue, setInternalURLInputValue, setInternalTextInputValue, createSetInternalSettingValueHandler] = useInternalValue(value);
24298    const valueHasChanges = value && !(0,external_wp_isShallowEqual_namespaceObject.isShallowEqualObjects)(internalControlValue, value);
24299    const [isEditingLink, setIsEditingLink] = (0,external_wp_element_namespaceObject.useState)(forceIsEditingLink !== undefined ? forceIsEditingLink : !value || !value.url);
24300    const {
24301      createPage,
24302      isCreatingPage,
24303      errorMessage
24304    } = useCreatePage(createSuggestion);
24305    (0,external_wp_element_namespaceObject.useEffect)(() => {
24306      if (forceIsEditingLink === undefined) {
24307        return;
24308      }
24309      setIsEditingLink(forceIsEditingLink);
24310    }, [forceIsEditingLink]);
24311    (0,external_wp_element_namespaceObject.useEffect)(() => {
24312      // We don't auto focus into the Link UI on mount
24313      // because otherwise using the keyboard to select text
24314      // *within* the link format is not possible.
24315      if (isMountingRef.current) {
24316        return;
24317      }
24318  
24319      // Scenario - when:
24320      // - switching between editable and non editable LinkControl
24321      // - clicking on a link
24322      // ...then move focus to the *first* element to avoid focus loss
24323      // and to ensure focus is *within* the Link UI.
24324      const nextFocusTarget = external_wp_dom_namespaceObject.focus.focusable.find(wrapperNode.current)[0] || wrapperNode.current;
24325      nextFocusTarget.focus();
24326      isEndingEditWithFocusRef.current = false;
24327    }, [isEditingLink, isCreatingPage]);
24328  
24329    // The component mounting reference is maintained separately
24330    // to correctly reset values in `StrictMode`.
24331    (0,external_wp_element_namespaceObject.useEffect)(() => {
24332      isMountingRef.current = false;
24333      return () => {
24334        isMountingRef.current = true;
24335      };
24336    }, []);
24337    const hasLinkValue = value?.url?.trim()?.length > 0;
24338  
24339    /**
24340     * Cancels editing state and marks that focus may need to be restored after
24341     * the next render, if focus was within the wrapper when editing finished.
24342     */
24343    const stopEditing = () => {
24344      isEndingEditWithFocusRef.current = !!wrapperNode.current?.contains(wrapperNode.current.ownerDocument.activeElement);
24345      setIsEditingLink(false);
24346    };
24347    const handleSelectSuggestion = updatedValue => {
24348      // Suggestions may contains "settings" values (e.g. `opensInNewTab`)
24349      // which should not override any existing settings values set by the
24350      // user. This filters out any settings values from the suggestion.
24351      const nonSettingsChanges = Object.keys(updatedValue).reduce((acc, key) => {
24352        if (!settingsKeys.includes(key)) {
24353          acc[key] = updatedValue[key];
24354        }
24355        return acc;
24356      }, {});
24357      onChange({
24358        ...internalControlValue,
24359        ...nonSettingsChanges,
24360        // As title is not a setting, it must be manually applied
24361        // in such a way as to preserve the users changes over
24362        // any "title" value provided by the "suggestion".
24363        title: internalControlValue?.title || updatedValue?.title
24364      });
24365      stopEditing();
24366    };
24367    const handleSubmit = () => {
24368      if (valueHasChanges) {
24369        // Submit the original value with new stored values applied
24370        // on top. URL is a special case as it may also be a prop.
24371        onChange({
24372          ...value,
24373          ...internalControlValue,
24374          url: currentUrlInputValue
24375        });
24376      }
24377      stopEditing();
24378    };
24379    const handleSubmitWithEnter = event => {
24380      const {
24381        keyCode
24382      } = event;
24383      if (keyCode === external_wp_keycodes_namespaceObject.ENTER && !currentInputIsEmpty // Disallow submitting empty values.
24384      ) {
24385        event.preventDefault();
24386        handleSubmit();
24387      }
24388    };
24389    const resetInternalValues = () => {
24390      setInternalControlValue(value);
24391    };
24392    const handleCancel = event => {
24393      event.preventDefault();
24394      event.stopPropagation();
24395  
24396      // Ensure that any unsubmitted input changes are reset.
24397      resetInternalValues();
24398      if (hasLinkValue) {
24399        // If there is a link then exist editing mode and show preview.
24400        stopEditing();
24401      } else {
24402        // If there is no link value, then remove the link entirely.
24403        onRemove?.();
24404      }
24405      onCancel?.();
24406    };
24407    const currentUrlInputValue = propInputValue || internalControlValue?.url || '';
24408    const currentInputIsEmpty = !currentUrlInputValue?.trim()?.length;
24409    const shownUnlinkControl = onRemove && value && !isEditingLink && !isCreatingPage;
24410    const showActions = isEditingLink && hasLinkValue;
24411  
24412    // Only show text control once a URL value has been committed
24413    // and it isn't just empty whitespace.
24414    // See https://github.com/WordPress/gutenberg/pull/33849/#issuecomment-932194927.
24415    const showTextControl = hasLinkValue && hasTextControl;
24416    const isEditing = (isEditingLink || !value) && !isCreatingPage;
24417    const isDisabled = !valueHasChanges || currentInputIsEmpty;
24418    const showSettings = !!settings?.length && isEditingLink && hasLinkValue;
24419    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
24420      tabIndex: -1,
24421      ref: wrapperNode,
24422      className: "block-editor-link-control",
24423      children: [isCreatingPage && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
24424        className: "block-editor-link-control__loading",
24425        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Spinner, {}), " ", (0,external_wp_i18n_namespaceObject.__)('Creating'), "\u2026"]
24426      }), isEditing && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
24427        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
24428          className: dist_clsx({
24429            'block-editor-link-control__search-input-wrapper': true,
24430            'has-text-control': showTextControl,
24431            'has-actions': showActions
24432          }),
24433          children: [showTextControl && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.TextControl, {
24434            __nextHasNoMarginBottom: true,
24435            ref: textInputRef,
24436            className: "block-editor-link-control__field block-editor-link-control__text-content",
24437            label: (0,external_wp_i18n_namespaceObject.__)('Text'),
24438            value: internalControlValue?.title,
24439            onChange: setInternalTextInputValue,
24440            onKeyDown: handleSubmitWithEnter,
24441            __next40pxDefaultSize: true
24442          }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(search_input, {
24443            currentLink: value,
24444            className: "block-editor-link-control__field block-editor-link-control__search-input",
24445            placeholder: searchInputPlaceholder,
24446            value: currentUrlInputValue,
24447            withCreateSuggestion: withCreateSuggestion,
24448            onCreateSuggestion: createPage,
24449            onChange: setInternalURLInputValue,
24450            onSelect: handleSelectSuggestion,
24451            showInitialSuggestions: showInitialSuggestions,
24452            allowDirectEntry: !noDirectEntry,
24453            showSuggestions: showSuggestions,
24454            suggestionsQuery: suggestionsQuery,
24455            withURLSuggestion: !noURLSuggestion,
24456            createSuggestionButtonText: createSuggestionButtonText,
24457            hideLabelFromVision: !showTextControl,
24458            suffix: showActions ? undefined : /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalInputControlSuffixWrapper, {
24459              variant: "control",
24460              children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
24461                onClick: isDisabled ? link_control_noop : handleSubmit,
24462                label: (0,external_wp_i18n_namespaceObject.__)('Submit'),
24463                icon: keyboard_return,
24464                className: "block-editor-link-control__search-submit",
24465                "aria-disabled": isDisabled,
24466                size: "small"
24467              })
24468            })
24469          })]
24470        }), errorMessage && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Notice, {
24471          className: "block-editor-link-control__search-error",
24472          status: "error",
24473          isDismissible: false,
24474          children: errorMessage
24475        })]
24476      }), value && !isEditingLink && !isCreatingPage && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(LinkPreview, {
24477        // force remount when URL changes to avoid race conditions for rich previews
24478        value: value,
24479        onEditClick: () => setIsEditingLink(true),
24480        hasRichPreviews: hasRichPreviews,
24481        hasUnlinkControl: shownUnlinkControl,
24482        onRemove: () => {
24483          onRemove();
24484          setIsEditingLink(true);
24485        }
24486      }, value?.url), showSettings && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
24487        className: "block-editor-link-control__tools",
24488        children: !currentInputIsEmpty && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(settings_drawer, {
24489          settingsOpen: isSettingsOpen,
24490          setSettingsOpen: setSettingsOpenWithPreference,
24491          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(link_control_settings, {
24492            value: internalControlValue,
24493            settings: settings,
24494            onChange: createSetInternalSettingValueHandler(settingsKeys)
24495          })
24496        })
24497      }), showActions && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalHStack, {
24498        justify: "right",
24499        className: "block-editor-link-control__search-actions",
24500        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
24501          __next40pxDefaultSize: true,
24502          variant: "tertiary",
24503          onClick: handleCancel,
24504          children: (0,external_wp_i18n_namespaceObject.__)('Cancel')
24505        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
24506          __next40pxDefaultSize: true,
24507          variant: "primary",
24508          onClick: isDisabled ? link_control_noop : handleSubmit,
24509          className: "block-editor-link-control__search-submit",
24510          "aria-disabled": isDisabled,
24511          children: (0,external_wp_i18n_namespaceObject.__)('Save')
24512        })]
24513      }), !isCreatingPage && renderControlBottom && renderControlBottom()]
24514    });
24515  }
24516  LinkControl.ViewerFill = ViewerFill;
24517  LinkControl.DEFAULT_LINK_SETTINGS = DEFAULT_LINK_SETTINGS;
24518  const DeprecatedExperimentalLinkControl = props => {
24519    external_wp_deprecated_default()('wp.blockEditor.__experimentalLinkControl', {
24520      since: '6.8',
24521      alternative: 'wp.blockEditor.LinkControl'
24522    });
24523    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(LinkControl, {
24524      ...props
24525    });
24526  };
24527  /* harmony default export */ const link_control = (LinkControl);
24528  
24529  ;// ./node_modules/@wordpress/block-editor/build-module/components/media-replace-flow/index.js
24530  /**
24531   * WordPress dependencies
24532   */
24533  
24534  
24535  
24536  
24537  
24538  
24539  
24540  
24541  
24542  
24543  /**
24544   * Internal dependencies
24545   */
24546  
24547  
24548  
24549  
24550  
24551  const media_replace_flow_noop = () => {};
24552  let uniqueId = 0;
24553  const MediaReplaceFlow = ({
24554    mediaURL,
24555    mediaId,
24556    mediaIds,
24557    allowedTypes,
24558    accept,
24559    onError,
24560    onSelect,
24561    onSelectURL,
24562    onReset,
24563    onToggleFeaturedImage,
24564    useFeaturedImage,
24565    onFilesUpload = media_replace_flow_noop,
24566    name = (0,external_wp_i18n_namespaceObject.__)('Replace'),
24567    createNotice,
24568    removeNotice,
24569    children,
24570    multiple = false,
24571    addToGallery,
24572    handleUpload = true,
24573    popoverProps,
24574    renderToggle
24575  }) => {
24576    const {
24577      getSettings
24578    } = (0,external_wp_data_namespaceObject.useSelect)(store);
24579    const errorNoticeID = `block-editor/media-replace-flow/error-notice/${++uniqueId}`;
24580    const onUploadError = message => {
24581      const safeMessage = (0,external_wp_dom_namespaceObject.__unstableStripHTML)(message);
24582      if (onError) {
24583        onError(safeMessage);
24584        return;
24585      }
24586      // We need to set a timeout for showing the notice
24587      // so that VoiceOver and possibly other screen readers
24588      // can announce the error after the toolbar button
24589      // regains focus once the upload dialog closes.
24590      // Otherwise VO simply skips over the notice and announces
24591      // the focused element and the open menu.
24592      setTimeout(() => {
24593        createNotice('error', safeMessage, {
24594          speak: true,
24595          id: errorNoticeID,
24596          isDismissible: true
24597        });
24598      }, 1000);
24599    };
24600    const selectMedia = (media, closeMenu) => {
24601      if (useFeaturedImage && onToggleFeaturedImage) {
24602        onToggleFeaturedImage();
24603      }
24604      closeMenu();
24605      // Calling `onSelect` after the state update since it might unmount the component.
24606      onSelect(media);
24607      (0,external_wp_a11y_namespaceObject.speak)((0,external_wp_i18n_namespaceObject.__)('The media file has been replaced'));
24608      removeNotice(errorNoticeID);
24609    };
24610    const uploadFiles = (event, closeMenu) => {
24611      const files = event.target.files;
24612      if (!handleUpload) {
24613        closeMenu();
24614        return onSelect(files);
24615      }
24616      onFilesUpload(files);
24617      getSettings().mediaUpload({
24618        allowedTypes,
24619        filesList: files,
24620        onFileChange: ([media]) => {
24621          selectMedia(media, closeMenu);
24622        },
24623        onError: onUploadError
24624      });
24625    };
24626    const openOnArrowDown = event => {
24627      if (event.keyCode === external_wp_keycodes_namespaceObject.DOWN) {
24628        event.preventDefault();
24629        event.target.click();
24630      }
24631    };
24632    const onlyAllowsImages = () => {
24633      if (!allowedTypes || allowedTypes.length === 0) {
24634        return false;
24635      }
24636      return allowedTypes.every(allowedType => allowedType === 'image' || allowedType.startsWith('image/'));
24637    };
24638    const gallery = multiple && onlyAllowsImages();
24639    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Dropdown, {
24640      popoverProps: popoverProps,
24641      contentClassName: "block-editor-media-replace-flow__options",
24642      renderToggle: ({
24643        isOpen,
24644        onToggle
24645      }) => {
24646        if (renderToggle) {
24647          return renderToggle({
24648            'aria-expanded': isOpen,
24649            'aria-haspopup': 'true',
24650            onClick: onToggle,
24651            onKeyDown: openOnArrowDown,
24652            children: name
24653          });
24654        }
24655        return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarButton, {
24656          "aria-expanded": isOpen,
24657          "aria-haspopup": "true",
24658          onClick: onToggle,
24659          onKeyDown: openOnArrowDown,
24660          children: name
24661        });
24662      },
24663      renderContent: ({
24664        onClose
24665      }) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
24666        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.NavigableMenu, {
24667          className: "block-editor-media-replace-flow__media-upload-menu",
24668          children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(check, {
24669            children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(media_upload, {
24670              gallery: gallery,
24671              addToGallery: addToGallery,
24672              multiple: multiple,
24673              value: multiple ? mediaIds : mediaId,
24674              onSelect: media => selectMedia(media, onClose),
24675              allowedTypes: allowedTypes,
24676              render: ({
24677                open
24678              }) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, {
24679                icon: library_media,
24680                onClick: open,
24681                children: (0,external_wp_i18n_namespaceObject.__)('Open Media Library')
24682              })
24683            }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FormFileUpload, {
24684              onChange: event => {
24685                uploadFiles(event, onClose);
24686              },
24687              accept: accept,
24688              multiple: !!multiple,
24689              render: ({
24690                openFileDialog
24691              }) => {
24692                return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, {
24693                  icon: library_upload,
24694                  onClick: () => {
24695                    openFileDialog();
24696                  },
24697                  children: (0,external_wp_i18n_namespaceObject._x)('Upload', 'verb')
24698                });
24699              }
24700            })]
24701          }), onToggleFeaturedImage && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, {
24702            icon: post_featured_image,
24703            onClick: onToggleFeaturedImage,
24704            isPressed: useFeaturedImage,
24705            children: (0,external_wp_i18n_namespaceObject.__)('Use featured image')
24706          }), mediaURL && onReset && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, {
24707            onClick: () => {
24708              onReset();
24709              onClose();
24710            },
24711            children: (0,external_wp_i18n_namespaceObject.__)('Reset')
24712          }), typeof children === 'function' ? children({
24713            onClose
24714          }) : children]
24715        }), onSelectURL &&
24716        /*#__PURE__*/
24717        // eslint-disable-next-line jsx-a11y/no-noninteractive-element-interactions
24718        (0,external_ReactJSXRuntime_namespaceObject.jsxs)("form", {
24719          className: "block-editor-media-flow__url-input",
24720          children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("span", {
24721            className: "block-editor-media-replace-flow__image-url-label",
24722            children: (0,external_wp_i18n_namespaceObject.__)('Current media URL:')
24723          }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(link_control, {
24724            value: {
24725              url: mediaURL
24726            },
24727            settings: [],
24728            showSuggestions: false,
24729            onChange: ({
24730              url
24731            }) => {
24732              onSelectURL(url);
24733            }
24734          })]
24735        })]
24736      })
24737    });
24738  };
24739  
24740  /**
24741   * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/media-replace-flow/README.md
24742   */
24743  /* harmony default export */ const media_replace_flow = ((0,external_wp_compose_namespaceObject.compose)([(0,external_wp_data_namespaceObject.withDispatch)(dispatch => {
24744    const {
24745      createNotice,
24746      removeNotice
24747    } = dispatch(external_wp_notices_namespaceObject.store);
24748    return {
24749      createNotice,
24750      removeNotice
24751    };
24752  }), (0,external_wp_components_namespaceObject.withFilters)('editor.MediaReplaceFlow')])(MediaReplaceFlow));
24753  
24754  ;// ./node_modules/@wordpress/block-editor/build-module/components/background-image-control/index.js
24755  /**
24756   * External dependencies
24757   */
24758  
24759  
24760  /**
24761   * WordPress dependencies
24762   */
24763  
24764  
24765  
24766  
24767  
24768  
24769  
24770  
24771  
24772  /**
24773   * Internal dependencies
24774   */
24775  
24776  
24777  
24778  
24779  
24780  
24781  
24782  const IMAGE_BACKGROUND_TYPE = 'image';
24783  const BACKGROUND_POPOVER_PROPS = {
24784    placement: 'left-start',
24785    offset: 36,
24786    shift: true,
24787    className: 'block-editor-global-styles-background-panel__popover'
24788  };
24789  const background_image_control_noop = () => {};
24790  
24791  /**
24792   * Get the help text for the background size control.
24793   *
24794   * @param {string} value backgroundSize value.
24795   * @return {string}      Translated help text.
24796   */
24797  function backgroundSizeHelpText(value) {
24798    if (value === 'cover' || value === undefined) {
24799      return (0,external_wp_i18n_namespaceObject.__)('Image covers the space evenly.');
24800    }
24801    if (value === 'contain') {
24802      return (0,external_wp_i18n_namespaceObject.__)('Image is contained without distortion.');
24803    }
24804    return (0,external_wp_i18n_namespaceObject.__)('Image has a fixed width.');
24805  }
24806  
24807  /**
24808   * Converts decimal x and y coords from FocalPointPicker to percentage-based values
24809   * to use as backgroundPosition value.
24810   *
24811   * @param {{x?:number, y?:number}} value FocalPointPicker coords.
24812   * @return {string}                       backgroundPosition value.
24813   */
24814  const coordsToBackgroundPosition = value => {
24815    if (!value || isNaN(value.x) && isNaN(value.y)) {
24816      return undefined;
24817    }
24818    const x = isNaN(value.x) ? 0.5 : value.x;
24819    const y = isNaN(value.y) ? 0.5 : value.y;
24820    return `$x * 100}% $y * 100}%`;
24821  };
24822  
24823  /**
24824   * Converts backgroundPosition value to x and y coords for FocalPointPicker.
24825   *
24826   * @param {string} value backgroundPosition value.
24827   * @return {{x?:number, y?:number}}       FocalPointPicker coords.
24828   */
24829  const backgroundPositionToCoords = value => {
24830    if (!value) {
24831      return {
24832        x: undefined,
24833        y: undefined
24834      };
24835    }
24836    let [x, y] = value.split(' ').map(v => parseFloat(v) / 100);
24837    x = isNaN(x) ? undefined : x;
24838    y = isNaN(y) ? x : y;
24839    return {
24840      x,
24841      y
24842    };
24843  };
24844  function InspectorImagePreviewItem({
24845    as = 'span',
24846    imgUrl,
24847    toggleProps = {},
24848    filename,
24849    label,
24850    className,
24851    onToggleCallback = background_image_control_noop
24852  }) {
24853    (0,external_wp_element_namespaceObject.useEffect)(() => {
24854      if (typeof toggleProps?.isOpen !== 'undefined') {
24855        onToggleCallback(toggleProps?.isOpen);
24856      }
24857    }, [toggleProps?.isOpen, onToggleCallback]);
24858    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalItemGroup, {
24859      as: as,
24860      className: className,
24861      ...toggleProps,
24862      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalHStack, {
24863        justify: "flex-start",
24864        as: "span",
24865        className: "block-editor-global-styles-background-panel__inspector-preview-inner",
24866        children: [imgUrl && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("span", {
24867          className: "block-editor-global-styles-background-panel__inspector-image-indicator-wrapper",
24868          "aria-hidden": true,
24869          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("span", {
24870            className: "block-editor-global-styles-background-panel__inspector-image-indicator",
24871            style: {
24872              backgroundImage: `url($imgUrl})`
24873            }
24874          })
24875        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.FlexItem, {
24876          as: "span",
24877          style: imgUrl ? {} : {
24878            flexGrow: 1
24879          },
24880          children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalTruncate, {
24881            numberOfLines: 1,
24882            className: "block-editor-global-styles-background-panel__inspector-media-replace-title",
24883            children: label
24884          }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.VisuallyHidden, {
24885            as: "span",
24886            children: imgUrl ? (0,external_wp_i18n_namespaceObject.sprintf)(/* translators: %s: file name */
24887            (0,external_wp_i18n_namespaceObject.__)('Background image: %s'), filename || label) : (0,external_wp_i18n_namespaceObject.__)('No background image selected')
24888          })]
24889        })]
24890      })
24891    });
24892  }
24893  function BackgroundControlsPanel({
24894    label,
24895    filename,
24896    url: imgUrl,
24897    children,
24898    onToggle: onToggleCallback = background_image_control_noop,
24899    hasImageValue
24900  }) {
24901    if (!hasImageValue) {
24902      return;
24903    }
24904    const imgLabel = label || (0,external_wp_url_namespaceObject.getFilename)(imgUrl) || (0,external_wp_i18n_namespaceObject.__)('Add background image');
24905    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Dropdown, {
24906      popoverProps: BACKGROUND_POPOVER_PROPS,
24907      renderToggle: ({
24908        onToggle,
24909        isOpen
24910      }) => {
24911        const toggleProps = {
24912          onClick: onToggle,
24913          className: 'block-editor-global-styles-background-panel__dropdown-toggle',
24914          'aria-expanded': isOpen,
24915          'aria-label': (0,external_wp_i18n_namespaceObject.__)('Background size, position and repeat options.'),
24916          isOpen
24917        };
24918        return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(InspectorImagePreviewItem, {
24919          imgUrl: imgUrl,
24920          filename: filename,
24921          label: imgLabel,
24922          toggleProps: toggleProps,
24923          as: "button",
24924          onToggleCallback: onToggleCallback
24925        });
24926      },
24927      renderContent: () => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalDropdownContentWrapper, {
24928        className: "block-editor-global-styles-background-panel__dropdown-content-wrapper",
24929        paddingSize: "medium",
24930        children: children
24931      })
24932    });
24933  }
24934  function LoadingSpinner() {
24935    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Placeholder, {
24936      className: "block-editor-global-styles-background-panel__loading",
24937      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Spinner, {})
24938    });
24939  }
24940  function BackgroundImageControls({
24941    onChange,
24942    style,
24943    inheritedValue,
24944    onRemoveImage = background_image_control_noop,
24945    onResetImage = background_image_control_noop,
24946    displayInPanel,
24947    defaultValues
24948  }) {
24949    const [isUploading, setIsUploading] = (0,external_wp_element_namespaceObject.useState)(false);
24950    const {
24951      getSettings
24952    } = (0,external_wp_data_namespaceObject.useSelect)(store);
24953    const {
24954      id,
24955      title,
24956      url
24957    } = style?.background?.backgroundImage || {
24958      ...inheritedValue?.background?.backgroundImage
24959    };
24960    const replaceContainerRef = (0,external_wp_element_namespaceObject.useRef)();
24961    const {
24962      createErrorNotice
24963    } = (0,external_wp_data_namespaceObject.useDispatch)(external_wp_notices_namespaceObject.store);
24964    const onUploadError = message => {
24965      createErrorNotice(message, {
24966        type: 'snackbar'
24967      });
24968      setIsUploading(false);
24969    };
24970    const resetBackgroundImage = () => onChange(setImmutably(style, ['background', 'backgroundImage'], undefined));
24971    const onSelectMedia = media => {
24972      if (!media || !media.url) {
24973        resetBackgroundImage();
24974        setIsUploading(false);
24975        return;
24976      }
24977      if ((0,external_wp_blob_namespaceObject.isBlobURL)(media.url)) {
24978        setIsUploading(true);
24979        return;
24980      }
24981  
24982      // For media selections originated from a file upload.
24983      if (media.media_type && media.media_type !== IMAGE_BACKGROUND_TYPE || !media.media_type && media.type && media.type !== IMAGE_BACKGROUND_TYPE) {
24984        onUploadError((0,external_wp_i18n_namespaceObject.__)('Only images can be used as a background image.'));
24985        return;
24986      }
24987      const sizeValue = style?.background?.backgroundSize || defaultValues?.backgroundSize;
24988      const positionValue = style?.background?.backgroundPosition;
24989      onChange(setImmutably(style, ['background'], {
24990        ...style?.background,
24991        backgroundImage: {
24992          url: media.url,
24993          id: media.id,
24994          source: 'file',
24995          title: media.title || undefined
24996        },
24997        backgroundPosition:
24998        /*
24999         * A background image uploaded and set in the editor receives a default background position of '50% 0',
25000         * when the background image size is the equivalent of "Tile".
25001         * This is to increase the chance that the image's focus point is visible.
25002         * This is in-editor only to assist with the user experience.
25003         */
25004        !positionValue && ('auto' === sizeValue || !sizeValue) ? '50% 0' : positionValue,
25005        backgroundSize: sizeValue
25006      }));
25007      setIsUploading(false);
25008    };
25009  
25010    // Drag and drop callback, restricting image to one.
25011    const onFilesDrop = filesList => {
25012      getSettings().mediaUpload({
25013        allowedTypes: [IMAGE_BACKGROUND_TYPE],
25014        filesList,
25015        onFileChange([image]) {
25016          onSelectMedia(image);
25017        },
25018        onError: onUploadError,
25019        multiple: false
25020      });
25021    };
25022    const hasValue = hasBackgroundImageValue(style);
25023    const closeAndFocus = () => {
25024      const [toggleButton] = external_wp_dom_namespaceObject.focus.tabbable.find(replaceContainerRef.current);
25025      // Focus the toggle button and close the dropdown menu.
25026      // This ensures similar behaviour as to selecting an image, where the dropdown is
25027      // closed and focus is redirected to the dropdown toggle button.
25028      toggleButton?.focus();
25029      toggleButton?.click();
25030    };
25031    const onRemove = () => onChange(setImmutably(style, ['background'], {
25032      backgroundImage: 'none'
25033    }));
25034    const canRemove = !hasValue && hasBackgroundImageValue(inheritedValue);
25035    const imgLabel = title || (0,external_wp_url_namespaceObject.getFilename)(url) || (0,external_wp_i18n_namespaceObject.__)('Add background image');
25036    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
25037      ref: replaceContainerRef,
25038      className: "block-editor-global-styles-background-panel__image-tools-panel-item",
25039      children: [isUploading && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(LoadingSpinner, {}), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(media_replace_flow, {
25040        mediaId: id,
25041        mediaURL: url,
25042        allowedTypes: [IMAGE_BACKGROUND_TYPE],
25043        accept: "image/*",
25044        onSelect: onSelectMedia,
25045        popoverProps: {
25046          className: dist_clsx({
25047            'block-editor-global-styles-background-panel__media-replace-popover': displayInPanel
25048          })
25049        },
25050        name: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(InspectorImagePreviewItem, {
25051          className: "block-editor-global-styles-background-panel__image-preview",
25052          imgUrl: url,
25053          filename: title,
25054          label: imgLabel
25055        }),
25056        renderToggle: props => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
25057          ...props,
25058          __next40pxDefaultSize: true
25059        }),
25060        onError: onUploadError,
25061        onReset: () => {
25062          closeAndFocus();
25063          onResetImage();
25064        },
25065        children: canRemove && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, {
25066          onClick: () => {
25067            closeAndFocus();
25068            onRemove();
25069            onRemoveImage();
25070          },
25071          children: (0,external_wp_i18n_namespaceObject.__)('Remove')
25072        })
25073      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.DropZone, {
25074        onFilesDrop: onFilesDrop,
25075        label: (0,external_wp_i18n_namespaceObject.__)('Drop to upload')
25076      })]
25077    });
25078  }
25079  function BackgroundSizeControls({
25080    onChange,
25081    style,
25082    inheritedValue,
25083    defaultValues
25084  }) {
25085    const sizeValue = style?.background?.backgroundSize || inheritedValue?.background?.backgroundSize;
25086    const repeatValue = style?.background?.backgroundRepeat || inheritedValue?.background?.backgroundRepeat;
25087    const imageValue = style?.background?.backgroundImage?.url || inheritedValue?.background?.backgroundImage?.url;
25088    const isUploadedImage = style?.background?.backgroundImage?.id;
25089    const positionValue = style?.background?.backgroundPosition || inheritedValue?.background?.backgroundPosition;
25090    const attachmentValue = style?.background?.backgroundAttachment || inheritedValue?.background?.backgroundAttachment;
25091  
25092    /*
25093     * Set default values for uploaded images.
25094     * The default values are passed by the consumer.
25095     * Block-level controls may have different defaults to root-level controls.
25096     * A falsy value is treated by default as `auto` (Tile).
25097     */
25098    let currentValueForToggle = !sizeValue && isUploadedImage ? defaultValues?.backgroundSize : sizeValue || 'auto';
25099    /*
25100     * The incoming value could be a value + unit, e.g. '20px'.
25101     * In this case set the value to 'tile'.
25102     */
25103    currentValueForToggle = !['cover', 'contain', 'auto'].includes(currentValueForToggle) ? 'auto' : currentValueForToggle;
25104    /*
25105     * If the current value is `cover` and the repeat value is `undefined`, then
25106     * the toggle should be unchecked as the default state. Otherwise, the toggle
25107     * should reflect the current repeat value.
25108     */
25109    const repeatCheckedValue = !(repeatValue === 'no-repeat' || currentValueForToggle === 'cover' && repeatValue === undefined);
25110    const updateBackgroundSize = next => {
25111      // When switching to 'contain' toggle the repeat off.
25112      let nextRepeat = repeatValue;
25113      let nextPosition = positionValue;
25114      if (next === 'contain') {
25115        nextRepeat = 'no-repeat';
25116        nextPosition = undefined;
25117      }
25118      if (next === 'cover') {
25119        nextRepeat = undefined;
25120        nextPosition = undefined;
25121      }
25122      if ((currentValueForToggle === 'cover' || currentValueForToggle === 'contain') && next === 'auto') {
25123        nextRepeat = undefined;
25124        /*
25125         * A background image uploaded and set in the editor (an image with a record id),
25126         * receives a default background position of '50% 0',
25127         * when the toggle switches to "Tile". This is to increase the chance that
25128         * the image's focus point is visible.
25129         * This is in-editor only to assist with the user experience.
25130         */
25131        if (!!style?.background?.backgroundImage?.id) {
25132          nextPosition = '50% 0';
25133        }
25134      }
25135  
25136      /*
25137       * Next will be null when the input is cleared,
25138       * in which case the value should be 'auto'.
25139       */
25140      if (!next && currentValueForToggle === 'auto') {
25141        next = 'auto';
25142      }
25143      onChange(setImmutably(style, ['background'], {
25144        ...style?.background,
25145        backgroundPosition: nextPosition,
25146        backgroundRepeat: nextRepeat,
25147        backgroundSize: next
25148      }));
25149    };
25150    const updateBackgroundPosition = next => {
25151      onChange(setImmutably(style, ['background', 'backgroundPosition'], coordsToBackgroundPosition(next)));
25152    };
25153    const toggleIsRepeated = () => onChange(setImmutably(style, ['background', 'backgroundRepeat'], repeatCheckedValue === true ? 'no-repeat' : 'repeat'));
25154    const toggleScrollWithPage = () => onChange(setImmutably(style, ['background', 'backgroundAttachment'], attachmentValue === 'fixed' ? 'scroll' : 'fixed'));
25155  
25156    // Set a default background position for non-site-wide, uploaded images with a size of 'contain'.
25157    const backgroundPositionValue = !positionValue && isUploadedImage && 'contain' === sizeValue ? defaultValues?.backgroundPosition : positionValue;
25158    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalVStack, {
25159      spacing: 3,
25160      className: "single-column",
25161      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FocalPointPicker, {
25162        __nextHasNoMarginBottom: true,
25163        label: (0,external_wp_i18n_namespaceObject.__)('Focal point'),
25164        url: imageValue,
25165        value: backgroundPositionToCoords(backgroundPositionValue),
25166        onChange: updateBackgroundPosition
25167      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToggleControl, {
25168        __nextHasNoMarginBottom: true,
25169        label: (0,external_wp_i18n_namespaceObject.__)('Fixed background'),
25170        checked: attachmentValue === 'fixed',
25171        onChange: toggleScrollWithPage
25172      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalToggleGroupControl, {
25173        __nextHasNoMarginBottom: true,
25174        size: "__unstable-large",
25175        label: (0,external_wp_i18n_namespaceObject.__)('Size'),
25176        value: currentValueForToggle,
25177        onChange: updateBackgroundSize,
25178        isBlock: true,
25179        help: backgroundSizeHelpText(sizeValue || defaultValues?.backgroundSize),
25180        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControlOption, {
25181          value: "cover",
25182          label: (0,external_wp_i18n_namespaceObject._x)('Cover', 'Size option for background image control')
25183        }, "cover"), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControlOption, {
25184          value: "contain",
25185          label: (0,external_wp_i18n_namespaceObject._x)('Contain', 'Size option for background image control')
25186        }, "contain"), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControlOption, {
25187          value: "auto",
25188          label: (0,external_wp_i18n_namespaceObject._x)('Tile', 'Size option for background image control')
25189        }, "tile")]
25190      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalHStack, {
25191        justify: "flex-start",
25192        spacing: 2,
25193        as: "span",
25194        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalUnitControl, {
25195          "aria-label": (0,external_wp_i18n_namespaceObject.__)('Background image width'),
25196          onChange: updateBackgroundSize,
25197          value: sizeValue,
25198          size: "__unstable-large",
25199          __unstableInputWidth: "100px",
25200          min: 0,
25201          placeholder: (0,external_wp_i18n_namespaceObject.__)('Auto'),
25202          disabled: currentValueForToggle !== 'auto' || currentValueForToggle === undefined
25203        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToggleControl, {
25204          __nextHasNoMarginBottom: true,
25205          label: (0,external_wp_i18n_namespaceObject.__)('Repeat'),
25206          checked: repeatCheckedValue,
25207          onChange: toggleIsRepeated,
25208          disabled: currentValueForToggle === 'cover'
25209        })]
25210      })]
25211    });
25212  }
25213  function BackgroundImagePanel({
25214    value,
25215    onChange,
25216    inheritedValue = value,
25217    settings,
25218    defaultValues = {}
25219  }) {
25220    /*
25221     * Resolve any inherited "ref" pointers.
25222     * Should the block editor need resolved, inherited values
25223     * across all controls, this could be abstracted into a hook,
25224     * e.g., useResolveGlobalStyle
25225     */
25226    const {
25227      globalStyles,
25228      _links
25229    } = (0,external_wp_data_namespaceObject.useSelect)(select => {
25230      const {
25231        getSettings
25232      } = select(store);
25233      const _settings = getSettings();
25234      return {
25235        globalStyles: _settings[globalStylesDataKey],
25236        _links: _settings[globalStylesLinksDataKey]
25237      };
25238    }, []);
25239    const resolvedInheritedValue = (0,external_wp_element_namespaceObject.useMemo)(() => {
25240      const resolvedValues = {
25241        background: {}
25242      };
25243      if (!inheritedValue?.background) {
25244        return inheritedValue;
25245      }
25246      Object.entries(inheritedValue?.background).forEach(([key, backgroundValue]) => {
25247        resolvedValues.background[key] = getResolvedValue(backgroundValue, {
25248          styles: globalStyles,
25249          _links
25250        });
25251      });
25252      return resolvedValues;
25253    }, [globalStyles, _links, inheritedValue]);
25254    const resetBackground = () => onChange(setImmutably(value, ['background'], {}));
25255    const {
25256      title,
25257      url
25258    } = value?.background?.backgroundImage || {
25259      ...resolvedInheritedValue?.background?.backgroundImage
25260    };
25261    const hasImageValue = hasBackgroundImageValue(value) || hasBackgroundImageValue(resolvedInheritedValue);
25262    const imageValue = value?.background?.backgroundImage || inheritedValue?.background?.backgroundImage;
25263    const shouldShowBackgroundImageControls = hasImageValue && 'none' !== imageValue && (settings?.background?.backgroundSize || settings?.background?.backgroundPosition || settings?.background?.backgroundRepeat);
25264    const [isDropDownOpen, setIsDropDownOpen] = (0,external_wp_element_namespaceObject.useState)(false);
25265    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
25266      className: dist_clsx('block-editor-global-styles-background-panel__inspector-media-replace-container', {
25267        'is-open': isDropDownOpen
25268      }),
25269      children: shouldShowBackgroundImageControls ? /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BackgroundControlsPanel, {
25270        label: title,
25271        filename: title,
25272        url: url,
25273        onToggle: setIsDropDownOpen,
25274        hasImageValue: hasImageValue,
25275        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalVStack, {
25276          spacing: 3,
25277          className: "single-column",
25278          children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BackgroundImageControls, {
25279            onChange: onChange,
25280            style: value,
25281            inheritedValue: resolvedInheritedValue,
25282            displayInPanel: true,
25283            onResetImage: () => {
25284              setIsDropDownOpen(false);
25285              resetBackground();
25286            },
25287            onRemoveImage: () => setIsDropDownOpen(false),
25288            defaultValues: defaultValues
25289          }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BackgroundSizeControls, {
25290            onChange: onChange,
25291            style: value,
25292            defaultValues: defaultValues,
25293            inheritedValue: resolvedInheritedValue
25294          })]
25295        })
25296      }) : /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BackgroundImageControls, {
25297        onChange: onChange,
25298        style: value,
25299        inheritedValue: resolvedInheritedValue,
25300        defaultValues: defaultValues,
25301        onResetImage: () => {
25302          setIsDropDownOpen(false);
25303          resetBackground();
25304        },
25305        onRemoveImage: () => setIsDropDownOpen(false)
25306      })
25307    });
25308  }
25309  
25310  ;// ./node_modules/@wordpress/block-editor/build-module/components/global-styles/background-panel.js
25311  /**
25312   * WordPress dependencies
25313   */
25314  
25315  
25316  /**
25317   * Internal dependencies
25318   */
25319  
25320  
25321  
25322  
25323  
25324  const background_panel_DEFAULT_CONTROLS = {
25325    backgroundImage: true
25326  };
25327  
25328  /**
25329   * Checks site settings to see if the background panel may be used.
25330   * `settings.background.backgroundSize` exists also,
25331   * but can only be used if settings?.background?.backgroundImage is `true`.
25332   *
25333   * @param {Object} settings Site settings
25334   * @return {boolean}        Whether site settings has activated background panel.
25335   */
25336  function useHasBackgroundPanel(settings) {
25337    return external_wp_element_namespaceObject.Platform.OS === 'web' && settings?.background?.backgroundImage;
25338  }
25339  
25340  /**
25341   * Checks if there is a current value in the background size block support
25342   * attributes. Background size values include background size as well
25343   * as background position.
25344   *
25345   * @param {Object} style Style attribute.
25346   * @return {boolean}     Whether the block has a background size value set.
25347   */
25348  function hasBackgroundSizeValue(style) {
25349    return style?.background?.backgroundPosition !== undefined || style?.background?.backgroundSize !== undefined;
25350  }
25351  
25352  /**
25353   * Checks if there is a current value in the background image block support
25354   * attributes.
25355   *
25356   * @param {Object} style Style attribute.
25357   * @return {boolean}     Whether the block has a background image value set.
25358   */
25359  function hasBackgroundImageValue(style) {
25360    return !!style?.background?.backgroundImage?.id ||
25361    // Supports url() string values in theme.json.
25362    'string' === typeof style?.background?.backgroundImage || !!style?.background?.backgroundImage?.url;
25363  }
25364  function BackgroundToolsPanel({
25365    resetAllFilter,
25366    onChange,
25367    value,
25368    panelId,
25369    children,
25370    headerLabel
25371  }) {
25372    const dropdownMenuProps = useToolsPanelDropdownMenuProps();
25373    const resetAll = () => {
25374      const updatedValue = resetAllFilter(value);
25375      onChange(updatedValue);
25376    };
25377    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanel, {
25378      label: headerLabel,
25379      resetAll: resetAll,
25380      panelId: panelId,
25381      dropdownMenuProps: dropdownMenuProps,
25382      children: children
25383    });
25384  }
25385  function background_panel_BackgroundImagePanel({
25386    as: Wrapper = BackgroundToolsPanel,
25387    value,
25388    onChange,
25389    inheritedValue,
25390    settings,
25391    panelId,
25392    defaultControls = background_panel_DEFAULT_CONTROLS,
25393    defaultValues = {},
25394    headerLabel = (0,external_wp_i18n_namespaceObject.__)('Background image')
25395  }) {
25396    const showBackgroundImageControl = useHasBackgroundPanel(settings);
25397    const resetBackground = () => onChange(setImmutably(value, ['background'], {}));
25398    const resetAllFilter = (0,external_wp_element_namespaceObject.useCallback)(previousValue => {
25399      return {
25400        ...previousValue,
25401        background: {}
25402      };
25403    }, []);
25404    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Wrapper, {
25405      resetAllFilter: resetAllFilter,
25406      value: value,
25407      onChange: onChange,
25408      panelId: panelId,
25409      headerLabel: headerLabel,
25410      children: showBackgroundImageControl && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanelItem, {
25411        hasValue: () => !!value?.background,
25412        label: (0,external_wp_i18n_namespaceObject.__)('Image'),
25413        onDeselect: resetBackground,
25414        isShownByDefault: defaultControls.backgroundImage,
25415        panelId: panelId,
25416        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BackgroundImagePanel, {
25417          value: value,
25418          onChange: onChange,
25419          settings: settings,
25420          inheritedValue: inheritedValue,
25421          defaultControls: defaultControls,
25422          defaultValues: defaultValues
25423        })
25424      })
25425    });
25426  }
25427  
25428  ;// ./node_modules/@wordpress/block-editor/build-module/hooks/background.js
25429  /**
25430   * WordPress dependencies
25431   */
25432  
25433  
25434  
25435  
25436  /**
25437   * Internal dependencies
25438   */
25439  
25440  
25441  
25442  
25443  
25444  
25445  const BACKGROUND_SUPPORT_KEY = 'background';
25446  
25447  // Initial control values.
25448  const BACKGROUND_BLOCK_DEFAULT_VALUES = {
25449    backgroundSize: 'cover',
25450    backgroundPosition: '50% 50%' // used only when backgroundSize is 'contain'.
25451  };
25452  
25453  /**
25454   * Determine whether there is block support for background.
25455   *
25456   * @param {string} blockName Block name.
25457   * @param {string} feature   Background image feature to check for.
25458   *
25459   * @return {boolean} Whether there is support.
25460   */
25461  function hasBackgroundSupport(blockName, feature = 'any') {
25462    const support = (0,external_wp_blocks_namespaceObject.getBlockSupport)(blockName, BACKGROUND_SUPPORT_KEY);
25463    if (support === true) {
25464      return true;
25465    }
25466    if (feature === 'any') {
25467      return !!support?.backgroundImage || !!support?.backgroundSize || !!support?.backgroundRepeat;
25468    }
25469    return !!support?.[feature];
25470  }
25471  function setBackgroundStyleDefaults(backgroundStyle) {
25472    if (!backgroundStyle || !backgroundStyle?.backgroundImage?.url) {
25473      return;
25474    }
25475    let backgroundStylesWithDefaults;
25476  
25477    // Set block background defaults.
25478    if (!backgroundStyle?.backgroundSize) {
25479      backgroundStylesWithDefaults = {
25480        backgroundSize: BACKGROUND_BLOCK_DEFAULT_VALUES.backgroundSize
25481      };
25482    }
25483    if ('contain' === backgroundStyle?.backgroundSize && !backgroundStyle?.backgroundPosition) {
25484      backgroundStylesWithDefaults = {
25485        backgroundPosition: BACKGROUND_BLOCK_DEFAULT_VALUES.backgroundPosition
25486      };
25487    }
25488    return backgroundStylesWithDefaults;
25489  }
25490  function background_useBlockProps({
25491    name,
25492    style
25493  }) {
25494    if (!hasBackgroundSupport(name) || !style?.background?.backgroundImage) {
25495      return;
25496    }
25497    const backgroundStyles = setBackgroundStyleDefaults(style?.background);
25498    if (!backgroundStyles) {
25499      return;
25500    }
25501    return {
25502      style: {
25503        ...backgroundStyles
25504      }
25505    };
25506  }
25507  
25508  /**
25509   * Generates a CSS class name if an background image is set.
25510   *
25511   * @param {Object} style A block's style attribute.
25512   *
25513   * @return {string} CSS class name.
25514   */
25515  function getBackgroundImageClasses(style) {
25516    return hasBackgroundImageValue(style) ? 'has-background' : '';
25517  }
25518  function BackgroundInspectorControl({
25519    children
25520  }) {
25521    const resetAllFilter = (0,external_wp_element_namespaceObject.useCallback)(attributes => {
25522      return {
25523        ...attributes,
25524        style: {
25525          ...attributes.style,
25526          background: undefined
25527        }
25528      };
25529    }, []);
25530    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls, {
25531      group: "background",
25532      resetAllFilter: resetAllFilter,
25533      children: children
25534    });
25535  }
25536  function background_BackgroundImagePanel({
25537    clientId,
25538    name,
25539    setAttributes,
25540    settings
25541  }) {
25542    const {
25543      style,
25544      inheritedValue
25545    } = (0,external_wp_data_namespaceObject.useSelect)(select => {
25546      const {
25547        getBlockAttributes,
25548        getSettings
25549      } = select(store);
25550      const _settings = getSettings();
25551      return {
25552        style: getBlockAttributes(clientId)?.style,
25553        /*
25554         * To ensure we pass down the right inherited values:
25555         * @TODO 1. Pass inherited value down to all block style controls,
25556         *   See: packages/block-editor/src/hooks/style.js
25557         * @TODO 2. Add support for block style variations,
25558         *   See implementation: packages/block-editor/src/hooks/block-style-variation.js
25559         */
25560        inheritedValue: _settings[globalStylesDataKey]?.blocks?.[name]
25561      };
25562    }, [clientId, name]);
25563    if (!useHasBackgroundPanel(settings) || !hasBackgroundSupport(name, 'backgroundImage')) {
25564      return null;
25565    }
25566    const onChange = newStyle => {
25567      setAttributes({
25568        style: utils_cleanEmptyObject(newStyle)
25569      });
25570    };
25571    const updatedSettings = {
25572      ...settings,
25573      background: {
25574        ...settings.background,
25575        backgroundSize: settings?.background?.backgroundSize && hasBackgroundSupport(name, 'backgroundSize')
25576      }
25577    };
25578    const defaultControls = (0,external_wp_blocks_namespaceObject.getBlockSupport)(name, [BACKGROUND_SUPPORT_KEY, 'defaultControls']);
25579    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(background_panel_BackgroundImagePanel, {
25580      inheritedValue: inheritedValue,
25581      as: BackgroundInspectorControl,
25582      panelId: clientId,
25583      defaultValues: BACKGROUND_BLOCK_DEFAULT_VALUES,
25584      settings: updatedSettings,
25585      onChange: onChange,
25586      defaultControls: defaultControls,
25587      value: style
25588    });
25589  }
25590  /* harmony default export */ const background = ({
25591    useBlockProps: background_useBlockProps,
25592    attributeKeys: ['style'],
25593    hasSupport: hasBackgroundSupport
25594  });
25595  
25596  ;// ./node_modules/@wordpress/block-editor/build-module/hooks/lock.js
25597  /**
25598   * WordPress dependencies
25599   */
25600  
25601  
25602  /**
25603   * Filters registered block settings, extending attributes to include `lock`.
25604   *
25605   * @param {Object} settings Original block settings.
25606   *
25607   * @return {Object} Filtered block settings.
25608   */
25609  function lock_addAttribute(settings) {
25610    var _settings$attributes$;
25611    // Allow blocks to specify their own attribute definition with default values if needed.
25612    if ('type' in ((_settings$attributes$ = settings.attributes?.lock) !== null && _settings$attributes$ !== void 0 ? _settings$attributes$ : {})) {
25613      return settings;
25614    }
25615    // Gracefully handle if settings.attributes is undefined.
25616    settings.attributes = {
25617      ...settings.attributes,
25618      lock: {
25619        type: 'object'
25620      }
25621    };
25622    return settings;
25623  }
25624  (0,external_wp_hooks_namespaceObject.addFilter)('blocks.registerBlockType', 'core/lock/addAttribute', lock_addAttribute);
25625  
25626  ;// ./node_modules/@wordpress/block-editor/build-module/hooks/anchor.js
25627  /**
25628   * WordPress dependencies
25629   */
25630  
25631  
25632  
25633  
25634  
25635  
25636  /**
25637   * Internal dependencies
25638   */
25639  
25640  
25641  
25642  /**
25643   * Regular expression matching invalid anchor characters for replacement.
25644   *
25645   * @type {RegExp}
25646   */
25647  
25648  const ANCHOR_REGEX = /[\s#]/g;
25649  const ANCHOR_SCHEMA = {
25650    type: 'string',
25651    source: 'attribute',
25652    attribute: 'id',
25653    selector: '*'
25654  };
25655  
25656  /**
25657   * Filters registered block settings, extending attributes with anchor using ID
25658   * of the first node.
25659   *
25660   * @param {Object} settings Original block settings.
25661   *
25662   * @return {Object} Filtered block settings.
25663   */
25664  function anchor_addAttribute(settings) {
25665    var _settings$attributes$;
25666    // Allow blocks to specify their own attribute definition with default values if needed.
25667    if ('type' in ((_settings$attributes$ = settings.attributes?.anchor) !== null && _settings$attributes$ !== void 0 ? _settings$attributes$ : {})) {
25668      return settings;
25669    }
25670    if ((0,external_wp_blocks_namespaceObject.hasBlockSupport)(settings, 'anchor')) {
25671      // Gracefully handle if settings.attributes is undefined.
25672      settings.attributes = {
25673        ...settings.attributes,
25674        anchor: ANCHOR_SCHEMA
25675      };
25676    }
25677    return settings;
25678  }
25679  function BlockEditAnchorControlPure({
25680    anchor,
25681    setAttributes
25682  }) {
25683    const blockEditingMode = useBlockEditingMode();
25684    if (blockEditingMode !== 'default') {
25685      return null;
25686    }
25687    const isWeb = external_wp_element_namespaceObject.Platform.OS === 'web';
25688    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls, {
25689      group: "advanced",
25690      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.TextControl, {
25691        __nextHasNoMarginBottom: true,
25692        __next40pxDefaultSize: true,
25693        className: "html-anchor-control",
25694        label: (0,external_wp_i18n_namespaceObject.__)('HTML anchor'),
25695        help: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
25696          children: [(0,external_wp_i18n_namespaceObject.__)('Enter a word or two — without spaces — to make a unique web address just for this block, called an “anchor”. Then, you’ll be able to link directly to this section of your page.'), isWeb && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
25697            children: [' ', /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ExternalLink, {
25698              href: (0,external_wp_i18n_namespaceObject.__)('https://wordpress.org/documentation/article/page-jumps/'),
25699              children: (0,external_wp_i18n_namespaceObject.__)('Learn more about anchors')
25700            })]
25701          })]
25702        }),
25703        value: anchor || '',
25704        placeholder: !isWeb ? (0,external_wp_i18n_namespaceObject.__)('Add an anchor') : null,
25705        onChange: nextValue => {
25706          nextValue = nextValue.replace(ANCHOR_REGEX, '-');
25707          setAttributes({
25708            anchor: nextValue
25709          });
25710        },
25711        autoCapitalize: "none",
25712        autoComplete: "off"
25713      })
25714    });
25715  }
25716  /* harmony default export */ const hooks_anchor = ({
25717    addSaveProps,
25718    edit: BlockEditAnchorControlPure,
25719    attributeKeys: ['anchor'],
25720    hasSupport(name) {
25721      return (0,external_wp_blocks_namespaceObject.hasBlockSupport)(name, 'anchor');
25722    }
25723  });
25724  
25725  /**
25726   * Override props assigned to save component to inject anchor ID, if block
25727   * supports anchor. This is only applied if the block's save result is an
25728   * element and not a markup string.
25729   *
25730   * @param {Object} extraProps Additional props applied to save element.
25731   * @param {Object} blockType  Block type.
25732   * @param {Object} attributes Current block attributes.
25733   *
25734   * @return {Object} Filtered props applied to save element.
25735   */
25736  function addSaveProps(extraProps, blockType, attributes) {
25737    if ((0,external_wp_blocks_namespaceObject.hasBlockSupport)(blockType, 'anchor')) {
25738      extraProps.id = attributes.anchor === '' ? null : attributes.anchor;
25739    }
25740    return extraProps;
25741  }
25742  (0,external_wp_hooks_namespaceObject.addFilter)('blocks.registerBlockType', 'core/anchor/attribute', anchor_addAttribute);
25743  
25744  ;// ./node_modules/@wordpress/block-editor/build-module/hooks/aria-label.js
25745  /**
25746   * WordPress dependencies
25747   */
25748  
25749  
25750  
25751  /**
25752   * Filters registered block settings, extending attributes with ariaLabel using aria-label
25753   * of the first node.
25754   *
25755   * @param {Object} settings Original block settings.
25756   *
25757   * @return {Object} Filtered block settings.
25758   */
25759  function aria_label_addAttribute(settings) {
25760    // Allow blocks to specify their own attribute definition with default values if needed.
25761    if (settings?.attributes?.ariaLabel?.type) {
25762      return settings;
25763    }
25764    if ((0,external_wp_blocks_namespaceObject.hasBlockSupport)(settings, 'ariaLabel')) {
25765      // Gracefully handle if settings.attributes is undefined.
25766      settings.attributes = {
25767        ...settings.attributes,
25768        ariaLabel: {
25769          type: 'string'
25770        }
25771      };
25772    }
25773    return settings;
25774  }
25775  
25776  /**
25777   * Override props assigned to save component to inject aria-label, if block
25778   * supports ariaLabel. This is only applied if the block's save result is an
25779   * element and not a markup string.
25780   *
25781   * @param {Object} extraProps Additional props applied to save element.
25782   * @param {Object} blockType  Block type.
25783   * @param {Object} attributes Current block attributes.
25784   *
25785   * @return {Object} Filtered props applied to save element.
25786   */
25787  function aria_label_addSaveProps(extraProps, blockType, attributes) {
25788    if ((0,external_wp_blocks_namespaceObject.hasBlockSupport)(blockType, 'ariaLabel')) {
25789      extraProps['aria-label'] = attributes.ariaLabel === '' ? null : attributes.ariaLabel;
25790    }
25791    return extraProps;
25792  }
25793  /* harmony default export */ const aria_label = ({
25794    addSaveProps: aria_label_addSaveProps,
25795    attributeKeys: ['ariaLabel'],
25796    hasSupport(name) {
25797      return (0,external_wp_blocks_namespaceObject.hasBlockSupport)(name, 'ariaLabel');
25798    }
25799  });
25800  (0,external_wp_hooks_namespaceObject.addFilter)('blocks.registerBlockType', 'core/ariaLabel/attribute', aria_label_addAttribute);
25801  
25802  ;// ./node_modules/@wordpress/block-editor/build-module/hooks/custom-class-name.js
25803  /**
25804   * External dependencies
25805   */
25806  
25807  
25808  /**
25809   * WordPress dependencies
25810   */
25811  
25812  
25813  
25814  
25815  
25816  /**
25817   * Internal dependencies
25818   */
25819  
25820  
25821  
25822  /**
25823   * Filters registered block settings, extending attributes to include `className`.
25824   *
25825   * @param {Object} settings Original block settings.
25826   *
25827   * @return {Object} Filtered block settings.
25828   */
25829  
25830  function custom_class_name_addAttribute(settings) {
25831    if ((0,external_wp_blocks_namespaceObject.hasBlockSupport)(settings, 'customClassName', true)) {
25832      // Gracefully handle if settings.attributes is undefined.
25833      settings.attributes = {
25834        ...settings.attributes,
25835        className: {
25836          type: 'string'
25837        }
25838      };
25839    }
25840    return settings;
25841  }
25842  function CustomClassNameControlsPure({
25843    className,
25844    setAttributes
25845  }) {
25846    const blockEditingMode = useBlockEditingMode();
25847    if (blockEditingMode !== 'default') {
25848      return null;
25849    }
25850    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls, {
25851      group: "advanced",
25852      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.TextControl, {
25853        __nextHasNoMarginBottom: true,
25854        __next40pxDefaultSize: true,
25855        autoComplete: "off",
25856        label: (0,external_wp_i18n_namespaceObject.__)('Additional CSS class(es)'),
25857        value: className || '',
25858        onChange: nextValue => {
25859          setAttributes({
25860            className: nextValue !== '' ? nextValue : undefined
25861          });
25862        },
25863        help: (0,external_wp_i18n_namespaceObject.__)('Separate multiple classes with spaces.')
25864      })
25865    });
25866  }
25867  /* harmony default export */ const custom_class_name = ({
25868    edit: CustomClassNameControlsPure,
25869    addSaveProps: custom_class_name_addSaveProps,
25870    attributeKeys: ['className'],
25871    hasSupport(name) {
25872      return (0,external_wp_blocks_namespaceObject.hasBlockSupport)(name, 'customClassName', true);
25873    }
25874  });
25875  
25876  /**
25877   * Override props assigned to save component to inject the className, if block
25878   * supports customClassName. This is only applied if the block's save result is an
25879   * element and not a markup string.
25880   *
25881   * @param {Object} extraProps Additional props applied to save element.
25882   * @param {Object} blockType  Block type.
25883   * @param {Object} attributes Current block attributes.
25884   *
25885   * @return {Object} Filtered props applied to save element.
25886   */
25887  function custom_class_name_addSaveProps(extraProps, blockType, attributes) {
25888    if ((0,external_wp_blocks_namespaceObject.hasBlockSupport)(blockType, 'customClassName', true) && attributes.className) {
25889      extraProps.className = dist_clsx(extraProps.className, attributes.className);
25890    }
25891    return extraProps;
25892  }
25893  function addTransforms(result, source, index, results) {
25894    if (!(0,external_wp_blocks_namespaceObject.hasBlockSupport)(result.name, 'customClassName', true)) {
25895      return result;
25896    }
25897  
25898    // If the condition verifies we are probably in the presence of a wrapping transform
25899    // e.g: nesting paragraphs in a group or columns and in that case the class should not be kept.
25900    if (results.length === 1 && result.innerBlocks.length === source.length) {
25901      return result;
25902    }
25903  
25904    // If we are transforming one block to multiple blocks or multiple blocks to one block,
25905    // we ignore the class during the transform.
25906    if (results.length === 1 && source.length > 1 || results.length > 1 && source.length === 1) {
25907      return result;
25908    }
25909  
25910    // If we are in presence of transform between one or more block in the source
25911    // that have one or more blocks in the result
25912    // we apply the class on source N to the result N,
25913    // if source N does not exists we do nothing.
25914    if (source[index]) {
25915      const originClassName = source[index]?.attributes.className;
25916      // Avoid overriding classes if the transformed block already includes them.
25917      if (originClassName && result.attributes.className === undefined) {
25918        return {
25919          ...result,
25920          attributes: {
25921            ...result.attributes,
25922            className: originClassName
25923          }
25924        };
25925      }
25926    }
25927    return result;
25928  }
25929  (0,external_wp_hooks_namespaceObject.addFilter)('blocks.registerBlockType', 'core/editor/custom-class-name/attribute', custom_class_name_addAttribute);
25930  (0,external_wp_hooks_namespaceObject.addFilter)('blocks.switchToBlockType.transformedBlock', 'core/color/addTransforms', addTransforms);
25931  
25932  ;// ./node_modules/@wordpress/block-editor/build-module/hooks/generated-class-name.js
25933  /**
25934   * WordPress dependencies
25935   */
25936  
25937  
25938  
25939  /**
25940   * Override props assigned to save component to inject generated className if
25941   * block supports it. This is only applied if the block's save result is an
25942   * element and not a markup string.
25943   *
25944   * @param {Object} extraProps Additional props applied to save element.
25945   * @param {Object} blockType  Block type.
25946   *
25947   * @return {Object} Filtered props applied to save element.
25948   */
25949  function addGeneratedClassName(extraProps, blockType) {
25950    // Adding the generated className.
25951    if ((0,external_wp_blocks_namespaceObject.hasBlockSupport)(blockType, 'className', true)) {
25952      if (typeof extraProps.className === 'string') {
25953        // We have some extra classes and want to add the default classname
25954        // We use uniq to prevent duplicate classnames.
25955  
25956        extraProps.className = [...new Set([(0,external_wp_blocks_namespaceObject.getBlockDefaultClassName)(blockType.name), ...extraProps.className.split(' ')])].join(' ').trim();
25957      } else {
25958        // There is no string in the className variable,
25959        // so we just dump the default name in there.
25960        extraProps.className = (0,external_wp_blocks_namespaceObject.getBlockDefaultClassName)(blockType.name);
25961      }
25962    }
25963    return extraProps;
25964  }
25965  (0,external_wp_hooks_namespaceObject.addFilter)('blocks.getSaveContent.extraProps', 'core/generated-class-name/save-props', addGeneratedClassName);
25966  
25967  ;// ./node_modules/colord/index.mjs
25968  var colord_r={grad:.9,turn:360,rad:360/(2*Math.PI)},t=function(r){return"string"==typeof r?r.length>0:"number"==typeof r},n=function(r,t,n){return void 0===t&&(t=0),void 0===n&&(n=Math.pow(10,t)),Math.round(n*r)/n+0},e=function(r,t,n){return void 0===t&&(t=0),void 0===n&&(n=1),r>n?n:r>t?r:t},u=function(r){return(r=isFinite(r)?r%360:0)>0?r:r+360},a=function(r){return{r:e(r.r,0,255),g:e(r.g,0,255),b:e(r.b,0,255),a:e(r.a)}},o=function(r){return{r:n(r.r),g:n(r.g),b:n(r.b),a:n(r.a,3)}},i=/^#([0-9a-f]{3,8})$/i,s=function(r){var t=r.toString(16);return t.length<2?"0"+t:t},h=function(r){var t=r.r,n=r.g,e=r.b,u=r.a,a=Math.max(t,n,e),o=a-Math.min(t,n,e),i=o?a===t?(n-e)/o:a===n?2+(e-t)/o:4+(t-n)/o:0;return{h:60*(i<0?i+6:i),s:a?o/a*100:0,v:a/255*100,a:u}},b=function(r){var t=r.h,n=r.s,e=r.v,u=r.a;t=t/360*6,n/=100,e/=100;var a=Math.floor(t),o=e*(1-n),i=e*(1-(t-a)*n),s=e*(1-(1-t+a)*n),h=a%6;return{r:255*[e,i,o,o,s,e][h],g:255*[s,e,e,i,o,o][h],b:255*[o,o,s,e,e,i][h],a:u}},g=function(r){return{h:u(r.h),s:e(r.s,0,100),l:e(r.l,0,100),a:e(r.a)}},d=function(r){return{h:n(r.h),s:n(r.s),l:n(r.l),a:n(r.a,3)}},f=function(r){return b((n=(t=r).s,{h:t.h,s:(n*=((e=t.l)<50?e:100-e)/100)>0?2*n/(e+n)*100:0,v:e+n,a:t.a}));var t,n,e},c=function(r){return{h:(t=h(r)).h,s:(u=(200-(n=t.s))*(e=t.v)/100)>0&&u<200?n*e/100/(u<=100?u:200-u)*100:0,l:u/2,a:t.a};var t,n,e,u},l=/^hsla?\(\s*([+-]?\d*\.?\d+)(deg|rad|grad|turn)?\s*,\s*([+-]?\d*\.?\d+)%\s*,\s*([+-]?\d*\.?\d+)%\s*(?:,\s*([+-]?\d*\.?\d+)(%)?\s*)?\)$/i,p=/^hsla?\(\s*([+-]?\d*\.?\d+)(deg|rad|grad|turn)?\s+([+-]?\d*\.?\d+)%\s+([+-]?\d*\.?\d+)%\s*(?:\/\s*([+-]?\d*\.?\d+)(%)?\s*)?\)$/i,v=/^rgba?\(\s*([+-]?\d*\.?\d+)(%)?\s*,\s*([+-]?\d*\.?\d+)(%)?\s*,\s*([+-]?\d*\.?\d+)(%)?\s*(?:,\s*([+-]?\d*\.?\d+)(%)?\s*)?\)$/i,m=/^rgba?\(\s*([+-]?\d*\.?\d+)(%)?\s+([+-]?\d*\.?\d+)(%)?\s+([+-]?\d*\.?\d+)(%)?\s*(?:\/\s*([+-]?\d*\.?\d+)(%)?\s*)?\)$/i,y={string:[[function(r){var t=i.exec(r);return t?(r=t[1]).length<=4?{r:parseInt(r[0]+r[0],16),g:parseInt(r[1]+r[1],16),b:parseInt(r[2]+r[2],16),a:4===r.length?n(parseInt(r[3]+r[3],16)/255,2):1}:6===r.length||8===r.length?{r:parseInt(r.substr(0,2),16),g:parseInt(r.substr(2,2),16),b:parseInt(r.substr(4,2),16),a:8===r.length?n(parseInt(r.substr(6,2),16)/255,2):1}:null:null},"hex"],[function(r){var t=v.exec(r)||m.exec(r);return t?t[2]!==t[4]||t[4]!==t[6]?null:a({r:Number(t[1])/(t[2]?100/255:1),g:Number(t[3])/(t[4]?100/255:1),b:Number(t[5])/(t[6]?100/255:1),a:void 0===t[7]?1:Number(t[7])/(t[8]?100:1)}):null},"rgb"],[function(t){var n=l.exec(t)||p.exec(t);if(!n)return null;var e,u,a=g({h:(e=n[1],u=n[2],void 0===u&&(u="deg"),Number(e)*(colord_r[u]||1)),s:Number(n[3]),l:Number(n[4]),a:void 0===n[5]?1:Number(n[5])/(n[6]?100:1)});return f(a)},"hsl"]],object:[[function(r){var n=r.r,e=r.g,u=r.b,o=r.a,i=void 0===o?1:o;return t(n)&&t(e)&&t(u)?a({r:Number(n),g:Number(e),b:Number(u),a:Number(i)}):null},"rgb"],[function(r){var n=r.h,e=r.s,u=r.l,a=r.a,o=void 0===a?1:a;if(!t(n)||!t(e)||!t(u))return null;var i=g({h:Number(n),s:Number(e),l:Number(u),a:Number(o)});return f(i)},"hsl"],[function(r){var n=r.h,a=r.s,o=r.v,i=r.a,s=void 0===i?1:i;if(!t(n)||!t(a)||!t(o))return null;var h=function(r){return{h:u(r.h),s:e(r.s,0,100),v:e(r.v,0,100),a:e(r.a)}}({h:Number(n),s:Number(a),v:Number(o),a:Number(s)});return b(h)},"hsv"]]},N=function(r,t){for(var n=0;n<t.length;n++){var e=t[n][0](r);if(e)return[e,t[n][1]]}return[null,void 0]},x=function(r){return"string"==typeof r?N(r.trim(),y.string):"object"==typeof r&&null!==r?N(r,y.object):[null,void 0]},I=function(r){return x(r)[1]},M=function(r,t){var n=c(r);return{h:n.h,s:e(n.s+100*t,0,100),l:n.l,a:n.a}},H=function(r){return(299*r.r+587*r.g+114*r.b)/1e3/255},$=function(r,t){var n=c(r);return{h:n.h,s:n.s,l:e(n.l+100*t,0,100),a:n.a}},colord_j=function(){function r(r){this.parsed=x(r)[0],this.rgba=this.parsed||{r:0,g:0,b:0,a:1}}return r.prototype.isValid=function(){return null!==this.parsed},r.prototype.brightness=function(){return n(H(this.rgba),2)},r.prototype.isDark=function(){return H(this.rgba)<.5},r.prototype.isLight=function(){return H(this.rgba)>=.5},r.prototype.toHex=function(){return r=o(this.rgba),t=r.r,e=r.g,u=r.b,i=(a=r.a)<1?s(n(255*a)):"","#"+s(t)+s(e)+s(u)+i;var r,t,e,u,a,i},r.prototype.toRgb=function(){return o(this.rgba)},r.prototype.toRgbString=function(){return r=o(this.rgba),t=r.r,n=r.g,e=r.b,(u=r.a)<1?"rgba("+t+", "+n+", "+e+", "+u+")":"rgb("+t+", "+n+", "+e+")";var r,t,n,e,u},r.prototype.toHsl=function(){return d(c(this.rgba))},r.prototype.toHslString=function(){return r=d(c(this.rgba)),t=r.h,n=r.s,e=r.l,(u=r.a)<1?"hsla("+t+", "+n+"%, "+e+"%, "+u+")":"hsl("+t+", "+n+"%, "+e+"%)";var r,t,n,e,u},r.prototype.toHsv=function(){return r=h(this.rgba),{h:n(r.h),s:n(r.s),v:n(r.v),a:n(r.a,3)};var r},r.prototype.invert=function(){return w({r:255-(r=this.rgba).r,g:255-r.g,b:255-r.b,a:r.a});var r},r.prototype.saturate=function(r){return void 0===r&&(r=.1),w(M(this.rgba,r))},r.prototype.desaturate=function(r){return void 0===r&&(r=.1),w(M(this.rgba,-r))},r.prototype.grayscale=function(){return w(M(this.rgba,-1))},r.prototype.lighten=function(r){return void 0===r&&(r=.1),w($(this.rgba,r))},r.prototype.darken=function(r){return void 0===r&&(r=.1),w($(this.rgba,-r))},r.prototype.rotate=function(r){return void 0===r&&(r=15),this.hue(this.hue()+r)},r.prototype.alpha=function(r){return"number"==typeof r?w({r:(t=this.rgba).r,g:t.g,b:t.b,a:r}):n(this.rgba.a,3);var t},r.prototype.hue=function(r){var t=c(this.rgba);return"number"==typeof r?w({h:r,s:t.s,l:t.l,a:t.a}):n(t.h)},r.prototype.isEqual=function(r){return this.toHex()===w(r).toHex()},r}(),w=function(r){return r instanceof colord_j?r:new colord_j(r)},S=[],k=function(r){r.forEach(function(r){S.indexOf(r)<0&&(r(colord_j,y),S.push(r))})},E=function(){return new colord_j({r:255*Math.random(),g:255*Math.random(),b:255*Math.random()})};
25969  
25970  ;// ./node_modules/colord/plugins/names.mjs
25971  /* harmony default export */ function names(e,f){var a={white:"#ffffff",bisque:"#ffe4c4",blue:"#0000ff",cadetblue:"#5f9ea0",chartreuse:"#7fff00",chocolate:"#d2691e",coral:"#ff7f50",antiquewhite:"#faebd7",aqua:"#00ffff",azure:"#f0ffff",whitesmoke:"#f5f5f5",papayawhip:"#ffefd5",plum:"#dda0dd",blanchedalmond:"#ffebcd",black:"#000000",gold:"#ffd700",goldenrod:"#daa520",gainsboro:"#dcdcdc",cornsilk:"#fff8dc",cornflowerblue:"#6495ed",burlywood:"#deb887",aquamarine:"#7fffd4",beige:"#f5f5dc",crimson:"#dc143c",cyan:"#00ffff",darkblue:"#00008b",darkcyan:"#008b8b",darkgoldenrod:"#b8860b",darkkhaki:"#bdb76b",darkgray:"#a9a9a9",darkgreen:"#006400",darkgrey:"#a9a9a9",peachpuff:"#ffdab9",darkmagenta:"#8b008b",darkred:"#8b0000",darkorchid:"#9932cc",darkorange:"#ff8c00",darkslateblue:"#483d8b",gray:"#808080",darkslategray:"#2f4f4f",darkslategrey:"#2f4f4f",deeppink:"#ff1493",deepskyblue:"#00bfff",wheat:"#f5deb3",firebrick:"#b22222",floralwhite:"#fffaf0",ghostwhite:"#f8f8ff",darkviolet:"#9400d3",magenta:"#ff00ff",green:"#008000",dodgerblue:"#1e90ff",grey:"#808080",honeydew:"#f0fff0",hotpink:"#ff69b4",blueviolet:"#8a2be2",forestgreen:"#228b22",lawngreen:"#7cfc00",indianred:"#cd5c5c",indigo:"#4b0082",fuchsia:"#ff00ff",brown:"#a52a2a",maroon:"#800000",mediumblue:"#0000cd",lightcoral:"#f08080",darkturquoise:"#00ced1",lightcyan:"#e0ffff",ivory:"#fffff0",lightyellow:"#ffffe0",lightsalmon:"#ffa07a",lightseagreen:"#20b2aa",linen:"#faf0e6",mediumaquamarine:"#66cdaa",lemonchiffon:"#fffacd",lime:"#00ff00",khaki:"#f0e68c",mediumseagreen:"#3cb371",limegreen:"#32cd32",mediumspringgreen:"#00fa9a",lightskyblue:"#87cefa",lightblue:"#add8e6",midnightblue:"#191970",lightpink:"#ffb6c1",mistyrose:"#ffe4e1",moccasin:"#ffe4b5",mintcream:"#f5fffa",lightslategray:"#778899",lightslategrey:"#778899",navajowhite:"#ffdead",navy:"#000080",mediumvioletred:"#c71585",powderblue:"#b0e0e6",palegoldenrod:"#eee8aa",oldlace:"#fdf5e6",paleturquoise:"#afeeee",mediumturquoise:"#48d1cc",mediumorchid:"#ba55d3",rebeccapurple:"#663399",lightsteelblue:"#b0c4de",mediumslateblue:"#7b68ee",thistle:"#d8bfd8",tan:"#d2b48c",orchid:"#da70d6",mediumpurple:"#9370db",purple:"#800080",pink:"#ffc0cb",skyblue:"#87ceeb",springgreen:"#00ff7f",palegreen:"#98fb98",red:"#ff0000",yellow:"#ffff00",slateblue:"#6a5acd",lavenderblush:"#fff0f5",peru:"#cd853f",palevioletred:"#db7093",violet:"#ee82ee",teal:"#008080",slategray:"#708090",slategrey:"#708090",aliceblue:"#f0f8ff",darkseagreen:"#8fbc8f",darkolivegreen:"#556b2f",greenyellow:"#adff2f",seagreen:"#2e8b57",seashell:"#fff5ee",tomato:"#ff6347",silver:"#c0c0c0",sienna:"#a0522d",lavender:"#e6e6fa",lightgreen:"#90ee90",orange:"#ffa500",orangered:"#ff4500",steelblue:"#4682b4",royalblue:"#4169e1",turquoise:"#40e0d0",yellowgreen:"#9acd32",salmon:"#fa8072",saddlebrown:"#8b4513",sandybrown:"#f4a460",rosybrown:"#bc8f8f",darksalmon:"#e9967a",lightgoldenrodyellow:"#fafad2",snow:"#fffafa",lightgrey:"#d3d3d3",lightgray:"#d3d3d3",dimgray:"#696969",dimgrey:"#696969",olivedrab:"#6b8e23",olive:"#808000"},r={};for(var d in a)r[a[d]]=d;var l={};e.prototype.toName=function(f){if(!(this.rgba.a||this.rgba.r||this.rgba.g||this.rgba.b))return"transparent";var d,i,n=r[this.toHex()];if(n)return n;if(null==f?void 0:f.closest){var o=this.toRgb(),t=1/0,b="black";if(!l.length)for(var c in a)l[c]=new e(a[c]).toRgb();for(var g in a){var u=(d=o,i=l[g],Math.pow(d.r-i.r,2)+Math.pow(d.g-i.g,2)+Math.pow(d.b-i.b,2));u<t&&(t=u,b=g)}return b}};f.string.push([function(f){var r=f.toLowerCase(),d="transparent"===r?"#0000":a[r];return d?new e(d).toRgb():null},"name"])}
25972  
25973  ;// ./node_modules/colord/plugins/a11y.mjs
25974  var a11y_o=function(o){var t=o/255;return t<.04045?t/12.92:Math.pow((t+.055)/1.055,2.4)},a11y_t=function(t){return.2126*a11y_o(t.r)+.7152*a11y_o(t.g)+.0722*a11y_o(t.b)};/* harmony default export */ function a11y(o){o.prototype.luminance=function(){return o=a11y_t(this.rgba),void 0===(r=2)&&(r=0),void 0===n&&(n=Math.pow(10,r)),Math.round(n*o)/n+0;var o,r,n},o.prototype.contrast=function(r){void 0===r&&(r="#FFF");var n,a,i,e,v,u,d,c=r instanceof o?r:new o(r);return e=this.rgba,v=c.toRgb(),u=a11y_t(e),d=a11y_t(v),n=u>d?(u+.05)/(d+.05):(d+.05)/(u+.05),void 0===(a=2)&&(a=0),void 0===i&&(i=Math.pow(10,a)),Math.floor(i*n)/i+0},o.prototype.isReadable=function(o,t){return void 0===o&&(o="#FFF"),void 0===t&&(t={}),this.contrast(o)>=(e=void 0===(i=(r=t).size)?"normal":i,"AAA"===(a=void 0===(n=r.level)?"AA":n)&&"normal"===e?7:"AA"===a&&"large"===e?3:4.5);var r,n,a,i,e}}
25975  
25976  ;// ./node_modules/@wordpress/block-editor/build-module/components/colors/utils.js
25977  /**
25978   * External dependencies
25979   */
25980  
25981  
25982  
25983  
25984  /**
25985   * WordPress dependencies
25986   */
25987  
25988  
25989  /**
25990   * Internal dependencies
25991   */
25992  
25993  k([names, a11y]);
25994  const {
25995    kebabCase
25996  } = unlock(external_wp_components_namespaceObject.privateApis);
25997  
25998  /**
25999   * Provided an array of color objects as set by the theme or by the editor defaults,
26000   * and the values of the defined color or custom color returns a color object describing the color.
26001   *
26002   * @param {Array}   colors       Array of color objects as set by the theme or by the editor defaults.
26003   * @param {?string} definedColor A string containing the color slug.
26004   * @param {?string} customColor  A string containing the customColor value.
26005   *
26006   * @return {?Object} If definedColor is passed and the name is found in colors,
26007   *                   the color object exactly as set by the theme or editor defaults is returned.
26008   *                   Otherwise, an object that just sets the color is defined.
26009   */
26010  const getColorObjectByAttributeValues = (colors, definedColor, customColor) => {
26011    if (definedColor) {
26012      const colorObj = colors?.find(color => color.slug === definedColor);
26013      if (colorObj) {
26014        return colorObj;
26015      }
26016    }
26017    return {
26018      color: customColor
26019    };
26020  };
26021  
26022  /**
26023   * Provided an array of color objects as set by the theme or by the editor defaults, and a color value returns the color object matching that value or undefined.
26024   *
26025   * @param {Array}   colors     Array of color objects as set by the theme or by the editor defaults.
26026   * @param {?string} colorValue A string containing the color value.
26027   *
26028   * @return {?Object} Color object included in the colors array whose color property equals colorValue.
26029   *                   Returns undefined if no color object matches this requirement.
26030   */
26031  const getColorObjectByColorValue = (colors, colorValue) => {
26032    return colors?.find(color => color.color === colorValue);
26033  };
26034  
26035  /**
26036   * Returns a class based on the context a color is being used and its slug.
26037   *
26038   * @param {string} colorContextName Context/place where color is being used e.g: background, text etc...
26039   * @param {string} colorSlug        Slug of the color.
26040   *
26041   * @return {?string} String with the class corresponding to the color in the provided context.
26042   *                   Returns undefined if either colorContextName or colorSlug are not provided.
26043   */
26044  function getColorClassName(colorContextName, colorSlug) {
26045    if (!colorContextName || !colorSlug) {
26046      return undefined;
26047    }
26048    return `has-$kebabCase(colorSlug)}-$colorContextName}`;
26049  }
26050  
26051  /**
26052   * Given an array of color objects and a color value returns the color value of the most readable color in the array.
26053   *
26054   * @param {Array}   colors     Array of color objects as set by the theme or by the editor defaults.
26055   * @param {?string} colorValue A string containing the color value.
26056   *
26057   * @return {string} String with the color value of the most readable color.
26058   */
26059  function getMostReadableColor(colors, colorValue) {
26060    const colordColor = w(colorValue);
26061    const getColorContrast = ({
26062      color
26063    }) => colordColor.contrast(color);
26064    const maxContrast = Math.max(...colors.map(getColorContrast));
26065    return colors.find(color => getColorContrast(color) === maxContrast).color;
26066  }
26067  
26068  ;// ./node_modules/@wordpress/block-editor/build-module/components/colors-gradients/use-multiple-origin-colors-and-gradients.js
26069  /**
26070   * WordPress dependencies
26071   */
26072  
26073  
26074  
26075  /**
26076   * Internal dependencies
26077   */
26078  
26079  
26080  /**
26081   * Retrieves color and gradient related settings.
26082   *
26083   * The arrays for colors and gradients are made up of color palettes from each
26084   * origin i.e. "Core", "Theme", and "User".
26085   *
26086   * @return {Object} Color and gradient related settings.
26087   */
26088  function useMultipleOriginColorsAndGradients() {
26089    const [enableCustomColors, customColors, themeColors, defaultColors, shouldDisplayDefaultColors, enableCustomGradients, customGradients, themeGradients, defaultGradients, shouldDisplayDefaultGradients] = use_settings_useSettings('color.custom', 'color.palette.custom', 'color.palette.theme', 'color.palette.default', 'color.defaultPalette', 'color.customGradient', 'color.gradients.custom', 'color.gradients.theme', 'color.gradients.default', 'color.defaultGradients');
26090    const colorGradientSettings = {
26091      disableCustomColors: !enableCustomColors,
26092      disableCustomGradients: !enableCustomGradients
26093    };
26094    colorGradientSettings.colors = (0,external_wp_element_namespaceObject.useMemo)(() => {
26095      const result = [];
26096      if (themeColors && themeColors.length) {
26097        result.push({
26098          name: (0,external_wp_i18n_namespaceObject._x)('Theme', 'Indicates this palette comes from the theme.'),
26099          slug: 'theme',
26100          colors: themeColors
26101        });
26102      }
26103      if (shouldDisplayDefaultColors && defaultColors && defaultColors.length) {
26104        result.push({
26105          name: (0,external_wp_i18n_namespaceObject._x)('Default', 'Indicates this palette comes from WordPress.'),
26106          slug: 'default',
26107          colors: defaultColors
26108        });
26109      }
26110      if (customColors && customColors.length) {
26111        result.push({
26112          name: (0,external_wp_i18n_namespaceObject._x)('Custom', 'Indicates this palette is created by the user.'),
26113          slug: 'custom',
26114          colors: customColors
26115        });
26116      }
26117      return result;
26118    }, [customColors, themeColors, defaultColors, shouldDisplayDefaultColors]);
26119    colorGradientSettings.gradients = (0,external_wp_element_namespaceObject.useMemo)(() => {
26120      const result = [];
26121      if (themeGradients && themeGradients.length) {
26122        result.push({
26123          name: (0,external_wp_i18n_namespaceObject._x)('Theme', 'Indicates this palette comes from the theme.'),
26124          slug: 'theme',
26125          gradients: themeGradients
26126        });
26127      }
26128      if (shouldDisplayDefaultGradients && defaultGradients && defaultGradients.length) {
26129        result.push({
26130          name: (0,external_wp_i18n_namespaceObject._x)('Default', 'Indicates this palette comes from WordPress.'),
26131          slug: 'default',
26132          gradients: defaultGradients
26133        });
26134      }
26135      if (customGradients && customGradients.length) {
26136        result.push({
26137          name: (0,external_wp_i18n_namespaceObject._x)('Custom', 'Indicates this palette is created by the user.'),
26138          slug: 'custom',
26139          gradients: customGradients
26140        });
26141      }
26142      return result;
26143    }, [customGradients, themeGradients, defaultGradients, shouldDisplayDefaultGradients]);
26144    colorGradientSettings.hasColorsOrGradients = !!colorGradientSettings.colors.length || !!colorGradientSettings.gradients.length;
26145    return colorGradientSettings;
26146  }
26147  
26148  ;// ./node_modules/@wordpress/block-editor/build-module/components/border-radius-control/utils.js
26149  /**
26150   * WordPress dependencies
26151   */
26152  
26153  
26154  /**
26155   * Gets the (non-undefined) item with the highest occurrence within an array
26156   * Based in part on: https://stackoverflow.com/a/20762713
26157   *
26158   * Undefined values are always sorted to the end by `sort`, so this function
26159   * returns the first element, to always prioritize real values over undefined
26160   * values.
26161   *
26162   * See: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort#description
26163   *
26164   * @param {Array<any>} inputArray Array of items to check.
26165   * @return {any}                  The item with the most occurrences.
26166   */
26167  function mode(inputArray) {
26168    const arr = [...inputArray];
26169    return arr.sort((a, b) => inputArray.filter(v => v === b).length - inputArray.filter(v => v === a).length).shift();
26170  }
26171  
26172  /**
26173   * Returns the most common CSS unit from the current CSS unit selections.
26174   *
26175   * - If a single flat border radius is set, its unit will be used
26176   * - If individual corner selections, the most common of those will be used
26177   * - Failing any unit selections a default of 'px' is returned.
26178   *
26179   * @param {Object} selectedUnits Unit selections for flat radius & each corner.
26180   * @return {string} Most common CSS unit from current selections. Default: `px`.
26181   */
26182  function getAllUnit(selectedUnits = {}) {
26183    const {
26184      flat,
26185      ...cornerUnits
26186    } = selectedUnits;
26187    return flat || mode(Object.values(cornerUnits).filter(Boolean)) || 'px';
26188  }
26189  
26190  /**
26191   * Gets the 'all' input value and unit from values data.
26192   *
26193   * @param {Object|string} values Radius values.
26194   * @return {string}              A value + unit for the 'all' input.
26195   */
26196  function getAllValue(values = {}) {
26197    /**
26198     * Border radius support was originally a single pixel value.
26199     *
26200     * To maintain backwards compatibility treat this case as the all value.
26201     */
26202    if (typeof values === 'string') {
26203      return values;
26204    }
26205    const parsedQuantitiesAndUnits = Object.values(values).map(value => (0,external_wp_components_namespaceObject.__experimentalParseQuantityAndUnitFromRawValue)(value));
26206    const allValues = parsedQuantitiesAndUnits.map(value => {
26207      var _value$;
26208      return (_value$ = value[0]) !== null && _value$ !== void 0 ? _value$ : '';
26209    });
26210    const allUnits = parsedQuantitiesAndUnits.map(value => value[1]);
26211    const value = allValues.every(v => v === allValues[0]) ? allValues[0] : '';
26212    const unit = mode(allUnits);
26213    const allValue = value === 0 || value ? `$value}$unit}` : undefined;
26214    return allValue;
26215  }
26216  
26217  /**
26218   * Checks to determine if values are mixed.
26219   *
26220   * @param {Object} values Radius values.
26221   * @return {boolean}      Whether values are mixed.
26222   */
26223  function hasMixedValues(values = {}) {
26224    const allValue = getAllValue(values);
26225    const isMixed = typeof values === 'string' ? false : isNaN(parseFloat(allValue));
26226    return isMixed;
26227  }
26228  
26229  /**
26230   * Checks to determine if values are defined.
26231   *
26232   * @param {Object} values Radius values.
26233   * @return {boolean}      Whether values are mixed.
26234   */
26235  function hasDefinedValues(values) {
26236    if (!values) {
26237      return false;
26238    }
26239  
26240    // A string value represents a shorthand value.
26241    if (typeof values === 'string') {
26242      return true;
26243    }
26244  
26245    // An object represents longhand border radius values, if any are set
26246    // flag values as being defined.
26247    const filteredValues = Object.values(values).filter(value => {
26248      return !!value || value === 0;
26249    });
26250    return !!filteredValues.length;
26251  }
26252  
26253  ;// ./node_modules/@wordpress/block-editor/build-module/components/border-radius-control/all-input-control.js
26254  /**
26255   * WordPress dependencies
26256   */
26257  
26258  
26259  
26260  /**
26261   * Internal dependencies
26262   */
26263  
26264  
26265  function AllInputControl({
26266    onChange,
26267    selectedUnits,
26268    setSelectedUnits,
26269    values,
26270    ...props
26271  }) {
26272    let allValue = getAllValue(values);
26273    if (allValue === undefined) {
26274      // If we don't have any value set the unit to any current selection
26275      // or the most common unit from the individual radii values.
26276      allValue = getAllUnit(selectedUnits);
26277    }
26278    const hasValues = hasDefinedValues(values);
26279    const isMixed = hasValues && hasMixedValues(values);
26280    const allPlaceholder = isMixed ? (0,external_wp_i18n_namespaceObject.__)('Mixed') : null;
26281  
26282    // Filter out CSS-unit-only values to prevent invalid styles.
26283    const handleOnChange = next => {
26284      const isNumeric = !isNaN(parseFloat(next));
26285      const nextValue = isNumeric ? next : undefined;
26286      onChange(nextValue);
26287    };
26288  
26289    // Store current unit selection for use as fallback for individual
26290    // radii controls.
26291    const handleOnUnitChange = unit => {
26292      setSelectedUnits({
26293        topLeft: unit,
26294        topRight: unit,
26295        bottomLeft: unit,
26296        bottomRight: unit
26297      });
26298    };
26299    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalUnitControl, {
26300      ...props,
26301      "aria-label": (0,external_wp_i18n_namespaceObject.__)('Border radius'),
26302      disableUnits: isMixed,
26303      isOnly: true,
26304      value: allValue,
26305      onChange: handleOnChange,
26306      onUnitChange: handleOnUnitChange,
26307      placeholder: allPlaceholder,
26308      size: "__unstable-large"
26309    });
26310  }
26311  
26312  ;// ./node_modules/@wordpress/block-editor/build-module/components/border-radius-control/input-controls.js
26313  /**
26314   * WordPress dependencies
26315   */
26316  
26317  
26318  
26319  const CORNERS = {
26320    topLeft: (0,external_wp_i18n_namespaceObject.__)('Top left'),
26321    topRight: (0,external_wp_i18n_namespaceObject.__)('Top right'),
26322    bottomLeft: (0,external_wp_i18n_namespaceObject.__)('Bottom left'),
26323    bottomRight: (0,external_wp_i18n_namespaceObject.__)('Bottom right')
26324  };
26325  function BoxInputControls({
26326    onChange,
26327    selectedUnits,
26328    setSelectedUnits,
26329    values: valuesProp,
26330    ...props
26331  }) {
26332    const createHandleOnChange = corner => next => {
26333      if (!onChange) {
26334        return;
26335      }
26336  
26337      // Filter out CSS-unit-only values to prevent invalid styles.
26338      const isNumeric = !isNaN(parseFloat(next));
26339      const nextValue = isNumeric ? next : undefined;
26340      onChange({
26341        ...values,
26342        [corner]: nextValue
26343      });
26344    };
26345    const createHandleOnUnitChange = side => next => {
26346      const newUnits = {
26347        ...selectedUnits
26348      };
26349      newUnits[side] = next;
26350      setSelectedUnits(newUnits);
26351    };
26352  
26353    // For shorthand style & backwards compatibility, handle flat string value.
26354    const values = typeof valuesProp !== 'string' ? valuesProp : {
26355      topLeft: valuesProp,
26356      topRight: valuesProp,
26357      bottomLeft: valuesProp,
26358      bottomRight: valuesProp
26359    };
26360  
26361    // Controls are wrapped in tooltips as visible labels aren't desired here.
26362    // Tooltip rendering also requires the UnitControl to be wrapped. See:
26363    // https://github.com/WordPress/gutenberg/pull/24966#issuecomment-685875026
26364    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
26365      className: "components-border-radius-control__input-controls-wrapper",
26366      children: Object.entries(CORNERS).map(([corner, label]) => {
26367        const [parsedQuantity, parsedUnit] = (0,external_wp_components_namespaceObject.__experimentalParseQuantityAndUnitFromRawValue)(values[corner]);
26368        const computedUnit = values[corner] ? parsedUnit : selectedUnits[corner] || selectedUnits.flat;
26369        return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Tooltip, {
26370          text: label,
26371          placement: "top",
26372          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
26373            className: "components-border-radius-control__tooltip-wrapper",
26374            children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalUnitControl, {
26375              ...props,
26376              "aria-label": label,
26377              value: [parsedQuantity, computedUnit].join(''),
26378              onChange: createHandleOnChange(corner),
26379              onUnitChange: createHandleOnUnitChange(corner),
26380              size: "__unstable-large"
26381            })
26382          })
26383        }, corner);
26384      })
26385    });
26386  }
26387  
26388  ;// ./node_modules/@wordpress/icons/build-module/library/link.js
26389  /**
26390   * WordPress dependencies
26391   */
26392  
26393  
26394  const link_link = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
26395    xmlns: "http://www.w3.org/2000/svg",
26396    viewBox: "0 0 24 24",
26397    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
26398      d: "M10 17.389H8.444A5.194 5.194 0 1 1 8.444 7H10v1.5H8.444a3.694 3.694 0 0 0 0 7.389H10v1.5ZM14 7h1.556a5.194 5.194 0 0 1 0 10.39H14v-1.5h1.556a3.694 3.694 0 0 0 0-7.39H14V7Zm-4.5 6h5v-1.5h-5V13Z"
26399    })
26400  });
26401  /* harmony default export */ const library_link = (link_link);
26402  
26403  ;// ./node_modules/@wordpress/block-editor/build-module/components/border-radius-control/linked-button.js
26404  /**
26405   * WordPress dependencies
26406   */
26407  
26408  
26409  
26410  
26411  function LinkedButton({
26412    isLinked,
26413    ...props
26414  }) {
26415    const label = isLinked ? (0,external_wp_i18n_namespaceObject.__)('Unlink radii') : (0,external_wp_i18n_namespaceObject.__)('Link radii');
26416    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
26417      ...props,
26418      className: "component-border-radius-control__linked-button",
26419      size: "small",
26420      icon: isLinked ? library_link : link_off,
26421      iconSize: 24,
26422      label: label
26423    });
26424  }
26425  
26426  ;// ./node_modules/@wordpress/block-editor/build-module/components/border-radius-control/index.js
26427  /**
26428   * WordPress dependencies
26429   */
26430  
26431  
26432  
26433  
26434  /**
26435   * Internal dependencies
26436   */
26437  
26438  
26439  
26440  
26441  
26442  
26443  const border_radius_control_DEFAULT_VALUES = {
26444    topLeft: undefined,
26445    topRight: undefined,
26446    bottomLeft: undefined,
26447    bottomRight: undefined
26448  };
26449  const MIN_BORDER_RADIUS_VALUE = 0;
26450  const MAX_BORDER_RADIUS_VALUES = {
26451    px: 100,
26452    em: 20,
26453    rem: 20
26454  };
26455  
26456  /**
26457   * Control to display border radius options.
26458   *
26459   * @param {Object}   props          Component props.
26460   * @param {Function} props.onChange Callback to handle onChange.
26461   * @param {Object}   props.values   Border radius values.
26462   *
26463   * @return {Element}              Custom border radius control.
26464   */
26465  function BorderRadiusControl({
26466    onChange,
26467    values
26468  }) {
26469    const [isLinked, setIsLinked] = (0,external_wp_element_namespaceObject.useState)(!hasDefinedValues(values) || !hasMixedValues(values));
26470  
26471    // Tracking selected units via internal state allows filtering of CSS unit
26472    // only values from being saved while maintaining preexisting unit selection
26473    // behaviour. Filtering CSS unit only values prevents invalid style values.
26474    const [selectedUnits, setSelectedUnits] = (0,external_wp_element_namespaceObject.useState)({
26475      flat: typeof values === 'string' ? (0,external_wp_components_namespaceObject.__experimentalParseQuantityAndUnitFromRawValue)(values)[1] : undefined,
26476      topLeft: (0,external_wp_components_namespaceObject.__experimentalParseQuantityAndUnitFromRawValue)(values?.topLeft)[1],
26477      topRight: (0,external_wp_components_namespaceObject.__experimentalParseQuantityAndUnitFromRawValue)(values?.topRight)[1],
26478      bottomLeft: (0,external_wp_components_namespaceObject.__experimentalParseQuantityAndUnitFromRawValue)(values?.bottomLeft)[1],
26479      bottomRight: (0,external_wp_components_namespaceObject.__experimentalParseQuantityAndUnitFromRawValue)(values?.bottomRight)[1]
26480    });
26481    const [availableUnits] = use_settings_useSettings('spacing.units');
26482    const units = (0,external_wp_components_namespaceObject.__experimentalUseCustomUnits)({
26483      availableUnits: availableUnits || ['px', 'em', 'rem']
26484    });
26485    const unit = getAllUnit(selectedUnits);
26486    const unitConfig = units && units.find(item => item.value === unit);
26487    const step = unitConfig?.step || 1;
26488    const [allValue] = (0,external_wp_components_namespaceObject.__experimentalParseQuantityAndUnitFromRawValue)(getAllValue(values));
26489    const toggleLinked = () => setIsLinked(!isLinked);
26490    const handleSliderChange = next => {
26491      onChange(next !== undefined ? `$next}$unit}` : undefined);
26492    };
26493    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("fieldset", {
26494      className: "components-border-radius-control",
26495      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.BaseControl.VisualLabel, {
26496        as: "legend",
26497        children: (0,external_wp_i18n_namespaceObject.__)('Radius')
26498      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
26499        className: "components-border-radius-control__wrapper",
26500        children: [isLinked ? /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
26501          children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(AllInputControl, {
26502            className: "components-border-radius-control__unit-control",
26503            values: values,
26504            min: MIN_BORDER_RADIUS_VALUE,
26505            onChange: onChange,
26506            selectedUnits: selectedUnits,
26507            setSelectedUnits: setSelectedUnits,
26508            units: units
26509          }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.RangeControl, {
26510            __next40pxDefaultSize: true,
26511            label: (0,external_wp_i18n_namespaceObject.__)('Border radius'),
26512            hideLabelFromVision: true,
26513            className: "components-border-radius-control__range-control",
26514            value: allValue !== null && allValue !== void 0 ? allValue : '',
26515            min: MIN_BORDER_RADIUS_VALUE,
26516            max: MAX_BORDER_RADIUS_VALUES[unit],
26517            initialPosition: 0,
26518            withInputField: false,
26519            onChange: handleSliderChange,
26520            step: step,
26521            __nextHasNoMarginBottom: true
26522          })]
26523        }) : /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BoxInputControls, {
26524          min: MIN_BORDER_RADIUS_VALUE,
26525          onChange: onChange,
26526          selectedUnits: selectedUnits,
26527          setSelectedUnits: setSelectedUnits,
26528          values: values || border_radius_control_DEFAULT_VALUES,
26529          units: units
26530        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(LinkedButton, {
26531          onClick: toggleLinked,
26532          isLinked: isLinked
26533        })]
26534      })]
26535    });
26536  }
26537  
26538  ;// ./node_modules/@wordpress/icons/build-module/library/check.js
26539  /**
26540   * WordPress dependencies
26541   */
26542  
26543  
26544  const check_check = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
26545    xmlns: "http://www.w3.org/2000/svg",
26546    viewBox: "0 0 24 24",
26547    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
26548      d: "M16.7 7.1l-6.3 8.5-3.3-2.5-.9 1.2 4.5 3.4L17.9 8z"
26549    })
26550  });
26551  /* harmony default export */ const library_check = (check_check);
26552  
26553  ;// ./node_modules/@wordpress/icons/build-module/library/shadow.js
26554  /**
26555   * WordPress dependencies
26556   */
26557  
26558  
26559  const shadow = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
26560    viewBox: "0 0 24 24",
26561    xmlns: "http://www.w3.org/2000/svg",
26562    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
26563      d: "M12 8c-2.2 0-4 1.8-4 4s1.8 4 4 4 4-1.8 4-4-1.8-4-4-4zm0 6.5c-1.4 0-2.5-1.1-2.5-2.5s1.1-2.5 2.5-2.5 2.5 1.1 2.5 2.5-1.1 2.5-2.5 2.5zM12.8 3h-1.5v3h1.5V3zm-1.6 18h1.5v-3h-1.5v3zm6.8-9.8v1.5h3v-1.5h-3zm-12 0H3v1.5h3v-1.5zm9.7 5.6 2.1 2.1 1.1-1.1-2.1-2.1-1.1 1.1zM8.3 7.2 6.2 5.1 5.1 6.2l2.1 2.1 1.1-1.1zM5.1 17.8l1.1 1.1 2.1-2.1-1.1-1.1-2.1 2.1zM18.9 6.2l-1.1-1.1-2.1 2.1 1.1 1.1 2.1-2.1z"
26564    })
26565  });
26566  /* harmony default export */ const library_shadow = (shadow);
26567  
26568  ;// ./node_modules/@wordpress/icons/build-module/library/reset.js
26569  /**
26570   * WordPress dependencies
26571   */
26572  
26573  
26574  const reset_reset = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
26575    xmlns: "http://www.w3.org/2000/svg",
26576    viewBox: "0 0 24 24",
26577    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
26578      d: "M7 11.5h10V13H7z"
26579    })
26580  });
26581  /* harmony default export */ const library_reset = (reset_reset);
26582  
26583  ;// ./node_modules/@wordpress/block-editor/build-module/components/global-styles/shadow-panel-components.js
26584  /**
26585   * WordPress dependencies
26586   */
26587  
26588  
26589  
26590  
26591  
26592  /**
26593   * External dependencies
26594   */
26595  
26596  
26597  /**
26598   * Shared reference to an empty array for cases where it is important to avoid
26599   * returning a new array reference on every invocation.
26600   *
26601   * @type {Array}
26602   */
26603  
26604  const shadow_panel_components_EMPTY_ARRAY = [];
26605  function ShadowPopoverContainer({
26606    shadow,
26607    onShadowChange,
26608    settings
26609  }) {
26610    const shadows = useShadowPresets(settings);
26611    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
26612      className: "block-editor-global-styles__shadow-popover-container",
26613      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalVStack, {
26614        spacing: 4,
26615        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalHeading, {
26616          level: 5,
26617          children: (0,external_wp_i18n_namespaceObject.__)('Drop shadow')
26618        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ShadowPresets, {
26619          presets: shadows,
26620          activeShadow: shadow,
26621          onSelect: onShadowChange
26622        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
26623          className: "block-editor-global-styles__clear-shadow",
26624          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
26625            __next40pxDefaultSize: true,
26626            variant: "tertiary",
26627            onClick: () => onShadowChange(undefined),
26628            disabled: !shadow,
26629            accessibleWhenDisabled: true,
26630            children: (0,external_wp_i18n_namespaceObject.__)('Clear')
26631          })
26632        })]
26633      })
26634    });
26635  }
26636  function ShadowPresets({
26637    presets,
26638    activeShadow,
26639    onSelect
26640  }) {
26641    return !presets ? null : /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Composite, {
26642      role: "listbox",
26643      className: "block-editor-global-styles__shadow__list",
26644      "aria-label": (0,external_wp_i18n_namespaceObject.__)('Drop shadows'),
26645      children: presets.map(({
26646        name,
26647        slug,
26648        shadow
26649      }) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ShadowIndicator, {
26650        label: name,
26651        isActive: shadow === activeShadow,
26652        type: slug === 'unset' ? 'unset' : 'preset',
26653        onSelect: () => onSelect(shadow === activeShadow ? undefined : shadow),
26654        shadow: shadow
26655      }, slug))
26656    });
26657  }
26658  function ShadowIndicator({
26659    type,
26660    label,
26661    isActive,
26662    onSelect,
26663    shadow
26664  }) {
26665    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Tooltip, {
26666      text: label,
26667      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Composite.Item, {
26668        role: "option",
26669        "aria-label": label,
26670        "aria-selected": isActive,
26671        className: dist_clsx('block-editor-global-styles__shadow__item', {
26672          'is-active': isActive
26673        }),
26674        render: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("button", {
26675          className: dist_clsx('block-editor-global-styles__shadow-indicator', {
26676            unset: type === 'unset'
26677          }),
26678          onClick: onSelect,
26679          style: {
26680            boxShadow: shadow
26681          },
26682          "aria-label": label,
26683          children: isActive && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(build_module_icon, {
26684            icon: library_check
26685          })
26686        })
26687      })
26688    });
26689  }
26690  function ShadowPopover({
26691    shadow,
26692    onShadowChange,
26693    settings
26694  }) {
26695    const popoverProps = {
26696      placement: 'left-start',
26697      offset: 36,
26698      shift: true
26699    };
26700    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Dropdown, {
26701      popoverProps: popoverProps,
26702      className: "block-editor-global-styles__shadow-dropdown",
26703      renderToggle: renderShadowToggle(shadow, onShadowChange),
26704      renderContent: () => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalDropdownContentWrapper, {
26705        paddingSize: "medium",
26706        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ShadowPopoverContainer, {
26707          shadow: shadow,
26708          onShadowChange: onShadowChange,
26709          settings: settings
26710        })
26711      })
26712    });
26713  }
26714  function renderShadowToggle(shadow, onShadowChange) {
26715    return ({
26716      onToggle,
26717      isOpen
26718    }) => {
26719      const shadowButtonRef = (0,external_wp_element_namespaceObject.useRef)(undefined);
26720      const toggleProps = {
26721        onClick: onToggle,
26722        className: dist_clsx({
26723          'is-open': isOpen
26724        }),
26725        'aria-expanded': isOpen,
26726        ref: shadowButtonRef
26727      };
26728      const removeButtonProps = {
26729        onClick: () => {
26730          if (isOpen) {
26731            onToggle();
26732          }
26733          onShadowChange(undefined);
26734          // Return focus to parent button.
26735          shadowButtonRef.current?.focus();
26736        },
26737        className: dist_clsx('block-editor-global-styles__shadow-editor__remove-button', {
26738          'is-open': isOpen
26739        }),
26740        label: (0,external_wp_i18n_namespaceObject.__)('Remove')
26741      };
26742      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
26743        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
26744          __next40pxDefaultSize: true,
26745          ...toggleProps,
26746          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalHStack, {
26747            justify: "flex-start",
26748            children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(build_module_icon, {
26749              className: "block-editor-global-styles__toggle-icon",
26750              icon: library_shadow,
26751              size: 24
26752            }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FlexItem, {
26753              children: (0,external_wp_i18n_namespaceObject.__)('Drop shadow')
26754            })]
26755          })
26756        }), !!shadow && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
26757          __next40pxDefaultSize: true,
26758          size: "small",
26759          icon: library_reset,
26760          ...removeButtonProps
26761        })]
26762      });
26763    };
26764  }
26765  function useShadowPresets(settings) {
26766    return (0,external_wp_element_namespaceObject.useMemo)(() => {
26767      var _settings$shadow$pres;
26768      if (!settings?.shadow) {
26769        return shadow_panel_components_EMPTY_ARRAY;
26770      }
26771      const defaultPresetsEnabled = settings?.shadow?.defaultPresets;
26772      const {
26773        default: defaultShadows,
26774        theme: themeShadows,
26775        custom: customShadows
26776      } = (_settings$shadow$pres = settings?.shadow?.presets) !== null && _settings$shadow$pres !== void 0 ? _settings$shadow$pres : {};
26777      const unsetShadow = {
26778        name: (0,external_wp_i18n_namespaceObject.__)('Unset'),
26779        slug: 'unset',
26780        shadow: 'none'
26781      };
26782      const shadowPresets = [...(defaultPresetsEnabled && defaultShadows || shadow_panel_components_EMPTY_ARRAY), ...(themeShadows || shadow_panel_components_EMPTY_ARRAY), ...(customShadows || shadow_panel_components_EMPTY_ARRAY)];
26783      if (shadowPresets.length) {
26784        shadowPresets.unshift(unsetShadow);
26785      }
26786      return shadowPresets;
26787    }, [settings]);
26788  }
26789  
26790  ;// ./node_modules/@wordpress/block-editor/build-module/components/global-styles/border-panel.js
26791  /**
26792   * WordPress dependencies
26793   */
26794  
26795  
26796  
26797  
26798  /**
26799   * Internal dependencies
26800   */
26801  
26802  
26803  
26804  
26805  
26806  
26807  
26808  function useHasBorderPanel(settings) {
26809    const controls = Object.values(useHasBorderPanelControls(settings));
26810    return controls.some(Boolean);
26811  }
26812  function useHasBorderPanelControls(settings) {
26813    const controls = {
26814      hasBorderColor: useHasBorderColorControl(settings),
26815      hasBorderRadius: useHasBorderRadiusControl(settings),
26816      hasBorderStyle: useHasBorderStyleControl(settings),
26817      hasBorderWidth: useHasBorderWidthControl(settings),
26818      hasShadow: useHasShadowControl(settings)
26819    };
26820    return controls;
26821  }
26822  function useHasBorderColorControl(settings) {
26823    return settings?.border?.color;
26824  }
26825  function useHasBorderRadiusControl(settings) {
26826    return settings?.border?.radius;
26827  }
26828  function useHasBorderStyleControl(settings) {
26829    return settings?.border?.style;
26830  }
26831  function useHasBorderWidthControl(settings) {
26832    return settings?.border?.width;
26833  }
26834  function useHasShadowControl(settings) {
26835    const shadows = useShadowPresets(settings);
26836    return !!settings?.shadow && shadows.length > 0;
26837  }
26838  function BorderToolsPanel({
26839    resetAllFilter,
26840    onChange,
26841    value,
26842    panelId,
26843    children,
26844    label
26845  }) {
26846    const dropdownMenuProps = useToolsPanelDropdownMenuProps();
26847    const resetAll = () => {
26848      const updatedValue = resetAllFilter(value);
26849      onChange(updatedValue);
26850    };
26851    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanel, {
26852      label: label,
26853      resetAll: resetAll,
26854      panelId: panelId,
26855      dropdownMenuProps: dropdownMenuProps,
26856      children: children
26857    });
26858  }
26859  const border_panel_DEFAULT_CONTROLS = {
26860    radius: true,
26861    color: true,
26862    width: true,
26863    shadow: true
26864  };
26865  function BorderPanel({
26866    as: Wrapper = BorderToolsPanel,
26867    value,
26868    onChange,
26869    inheritedValue = value,
26870    settings,
26871    panelId,
26872    name,
26873    defaultControls = border_panel_DEFAULT_CONTROLS
26874  }) {
26875    var _settings$shadow$pres, _ref, _ref2, _shadowPresets$custom;
26876    const colors = useColorsPerOrigin(settings);
26877    const decodeValue = (0,external_wp_element_namespaceObject.useCallback)(rawValue => getValueFromVariable({
26878      settings
26879    }, '', rawValue), [settings]);
26880    const encodeColorValue = colorValue => {
26881      const allColors = colors.flatMap(({
26882        colors: originColors
26883      }) => originColors);
26884      const colorObject = allColors.find(({
26885        color
26886      }) => color === colorValue);
26887      return colorObject ? 'var:preset|color|' + colorObject.slug : colorValue;
26888    };
26889    const border = (0,external_wp_element_namespaceObject.useMemo)(() => {
26890      if ((0,external_wp_components_namespaceObject.__experimentalHasSplitBorders)(inheritedValue?.border)) {
26891        const borderValue = {
26892          ...inheritedValue?.border
26893        };
26894        ['top', 'right', 'bottom', 'left'].forEach(side => {
26895          borderValue[side] = {
26896            ...borderValue[side],
26897            color: decodeValue(borderValue[side]?.color)
26898          };
26899        });
26900        return borderValue;
26901      }
26902      return {
26903        ...inheritedValue?.border,
26904        color: inheritedValue?.border?.color ? decodeValue(inheritedValue?.border?.color) : undefined
26905      };
26906    }, [inheritedValue?.border, decodeValue]);
26907    const setBorder = newBorder => onChange({
26908      ...value,
26909      border: newBorder
26910    });
26911    const showBorderColor = useHasBorderColorControl(settings);
26912    const showBorderStyle = useHasBorderStyleControl(settings);
26913    const showBorderWidth = useHasBorderWidthControl(settings);
26914  
26915    // Border radius.
26916    const showBorderRadius = useHasBorderRadiusControl(settings);
26917    const borderRadiusValues = decodeValue(border?.radius);
26918    const setBorderRadius = newBorderRadius => setBorder({
26919      ...border,
26920      radius: newBorderRadius
26921    });
26922    const hasBorderRadius = () => {
26923      const borderValues = value?.border?.radius;
26924      if (typeof borderValues === 'object') {
26925        return Object.entries(borderValues).some(Boolean);
26926      }
26927      return !!borderValues;
26928    };
26929    const hasShadowControl = useHasShadowControl(settings);
26930  
26931    // Shadow
26932    const shadow = decodeValue(inheritedValue?.shadow);
26933    const shadowPresets = (_settings$shadow$pres = settings?.shadow?.presets) !== null && _settings$shadow$pres !== void 0 ? _settings$shadow$pres : {};
26934    const mergedShadowPresets = (_ref = (_ref2 = (_shadowPresets$custom = shadowPresets.custom) !== null && _shadowPresets$custom !== void 0 ? _shadowPresets$custom : shadowPresets.theme) !== null && _ref2 !== void 0 ? _ref2 : shadowPresets.default) !== null && _ref !== void 0 ? _ref : [];
26935    const setShadow = newValue => {
26936      const slug = mergedShadowPresets?.find(({
26937        shadow: shadowName
26938      }) => shadowName === newValue)?.slug;
26939      onChange(setImmutably(value, ['shadow'], slug ? `var:preset|shadow|$slug}` : newValue || undefined));
26940    };
26941    const hasShadow = () => !!value?.shadow;
26942    const resetShadow = () => setShadow(undefined);
26943    const resetBorder = () => {
26944      if (hasBorderRadius()) {
26945        return setBorder({
26946          radius: value?.border?.radius
26947        });
26948      }
26949      setBorder(undefined);
26950    };
26951    const onBorderChange = newBorder => {
26952      // Ensure we have a visible border style when a border width or
26953      // color is being selected.
26954      const updatedBorder = {
26955        ...newBorder
26956      };
26957      if ((0,external_wp_components_namespaceObject.__experimentalHasSplitBorders)(updatedBorder)) {
26958        ['top', 'right', 'bottom', 'left'].forEach(side => {
26959          if (updatedBorder[side]) {
26960            updatedBorder[side] = {
26961              ...updatedBorder[side],
26962              color: encodeColorValue(updatedBorder[side]?.color)
26963            };
26964          }
26965        });
26966      } else if (updatedBorder) {
26967        updatedBorder.color = encodeColorValue(updatedBorder.color);
26968      }
26969  
26970      // As radius is maintained separately to color, style, and width
26971      // maintain its value. Undefined values here will be cleaned when
26972      // global styles are saved.
26973      setBorder({
26974        radius: border?.radius,
26975        ...updatedBorder
26976      });
26977    };
26978    const resetAllFilter = (0,external_wp_element_namespaceObject.useCallback)(previousValue => {
26979      return {
26980        ...previousValue,
26981        border: undefined,
26982        shadow: undefined
26983      };
26984    }, []);
26985    const showBorderByDefault = defaultControls?.color || defaultControls?.width;
26986    const hasBorderControl = showBorderColor || showBorderStyle || showBorderWidth || showBorderRadius;
26987    const label = useBorderPanelLabel({
26988      blockName: name,
26989      hasShadowControl,
26990      hasBorderControl
26991    });
26992    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(Wrapper, {
26993      resetAllFilter: resetAllFilter,
26994      value: value,
26995      onChange: onChange,
26996      panelId: panelId,
26997      label: label,
26998      children: [(showBorderWidth || showBorderColor) && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanelItem, {
26999        hasValue: () => (0,external_wp_components_namespaceObject.__experimentalIsDefinedBorder)(value?.border),
27000        label: (0,external_wp_i18n_namespaceObject.__)('Border'),
27001        onDeselect: () => resetBorder(),
27002        isShownByDefault: showBorderByDefault,
27003        panelId: panelId,
27004        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.BorderBoxControl, {
27005          colors: colors,
27006          enableAlpha: true,
27007          enableStyle: showBorderStyle,
27008          onChange: onBorderChange,
27009          popoverOffset: 40,
27010          popoverPlacement: "left-start",
27011          value: border,
27012          __experimentalIsRenderedInSidebar: true,
27013          size: "__unstable-large",
27014          hideLabelFromVision: !hasShadowControl,
27015          label: (0,external_wp_i18n_namespaceObject.__)('Border')
27016        })
27017      }), showBorderRadius && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanelItem, {
27018        hasValue: hasBorderRadius,
27019        label: (0,external_wp_i18n_namespaceObject.__)('Radius'),
27020        onDeselect: () => setBorderRadius(undefined),
27021        isShownByDefault: defaultControls.radius,
27022        panelId: panelId,
27023        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BorderRadiusControl, {
27024          values: borderRadiusValues,
27025          onChange: newValue => {
27026            setBorderRadius(newValue || undefined);
27027          }
27028        })
27029      }), hasShadowControl && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalToolsPanelItem, {
27030        label: (0,external_wp_i18n_namespaceObject.__)('Shadow'),
27031        hasValue: hasShadow,
27032        onDeselect: resetShadow,
27033        isShownByDefault: defaultControls.shadow,
27034        panelId: panelId,
27035        children: [hasBorderControl ? /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.BaseControl.VisualLabel, {
27036          as: "legend",
27037          children: (0,external_wp_i18n_namespaceObject.__)('Shadow')
27038        }) : null, /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalItemGroup, {
27039          isBordered: true,
27040          isSeparated: true,
27041          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ShadowPopover, {
27042            shadow: shadow,
27043            onShadowChange: setShadow,
27044            settings: settings
27045          })
27046        })]
27047      })]
27048    });
27049  }
27050  
27051  ;// ./node_modules/@wordpress/block-editor/build-module/hooks/border.js
27052  /**
27053   * External dependencies
27054   */
27055  
27056  
27057  /**
27058   * WordPress dependencies
27059   */
27060  
27061  
27062  
27063  
27064  
27065  
27066  /**
27067   * Internal dependencies
27068   */
27069  
27070  
27071  
27072  
27073  
27074  
27075  
27076  
27077  const BORDER_SUPPORT_KEY = '__experimentalBorder';
27078  const SHADOW_SUPPORT_KEY = 'shadow';
27079  const getColorByProperty = (colors, property, value) => {
27080    let matchedColor;
27081    colors.some(origin => origin.colors.some(color => {
27082      if (color[property] === value) {
27083        matchedColor = color;
27084        return true;
27085      }
27086      return false;
27087    }));
27088    return matchedColor;
27089  };
27090  const getMultiOriginColor = ({
27091    colors,
27092    namedColor,
27093    customColor
27094  }) => {
27095    // Search each origin (default, theme, or user) for matching color by name.
27096    if (namedColor) {
27097      const colorObject = getColorByProperty(colors, 'slug', namedColor);
27098      if (colorObject) {
27099        return colorObject;
27100      }
27101    }
27102  
27103    // Skip if no custom color or matching named color.
27104    if (!customColor) {
27105      return {
27106        color: undefined
27107      };
27108    }
27109  
27110    // Attempt to find color via custom color value or build new object.
27111    const colorObject = getColorByProperty(colors, 'color', customColor);
27112    return colorObject ? colorObject : {
27113      color: customColor
27114    };
27115  };
27116  function getColorSlugFromVariable(value) {
27117    const namedColor = /var:preset\|color\|(.+)/.exec(value);
27118    if (namedColor && namedColor[1]) {
27119      return namedColor[1];
27120    }
27121    return null;
27122  }
27123  function styleToAttributes(style) {
27124    if ((0,external_wp_components_namespaceObject.__experimentalHasSplitBorders)(style?.border)) {
27125      return {
27126        style,
27127        borderColor: undefined
27128      };
27129    }
27130    const borderColorValue = style?.border?.color;
27131    const borderColorSlug = borderColorValue?.startsWith('var:preset|color|') ? borderColorValue.substring('var:preset|color|'.length) : undefined;
27132    const updatedStyle = {
27133      ...style
27134    };
27135    updatedStyle.border = {
27136      ...updatedStyle.border,
27137      color: borderColorSlug ? undefined : borderColorValue
27138    };
27139    return {
27140      style: utils_cleanEmptyObject(updatedStyle),
27141      borderColor: borderColorSlug
27142    };
27143  }
27144  function attributesToStyle(attributes) {
27145    if ((0,external_wp_components_namespaceObject.__experimentalHasSplitBorders)(attributes.style?.border)) {
27146      return attributes.style;
27147    }
27148    return {
27149      ...attributes.style,
27150      border: {
27151        ...attributes.style?.border,
27152        color: attributes.borderColor ? 'var:preset|color|' + attributes.borderColor : attributes.style?.border?.color
27153      }
27154    };
27155  }
27156  function BordersInspectorControl({
27157    label,
27158    children,
27159    resetAllFilter
27160  }) {
27161    const attributesResetAllFilter = (0,external_wp_element_namespaceObject.useCallback)(attributes => {
27162      const existingStyle = attributesToStyle(attributes);
27163      const updatedStyle = resetAllFilter(existingStyle);
27164      return {
27165        ...attributes,
27166        ...styleToAttributes(updatedStyle)
27167      };
27168    }, [resetAllFilter]);
27169    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls, {
27170      group: "border",
27171      resetAllFilter: attributesResetAllFilter,
27172      label: label,
27173      children: children
27174    });
27175  }
27176  function border_BorderPanel({
27177    clientId,
27178    name,
27179    setAttributes,
27180    settings
27181  }) {
27182    const isEnabled = useHasBorderPanel(settings);
27183    function selector(select) {
27184      const {
27185        style,
27186        borderColor
27187      } = select(store).getBlockAttributes(clientId) || {};
27188      return {
27189        style,
27190        borderColor
27191      };
27192    }
27193    const {
27194      style,
27195      borderColor
27196    } = (0,external_wp_data_namespaceObject.useSelect)(selector, [clientId]);
27197    const value = (0,external_wp_element_namespaceObject.useMemo)(() => {
27198      return attributesToStyle({
27199        style,
27200        borderColor
27201      });
27202    }, [style, borderColor]);
27203    const onChange = newStyle => {
27204      setAttributes(styleToAttributes(newStyle));
27205    };
27206    if (!isEnabled) {
27207      return null;
27208    }
27209    const defaultControls = {
27210      ...(0,external_wp_blocks_namespaceObject.getBlockSupport)(name, [BORDER_SUPPORT_KEY, '__experimentalDefaultControls']),
27211      ...(0,external_wp_blocks_namespaceObject.getBlockSupport)(name, [SHADOW_SUPPORT_KEY, '__experimentalDefaultControls'])
27212    };
27213    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BorderPanel, {
27214      as: BordersInspectorControl,
27215      panelId: clientId,
27216      settings: settings,
27217      value: value,
27218      onChange: onChange,
27219      defaultControls: defaultControls
27220    });
27221  }
27222  
27223  /**
27224   * Determine whether there is block support for border properties.
27225   *
27226   * @param {string} blockName Block name.
27227   * @param {string} feature   Border feature to check support for.
27228   *
27229   * @return {boolean} Whether there is support.
27230   */
27231  function hasBorderSupport(blockName, feature = 'any') {
27232    if (external_wp_element_namespaceObject.Platform.OS !== 'web') {
27233      return false;
27234    }
27235    const support = (0,external_wp_blocks_namespaceObject.getBlockSupport)(blockName, BORDER_SUPPORT_KEY);
27236    if (support === true) {
27237      return true;
27238    }
27239    if (feature === 'any') {
27240      return !!(support?.color || support?.radius || support?.width || support?.style);
27241    }
27242    return !!support?.[feature];
27243  }
27244  
27245  /**
27246   * Determine whether there is block support for shadow properties.
27247   *
27248   * @param {string} blockName Block name.
27249   *
27250   * @return {boolean} Whether there is support.
27251   */
27252  function hasShadowSupport(blockName) {
27253    return hasBlockSupport(blockName, SHADOW_SUPPORT_KEY);
27254  }
27255  function useBorderPanelLabel({
27256    blockName,
27257    hasBorderControl,
27258    hasShadowControl
27259  } = {}) {
27260    const settings = useBlockSettings(blockName);
27261    const controls = useHasBorderPanelControls(settings);
27262    if (!hasBorderControl && !hasShadowControl && blockName) {
27263      hasBorderControl = controls?.hasBorderColor || controls?.hasBorderStyle || controls?.hasBorderWidth || controls?.hasBorderRadius;
27264      hasShadowControl = controls?.hasShadow;
27265    }
27266    if (hasBorderControl && hasShadowControl) {
27267      return (0,external_wp_i18n_namespaceObject.__)('Border & Shadow');
27268    }
27269    if (hasShadowControl) {
27270      return (0,external_wp_i18n_namespaceObject.__)('Shadow');
27271    }
27272    return (0,external_wp_i18n_namespaceObject.__)('Border');
27273  }
27274  
27275  /**
27276   * Returns a new style object where the specified border attribute has been
27277   * removed.
27278   *
27279   * @param {Object} style     Styles from block attributes.
27280   * @param {string} attribute The border style attribute to clear.
27281   *
27282   * @return {Object} Style object with the specified attribute removed.
27283   */
27284  function removeBorderAttribute(style, attribute) {
27285    return cleanEmptyObject({
27286      ...style,
27287      border: {
27288        ...style?.border,
27289        [attribute]: undefined
27290      }
27291    });
27292  }
27293  
27294  /**
27295   * Filters registered block settings, extending attributes to include
27296   * `borderColor` if needed.
27297   *
27298   * @param {Object} settings Original block settings.
27299   *
27300   * @return {Object} Updated block settings.
27301   */
27302  function addAttributes(settings) {
27303    if (!hasBorderSupport(settings, 'color')) {
27304      return settings;
27305    }
27306  
27307    // Allow blocks to specify default value if needed.
27308    if (settings.attributes.borderColor) {
27309      return settings;
27310    }
27311  
27312    // Add new borderColor attribute to block settings.
27313    return {
27314      ...settings,
27315      attributes: {
27316        ...settings.attributes,
27317        borderColor: {
27318          type: 'string'
27319        }
27320      }
27321    };
27322  }
27323  
27324  /**
27325   * Override props assigned to save component to inject border color.
27326   *
27327   * @param {Object}        props           Additional props applied to save element.
27328   * @param {Object|string} blockNameOrType Block type definition.
27329   * @param {Object}        attributes      Block's attributes.
27330   *
27331   * @return {Object} Filtered props to apply to save element.
27332   */
27333  function border_addSaveProps(props, blockNameOrType, attributes) {
27334    if (!hasBorderSupport(blockNameOrType, 'color') || shouldSkipSerialization(blockNameOrType, BORDER_SUPPORT_KEY, 'color')) {
27335      return props;
27336    }
27337    const borderClasses = getBorderClasses(attributes);
27338    const newClassName = dist_clsx(props.className, borderClasses);
27339  
27340    // If we are clearing the last of the previous classes in `className`
27341    // set it to `undefined` to avoid rendering empty DOM attributes.
27342    props.className = newClassName ? newClassName : undefined;
27343    return props;
27344  }
27345  
27346  /**
27347   * Generates a CSS class name consisting of all the applicable border color
27348   * classes given the current block attributes.
27349   *
27350   * @param {Object} attributes Block's attributes.
27351   *
27352   * @return {string} CSS class name.
27353   */
27354  function getBorderClasses(attributes) {
27355    const {
27356      borderColor,
27357      style
27358    } = attributes;
27359    const borderColorClass = getColorClassName('border-color', borderColor);
27360    return dist_clsx({
27361      'has-border-color': borderColor || style?.border?.color,
27362      [borderColorClass]: !!borderColorClass
27363    });
27364  }
27365  function border_useBlockProps({
27366    name,
27367    borderColor,
27368    style
27369  }) {
27370    const {
27371      colors
27372    } = useMultipleOriginColorsAndGradients();
27373    if (!hasBorderSupport(name, 'color') || shouldSkipSerialization(name, BORDER_SUPPORT_KEY, 'color')) {
27374      return {};
27375    }
27376    const {
27377      color: borderColorValue
27378    } = getMultiOriginColor({
27379      colors,
27380      namedColor: borderColor
27381    });
27382    const {
27383      color: borderTopColor
27384    } = getMultiOriginColor({
27385      colors,
27386      namedColor: getColorSlugFromVariable(style?.border?.top?.color)
27387    });
27388    const {
27389      color: borderRightColor
27390    } = getMultiOriginColor({
27391      colors,
27392      namedColor: getColorSlugFromVariable(style?.border?.right?.color)
27393    });
27394    const {
27395      color: borderBottomColor
27396    } = getMultiOriginColor({
27397      colors,
27398      namedColor: getColorSlugFromVariable(style?.border?.bottom?.color)
27399    });
27400    const {
27401      color: borderLeftColor
27402    } = getMultiOriginColor({
27403      colors,
27404      namedColor: getColorSlugFromVariable(style?.border?.left?.color)
27405    });
27406    const extraStyles = {
27407      borderTopColor: borderTopColor || borderColorValue,
27408      borderRightColor: borderRightColor || borderColorValue,
27409      borderBottomColor: borderBottomColor || borderColorValue,
27410      borderLeftColor: borderLeftColor || borderColorValue
27411    };
27412    return border_addSaveProps({
27413      style: utils_cleanEmptyObject(extraStyles) || {}
27414    }, name, {
27415      borderColor,
27416      style
27417    });
27418  }
27419  /* harmony default export */ const border = ({
27420    useBlockProps: border_useBlockProps,
27421    addSaveProps: border_addSaveProps,
27422    attributeKeys: ['borderColor', 'style'],
27423    hasSupport(name) {
27424      return hasBorderSupport(name, 'color');
27425    }
27426  });
27427  (0,external_wp_hooks_namespaceObject.addFilter)('blocks.registerBlockType', 'core/border/addAttributes', addAttributes);
27428  
27429  ;// ./node_modules/@wordpress/block-editor/build-module/components/gradients/use-gradient.js
27430  /**
27431   * WordPress dependencies
27432   */
27433  
27434  
27435  
27436  /**
27437   * Internal dependencies
27438   */
27439  
27440  
27441  
27442  function __experimentalGetGradientClass(gradientSlug) {
27443    if (!gradientSlug) {
27444      return undefined;
27445    }
27446    return `has-$gradientSlug}-gradient-background`;
27447  }
27448  
27449  /**
27450   * Retrieves the gradient value per slug.
27451   *
27452   * @param {Array}  gradients Gradient Palette
27453   * @param {string} slug      Gradient slug
27454   *
27455   * @return {string} Gradient value.
27456   */
27457  function getGradientValueBySlug(gradients, slug) {
27458    const gradient = gradients?.find(g => g.slug === slug);
27459    return gradient && gradient.gradient;
27460  }
27461  function __experimentalGetGradientObjectByGradientValue(gradients, value) {
27462    const gradient = gradients?.find(g => g.gradient === value);
27463    return gradient;
27464  }
27465  
27466  /**
27467   * Retrieves the gradient slug per slug.
27468   *
27469   * @param {Array}  gradients Gradient Palette
27470   * @param {string} value     Gradient value
27471   * @return {string} Gradient slug.
27472   */
27473  function getGradientSlugByValue(gradients, value) {
27474    const gradient = __experimentalGetGradientObjectByGradientValue(gradients, value);
27475    return gradient && gradient.slug;
27476  }
27477  function __experimentalUseGradient({
27478    gradientAttribute = 'gradient',
27479    customGradientAttribute = 'customGradient'
27480  } = {}) {
27481    const {
27482      clientId
27483    } = useBlockEditContext();
27484    const [userGradientPalette, themeGradientPalette, defaultGradientPalette] = use_settings_useSettings('color.gradients.custom', 'color.gradients.theme', 'color.gradients.default');
27485    const allGradients = (0,external_wp_element_namespaceObject.useMemo)(() => [...(userGradientPalette || []), ...(themeGradientPalette || []), ...(defaultGradientPalette || [])], [userGradientPalette, themeGradientPalette, defaultGradientPalette]);
27486    const {
27487      gradient,
27488      customGradient
27489    } = (0,external_wp_data_namespaceObject.useSelect)(select => {
27490      const {
27491        getBlockAttributes
27492      } = select(store);
27493      const attributes = getBlockAttributes(clientId) || {};
27494      return {
27495        customGradient: attributes[customGradientAttribute],
27496        gradient: attributes[gradientAttribute]
27497      };
27498    }, [clientId, gradientAttribute, customGradientAttribute]);
27499    const {
27500      updateBlockAttributes
27501    } = (0,external_wp_data_namespaceObject.useDispatch)(store);
27502    const setGradient = (0,external_wp_element_namespaceObject.useCallback)(newGradientValue => {
27503      const slug = getGradientSlugByValue(allGradients, newGradientValue);
27504      if (slug) {
27505        updateBlockAttributes(clientId, {
27506          [gradientAttribute]: slug,
27507          [customGradientAttribute]: undefined
27508        });
27509        return;
27510      }
27511      updateBlockAttributes(clientId, {
27512        [gradientAttribute]: undefined,
27513        [customGradientAttribute]: newGradientValue
27514      });
27515    }, [allGradients, clientId, updateBlockAttributes]);
27516    const gradientClass = __experimentalGetGradientClass(gradient);
27517    let gradientValue;
27518    if (gradient) {
27519      gradientValue = getGradientValueBySlug(allGradients, gradient);
27520    } else {
27521      gradientValue = customGradient;
27522    }
27523    return {
27524      gradientClass,
27525      gradientValue,
27526      setGradient
27527    };
27528  }
27529  
27530  ;// ./node_modules/@wordpress/block-editor/build-module/components/colors-gradients/control.js
27531  /**
27532   * External dependencies
27533   */
27534  
27535  
27536  /**
27537   * WordPress dependencies
27538   */
27539  
27540  
27541  
27542  /**
27543   * Internal dependencies
27544   */
27545  
27546  
27547  
27548  const {
27549    Tabs
27550  } = unlock(external_wp_components_namespaceObject.privateApis);
27551  const colorsAndGradientKeys = ['colors', 'disableCustomColors', 'gradients', 'disableCustomGradients'];
27552  const TAB_IDS = {
27553    color: 'color',
27554    gradient: 'gradient'
27555  };
27556  function ColorGradientControlInner({
27557    colors,
27558    gradients,
27559    disableCustomColors,
27560    disableCustomGradients,
27561    __experimentalIsRenderedInSidebar,
27562    className,
27563    label,
27564    onColorChange,
27565    onGradientChange,
27566    colorValue,
27567    gradientValue,
27568    clearable,
27569    showTitle = true,
27570    enableAlpha,
27571    headingLevel
27572  }) {
27573    const canChooseAColor = onColorChange && (colors && colors.length > 0 || !disableCustomColors);
27574    const canChooseAGradient = onGradientChange && (gradients && gradients.length > 0 || !disableCustomGradients);
27575    if (!canChooseAColor && !canChooseAGradient) {
27576      return null;
27577    }
27578    const tabPanels = {
27579      [TAB_IDS.color]: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ColorPalette, {
27580        value: colorValue,
27581        onChange: canChooseAGradient ? newColor => {
27582          onColorChange(newColor);
27583          onGradientChange();
27584        } : onColorChange,
27585        colors,
27586        disableCustomColors,
27587        __experimentalIsRenderedInSidebar: __experimentalIsRenderedInSidebar,
27588        clearable: clearable,
27589        enableAlpha: enableAlpha,
27590        headingLevel: headingLevel
27591      }),
27592      [TAB_IDS.gradient]: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.GradientPicker, {
27593        value: gradientValue,
27594        onChange: canChooseAColor ? newGradient => {
27595          onGradientChange(newGradient);
27596          onColorChange();
27597        } : onGradientChange,
27598        gradients,
27599        disableCustomGradients,
27600        __experimentalIsRenderedInSidebar: __experimentalIsRenderedInSidebar,
27601        clearable: clearable,
27602        headingLevel: headingLevel
27603      })
27604    };
27605    const renderPanelType = type => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
27606      className: "block-editor-color-gradient-control__panel",
27607      children: tabPanels[type]
27608    });
27609    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.BaseControl, {
27610      __nextHasNoMarginBottom: true,
27611      className: dist_clsx('block-editor-color-gradient-control', className),
27612      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("fieldset", {
27613        className: "block-editor-color-gradient-control__fieldset",
27614        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalVStack, {
27615          spacing: 1,
27616          children: [showTitle && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("legend", {
27617            children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
27618              className: "block-editor-color-gradient-control__color-indicator",
27619              children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.BaseControl.VisualLabel, {
27620                children: label
27621              })
27622            })
27623          }), canChooseAColor && canChooseAGradient && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
27624            children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(Tabs, {
27625              defaultTabId: gradientValue ? TAB_IDS.gradient : !!canChooseAColor && TAB_IDS.color,
27626              children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(Tabs.TabList, {
27627                children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Tabs.Tab, {
27628                  tabId: TAB_IDS.color,
27629                  children: (0,external_wp_i18n_namespaceObject.__)('Color')
27630                }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Tabs.Tab, {
27631                  tabId: TAB_IDS.gradient,
27632                  children: (0,external_wp_i18n_namespaceObject.__)('Gradient')
27633                })]
27634              }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Tabs.TabPanel, {
27635                tabId: TAB_IDS.color,
27636                className: "block-editor-color-gradient-control__panel",
27637                focusable: false,
27638                children: tabPanels.color
27639              }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Tabs.TabPanel, {
27640                tabId: TAB_IDS.gradient,
27641                className: "block-editor-color-gradient-control__panel",
27642                focusable: false,
27643                children: tabPanels.gradient
27644              })]
27645            })
27646          }), !canChooseAGradient && renderPanelType(TAB_IDS.color), !canChooseAColor && renderPanelType(TAB_IDS.gradient)]
27647        })
27648      })
27649    });
27650  }
27651  function ColorGradientControlSelect(props) {
27652    const [colors, gradients, customColors, customGradients] = use_settings_useSettings('color.palette', 'color.gradients', 'color.custom', 'color.customGradient');
27653    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ColorGradientControlInner, {
27654      colors: colors,
27655      gradients: gradients,
27656      disableCustomColors: !customColors,
27657      disableCustomGradients: !customGradients,
27658      ...props
27659    });
27660  }
27661  function ColorGradientControl(props) {
27662    if (colorsAndGradientKeys.every(key => props.hasOwnProperty(key))) {
27663      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ColorGradientControlInner, {
27664        ...props
27665      });
27666    }
27667    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ColorGradientControlSelect, {
27668      ...props
27669    });
27670  }
27671  /* harmony default export */ const control = (ColorGradientControl);
27672  
27673  ;// ./node_modules/@wordpress/block-editor/build-module/components/global-styles/color-panel.js
27674  /**
27675   * External dependencies
27676   */
27677  
27678  
27679  /**
27680   * WordPress dependencies
27681   */
27682  
27683  
27684  
27685  
27686  /**
27687   * Internal dependencies
27688   */
27689  
27690  
27691  
27692  
27693  
27694  
27695  
27696  function useHasColorPanel(settings) {
27697    const hasTextPanel = useHasTextPanel(settings);
27698    const hasBackgroundPanel = useHasBackgroundColorPanel(settings);
27699    const hasLinkPanel = useHasLinkPanel(settings);
27700    const hasHeadingPanel = useHasHeadingPanel(settings);
27701    const hasButtonPanel = useHasButtonPanel(settings);
27702    const hasCaptionPanel = useHasCaptionPanel(settings);
27703    return hasTextPanel || hasBackgroundPanel || hasLinkPanel || hasHeadingPanel || hasButtonPanel || hasCaptionPanel;
27704  }
27705  function useHasTextPanel(settings) {
27706    const colors = useColorsPerOrigin(settings);
27707    return settings?.color?.text && (colors?.length > 0 || settings?.color?.custom);
27708  }
27709  function useHasLinkPanel(settings) {
27710    const colors = useColorsPerOrigin(settings);
27711    return settings?.color?.link && (colors?.length > 0 || settings?.color?.custom);
27712  }
27713  function useHasCaptionPanel(settings) {
27714    const colors = useColorsPerOrigin(settings);
27715    return settings?.color?.caption && (colors?.length > 0 || settings?.color?.custom);
27716  }
27717  function useHasHeadingPanel(settings) {
27718    const colors = useColorsPerOrigin(settings);
27719    const gradients = useGradientsPerOrigin(settings);
27720    return settings?.color?.heading && (colors?.length > 0 || settings?.color?.custom || gradients?.length > 0 || settings?.color?.customGradient);
27721  }
27722  function useHasButtonPanel(settings) {
27723    const colors = useColorsPerOrigin(settings);
27724    const gradients = useGradientsPerOrigin(settings);
27725    return settings?.color?.button && (colors?.length > 0 || settings?.color?.custom || gradients?.length > 0 || settings?.color?.customGradient);
27726  }
27727  function useHasBackgroundColorPanel(settings) {
27728    const colors = useColorsPerOrigin(settings);
27729    const gradients = useGradientsPerOrigin(settings);
27730    return settings?.color?.background && (colors?.length > 0 || settings?.color?.custom || gradients?.length > 0 || settings?.color?.customGradient);
27731  }
27732  function ColorToolsPanel({
27733    resetAllFilter,
27734    onChange,
27735    value,
27736    panelId,
27737    children
27738  }) {
27739    const dropdownMenuProps = useToolsPanelDropdownMenuProps();
27740    const resetAll = () => {
27741      const updatedValue = resetAllFilter(value);
27742      onChange(updatedValue);
27743    };
27744    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanel, {
27745      label: (0,external_wp_i18n_namespaceObject.__)('Elements'),
27746      resetAll: resetAll,
27747      panelId: panelId,
27748      hasInnerWrapper: true,
27749      headingLevel: 3,
27750      className: "color-block-support-panel",
27751      __experimentalFirstVisibleItemClass: "first",
27752      __experimentalLastVisibleItemClass: "last",
27753      dropdownMenuProps: dropdownMenuProps,
27754      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
27755        className: "color-block-support-panel__inner-wrapper",
27756        children: children
27757      })
27758    });
27759  }
27760  const color_panel_DEFAULT_CONTROLS = {
27761    text: true,
27762    background: true,
27763    link: true,
27764    heading: true,
27765    button: true,
27766    caption: true
27767  };
27768  const popoverProps = {
27769    placement: 'left-start',
27770    offset: 36,
27771    shift: true
27772  };
27773  const {
27774    Tabs: color_panel_Tabs
27775  } = unlock(external_wp_components_namespaceObject.privateApis);
27776  const LabeledColorIndicators = ({
27777    indicators,
27778    label
27779  }) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalHStack, {
27780    justify: "flex-start",
27781    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalZStack, {
27782      isLayered: false,
27783      offset: -8,
27784      children: indicators.map((indicator, index) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Flex, {
27785        expanded: false,
27786        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ColorIndicator, {
27787          colorValue: indicator
27788        })
27789      }, index))
27790    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FlexItem, {
27791      className: "block-editor-panel-color-gradient-settings__color-name",
27792      children: label
27793    })]
27794  });
27795  function ColorPanelTab({
27796    isGradient,
27797    inheritedValue,
27798    userValue,
27799    setValue,
27800    colorGradientControlSettings
27801  }) {
27802    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(control, {
27803      ...colorGradientControlSettings,
27804      showTitle: false,
27805      enableAlpha: true,
27806      __experimentalIsRenderedInSidebar: true,
27807      colorValue: isGradient ? undefined : inheritedValue,
27808      gradientValue: isGradient ? inheritedValue : undefined,
27809      onColorChange: isGradient ? undefined : setValue,
27810      onGradientChange: isGradient ? setValue : undefined,
27811      clearable: inheritedValue === userValue,
27812      headingLevel: 3
27813    });
27814  }
27815  function ColorPanelDropdown({
27816    label,
27817    hasValue,
27818    resetValue,
27819    isShownByDefault,
27820    indicators,
27821    tabs,
27822    colorGradientControlSettings,
27823    panelId
27824  }) {
27825    var _tabs$;
27826    const currentTab = tabs.find(tab => tab.userValue !== undefined);
27827    const {
27828      key: firstTabKey,
27829      ...firstTab
27830    } = (_tabs$ = tabs[0]) !== null && _tabs$ !== void 0 ? _tabs$ : {};
27831    const colorGradientDropdownButtonRef = (0,external_wp_element_namespaceObject.useRef)(undefined);
27832    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanelItem, {
27833      className: "block-editor-tools-panel-color-gradient-settings__item",
27834      hasValue: hasValue,
27835      label: label,
27836      onDeselect: resetValue,
27837      isShownByDefault: isShownByDefault,
27838      panelId: panelId,
27839      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Dropdown, {
27840        popoverProps: popoverProps,
27841        className: "block-editor-tools-panel-color-gradient-settings__dropdown",
27842        renderToggle: ({
27843          onToggle,
27844          isOpen
27845        }) => {
27846          const toggleProps = {
27847            onClick: onToggle,
27848            className: dist_clsx('block-editor-panel-color-gradient-settings__dropdown', {
27849              'is-open': isOpen
27850            }),
27851            'aria-expanded': isOpen,
27852            ref: colorGradientDropdownButtonRef
27853          };
27854          return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
27855            children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
27856              ...toggleProps,
27857              __next40pxDefaultSize: true,
27858              children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(LabeledColorIndicators, {
27859                indicators: indicators,
27860                label: label
27861              })
27862            }), hasValue() && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
27863              __next40pxDefaultSize: true,
27864              label: (0,external_wp_i18n_namespaceObject.__)('Reset'),
27865              className: "block-editor-panel-color-gradient-settings__reset",
27866              size: "small",
27867              icon: library_reset,
27868              onClick: () => {
27869                resetValue();
27870                if (isOpen) {
27871                  onToggle();
27872                }
27873                // Return focus to parent button
27874                colorGradientDropdownButtonRef.current?.focus();
27875              }
27876            })]
27877          });
27878        },
27879        renderContent: () => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalDropdownContentWrapper, {
27880          paddingSize: "none",
27881          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
27882            className: "block-editor-panel-color-gradient-settings__dropdown-content",
27883            children: [tabs.length === 1 && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ColorPanelTab, {
27884              ...firstTab,
27885              colorGradientControlSettings: colorGradientControlSettings
27886            }, firstTabKey), tabs.length > 1 && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(color_panel_Tabs, {
27887              defaultTabId: currentTab?.key,
27888              children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(color_panel_Tabs.TabList, {
27889                children: tabs.map(tab => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(color_panel_Tabs.Tab, {
27890                  tabId: tab.key,
27891                  children: tab.label
27892                }, tab.key))
27893              }), tabs.map(tab => {
27894                const {
27895                  key: tabKey,
27896                  ...restTabProps
27897                } = tab;
27898                return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(color_panel_Tabs.TabPanel, {
27899                  tabId: tabKey,
27900                  focusable: false,
27901                  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ColorPanelTab, {
27902                    ...restTabProps,
27903                    colorGradientControlSettings: colorGradientControlSettings
27904                  }, tabKey)
27905                }, tabKey);
27906              })]
27907            })]
27908          })
27909        })
27910      })
27911    });
27912  }
27913  function ColorPanel({
27914    as: Wrapper = ColorToolsPanel,
27915    value,
27916    onChange,
27917    inheritedValue = value,
27918    settings,
27919    panelId,
27920    defaultControls = color_panel_DEFAULT_CONTROLS,
27921    children
27922  }) {
27923    const colors = useColorsPerOrigin(settings);
27924    const gradients = useGradientsPerOrigin(settings);
27925    const areCustomSolidsEnabled = settings?.color?.custom;
27926    const areCustomGradientsEnabled = settings?.color?.customGradient;
27927    const hasSolidColors = colors.length > 0 || areCustomSolidsEnabled;
27928    const hasGradientColors = gradients.length > 0 || areCustomGradientsEnabled;
27929    const decodeValue = rawValue => getValueFromVariable({
27930      settings
27931    }, '', rawValue);
27932    const encodeColorValue = colorValue => {
27933      const allColors = colors.flatMap(({
27934        colors: originColors
27935      }) => originColors);
27936      const colorObject = allColors.find(({
27937        color
27938      }) => color === colorValue);
27939      return colorObject ? 'var:preset|color|' + colorObject.slug : colorValue;
27940    };
27941    const encodeGradientValue = gradientValue => {
27942      const allGradients = gradients.flatMap(({
27943        gradients: originGradients
27944      }) => originGradients);
27945      const gradientObject = allGradients.find(({
27946        gradient
27947      }) => gradient === gradientValue);
27948      return gradientObject ? 'var:preset|gradient|' + gradientObject.slug : gradientValue;
27949    };
27950  
27951    // BackgroundColor
27952    const showBackgroundPanel = useHasBackgroundColorPanel(settings);
27953    const backgroundColor = decodeValue(inheritedValue?.color?.background);
27954    const userBackgroundColor = decodeValue(value?.color?.background);
27955    const gradient = decodeValue(inheritedValue?.color?.gradient);
27956    const userGradient = decodeValue(value?.color?.gradient);
27957    const hasBackground = () => !!userBackgroundColor || !!userGradient;
27958    const setBackgroundColor = newColor => {
27959      const newValue = setImmutably(value, ['color', 'background'], encodeColorValue(newColor));
27960      newValue.color.gradient = undefined;
27961      onChange(newValue);
27962    };
27963    const setGradient = newGradient => {
27964      const newValue = setImmutably(value, ['color', 'gradient'], encodeGradientValue(newGradient));
27965      newValue.color.background = undefined;
27966      onChange(newValue);
27967    };
27968    const resetBackground = () => {
27969      const newValue = setImmutably(value, ['color', 'background'], undefined);
27970      newValue.color.gradient = undefined;
27971      onChange(newValue);
27972    };
27973  
27974    // Links
27975    const showLinkPanel = useHasLinkPanel(settings);
27976    const linkColor = decodeValue(inheritedValue?.elements?.link?.color?.text);
27977    const userLinkColor = decodeValue(value?.elements?.link?.color?.text);
27978    const setLinkColor = newColor => {
27979      onChange(setImmutably(value, ['elements', 'link', 'color', 'text'], encodeColorValue(newColor)));
27980    };
27981    const hoverLinkColor = decodeValue(inheritedValue?.elements?.link?.[':hover']?.color?.text);
27982    const userHoverLinkColor = decodeValue(value?.elements?.link?.[':hover']?.color?.text);
27983    const setHoverLinkColor = newColor => {
27984      onChange(setImmutably(value, ['elements', 'link', ':hover', 'color', 'text'], encodeColorValue(newColor)));
27985    };
27986    const hasLink = () => !!userLinkColor || !!userHoverLinkColor;
27987    const resetLink = () => {
27988      let newValue = setImmutably(value, ['elements', 'link', ':hover', 'color', 'text'], undefined);
27989      newValue = setImmutably(newValue, ['elements', 'link', 'color', 'text'], undefined);
27990      onChange(newValue);
27991    };
27992  
27993    // Text Color
27994    const showTextPanel = useHasTextPanel(settings);
27995    const textColor = decodeValue(inheritedValue?.color?.text);
27996    const userTextColor = decodeValue(value?.color?.text);
27997    const hasTextColor = () => !!userTextColor;
27998    const setTextColor = newColor => {
27999      let changedObject = setImmutably(value, ['color', 'text'], encodeColorValue(newColor));
28000      if (textColor === linkColor) {
28001        changedObject = setImmutably(changedObject, ['elements', 'link', 'color', 'text'], encodeColorValue(newColor));
28002      }
28003      onChange(changedObject);
28004    };
28005    const resetTextColor = () => setTextColor(undefined);
28006  
28007    // Elements
28008    const elements = [{
28009      name: 'caption',
28010      label: (0,external_wp_i18n_namespaceObject.__)('Captions'),
28011      showPanel: useHasCaptionPanel(settings)
28012    }, {
28013      name: 'button',
28014      label: (0,external_wp_i18n_namespaceObject.__)('Button'),
28015      showPanel: useHasButtonPanel(settings)
28016    }, {
28017      name: 'heading',
28018      label: (0,external_wp_i18n_namespaceObject.__)('Heading'),
28019      showPanel: useHasHeadingPanel(settings)
28020    }, {
28021      name: 'h1',
28022      label: (0,external_wp_i18n_namespaceObject.__)('H1'),
28023      showPanel: useHasHeadingPanel(settings)
28024    }, {
28025      name: 'h2',
28026      label: (0,external_wp_i18n_namespaceObject.__)('H2'),
28027      showPanel: useHasHeadingPanel(settings)
28028    }, {
28029      name: 'h3',
28030      label: (0,external_wp_i18n_namespaceObject.__)('H3'),
28031      showPanel: useHasHeadingPanel(settings)
28032    }, {
28033      name: 'h4',
28034      label: (0,external_wp_i18n_namespaceObject.__)('H4'),
28035      showPanel: useHasHeadingPanel(settings)
28036    }, {
28037      name: 'h5',
28038      label: (0,external_wp_i18n_namespaceObject.__)('H5'),
28039      showPanel: useHasHeadingPanel(settings)
28040    }, {
28041      name: 'h6',
28042      label: (0,external_wp_i18n_namespaceObject.__)('H6'),
28043      showPanel: useHasHeadingPanel(settings)
28044    }];
28045    const resetAllFilter = (0,external_wp_element_namespaceObject.useCallback)(previousValue => {
28046      return {
28047        ...previousValue,
28048        color: undefined,
28049        elements: {
28050          ...previousValue?.elements,
28051          link: {
28052            ...previousValue?.elements?.link,
28053            color: undefined,
28054            ':hover': {
28055              color: undefined
28056            }
28057          },
28058          ...elements.reduce((acc, element) => {
28059            return {
28060              ...acc,
28061              [element.name]: {
28062                ...previousValue?.elements?.[element.name],
28063                color: undefined
28064              }
28065            };
28066          }, {})
28067        }
28068      };
28069    }, []);
28070    const items = [showTextPanel && {
28071      key: 'text',
28072      label: (0,external_wp_i18n_namespaceObject.__)('Text'),
28073      hasValue: hasTextColor,
28074      resetValue: resetTextColor,
28075      isShownByDefault: defaultControls.text,
28076      indicators: [textColor],
28077      tabs: [{
28078        key: 'text',
28079        label: (0,external_wp_i18n_namespaceObject.__)('Text'),
28080        inheritedValue: textColor,
28081        setValue: setTextColor,
28082        userValue: userTextColor
28083      }]
28084    }, showBackgroundPanel && {
28085      key: 'background',
28086      label: (0,external_wp_i18n_namespaceObject.__)('Background'),
28087      hasValue: hasBackground,
28088      resetValue: resetBackground,
28089      isShownByDefault: defaultControls.background,
28090      indicators: [gradient !== null && gradient !== void 0 ? gradient : backgroundColor],
28091      tabs: [hasSolidColors && {
28092        key: 'background',
28093        label: (0,external_wp_i18n_namespaceObject.__)('Color'),
28094        inheritedValue: backgroundColor,
28095        setValue: setBackgroundColor,
28096        userValue: userBackgroundColor
28097      }, hasGradientColors && {
28098        key: 'gradient',
28099        label: (0,external_wp_i18n_namespaceObject.__)('Gradient'),
28100        inheritedValue: gradient,
28101        setValue: setGradient,
28102        userValue: userGradient,
28103        isGradient: true
28104      }].filter(Boolean)
28105    }, showLinkPanel && {
28106      key: 'link',
28107      label: (0,external_wp_i18n_namespaceObject.__)('Link'),
28108      hasValue: hasLink,
28109      resetValue: resetLink,
28110      isShownByDefault: defaultControls.link,
28111      indicators: [linkColor, hoverLinkColor],
28112      tabs: [{
28113        key: 'link',
28114        label: (0,external_wp_i18n_namespaceObject.__)('Default'),
28115        inheritedValue: linkColor,
28116        setValue: setLinkColor,
28117        userValue: userLinkColor
28118      }, {
28119        key: 'hover',
28120        label: (0,external_wp_i18n_namespaceObject.__)('Hover'),
28121        inheritedValue: hoverLinkColor,
28122        setValue: setHoverLinkColor,
28123        userValue: userHoverLinkColor
28124      }]
28125    }].filter(Boolean);
28126    elements.forEach(({
28127      name,
28128      label,
28129      showPanel
28130    }) => {
28131      if (!showPanel) {
28132        return;
28133      }
28134      const elementBackgroundColor = decodeValue(inheritedValue?.elements?.[name]?.color?.background);
28135      const elementGradient = decodeValue(inheritedValue?.elements?.[name]?.color?.gradient);
28136      const elementTextColor = decodeValue(inheritedValue?.elements?.[name]?.color?.text);
28137      const elementBackgroundUserColor = decodeValue(value?.elements?.[name]?.color?.background);
28138      const elementGradientUserColor = decodeValue(value?.elements?.[name]?.color?.gradient);
28139      const elementTextUserColor = decodeValue(value?.elements?.[name]?.color?.text);
28140      const hasElement = () => !!(elementTextUserColor || elementBackgroundUserColor || elementGradientUserColor);
28141      const resetElement = () => {
28142        const newValue = setImmutably(value, ['elements', name, 'color', 'background'], undefined);
28143        newValue.elements[name].color.gradient = undefined;
28144        newValue.elements[name].color.text = undefined;
28145        onChange(newValue);
28146      };
28147      const setElementTextColor = newTextColor => {
28148        onChange(setImmutably(value, ['elements', name, 'color', 'text'], encodeColorValue(newTextColor)));
28149      };
28150      const setElementBackgroundColor = newBackgroundColor => {
28151        const newValue = setImmutably(value, ['elements', name, 'color', 'background'], encodeColorValue(newBackgroundColor));
28152        newValue.elements[name].color.gradient = undefined;
28153        onChange(newValue);
28154      };
28155      const setElementGradient = newGradient => {
28156        const newValue = setImmutably(value, ['elements', name, 'color', 'gradient'], encodeGradientValue(newGradient));
28157        newValue.elements[name].color.background = undefined;
28158        onChange(newValue);
28159      };
28160      const supportsTextColor = true;
28161      // Background color is not supported for `caption`
28162      // as there isn't yet a way to set padding for the element.
28163      const supportsBackground = name !== 'caption';
28164      items.push({
28165        key: name,
28166        label,
28167        hasValue: hasElement,
28168        resetValue: resetElement,
28169        isShownByDefault: defaultControls[name],
28170        indicators: supportsTextColor && supportsBackground ? [elementTextColor, elementGradient !== null && elementGradient !== void 0 ? elementGradient : elementBackgroundColor] : [supportsTextColor ? elementTextColor : elementGradient !== null && elementGradient !== void 0 ? elementGradient : elementBackgroundColor],
28171        tabs: [hasSolidColors && supportsTextColor && {
28172          key: 'text',
28173          label: (0,external_wp_i18n_namespaceObject.__)('Text'),
28174          inheritedValue: elementTextColor,
28175          setValue: setElementTextColor,
28176          userValue: elementTextUserColor
28177        }, hasSolidColors && supportsBackground && {
28178          key: 'background',
28179          label: (0,external_wp_i18n_namespaceObject.__)('Background'),
28180          inheritedValue: elementBackgroundColor,
28181          setValue: setElementBackgroundColor,
28182          userValue: elementBackgroundUserColor
28183        }, hasGradientColors && supportsBackground && {
28184          key: 'gradient',
28185          label: (0,external_wp_i18n_namespaceObject.__)('Gradient'),
28186          inheritedValue: elementGradient,
28187          setValue: setElementGradient,
28188          userValue: elementGradientUserColor,
28189          isGradient: true
28190        }].filter(Boolean)
28191      });
28192    });
28193    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(Wrapper, {
28194      resetAllFilter: resetAllFilter,
28195      value: value,
28196      onChange: onChange,
28197      panelId: panelId,
28198      children: [items.map(item => {
28199        const {
28200          key,
28201          ...restItem
28202        } = item;
28203        return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ColorPanelDropdown, {
28204          ...restItem,
28205          colorGradientControlSettings: {
28206            colors,
28207            disableCustomColors: !areCustomSolidsEnabled,
28208            gradients,
28209            disableCustomGradients: !areCustomGradientsEnabled
28210          },
28211          panelId: panelId
28212        }, key);
28213      }), children]
28214    });
28215  }
28216  
28217  ;// ./node_modules/@wordpress/block-editor/build-module/components/contrast-checker/index.js
28218  /**
28219   * External dependencies
28220   */
28221  
28222  
28223  
28224  
28225  /**
28226   * WordPress dependencies
28227   */
28228  
28229  
28230  
28231  
28232  k([names, a11y]);
28233  function ContrastChecker({
28234    backgroundColor,
28235    fallbackBackgroundColor,
28236    fallbackTextColor,
28237    fallbackLinkColor,
28238    fontSize,
28239    // Font size value in pixels.
28240    isLargeText,
28241    textColor,
28242    linkColor,
28243    enableAlphaChecker = false
28244  }) {
28245    const currentBackgroundColor = backgroundColor || fallbackBackgroundColor;
28246  
28247    // Must have a background color.
28248    if (!currentBackgroundColor) {
28249      return null;
28250    }
28251    const currentTextColor = textColor || fallbackTextColor;
28252    const currentLinkColor = linkColor || fallbackLinkColor;
28253  
28254    // Must have at least one text color.
28255    if (!currentTextColor && !currentLinkColor) {
28256      return null;
28257    }
28258    const textColors = [{
28259      color: currentTextColor,
28260      description: (0,external_wp_i18n_namespaceObject.__)('text color')
28261    }, {
28262      color: currentLinkColor,
28263      description: (0,external_wp_i18n_namespaceObject.__)('link color')
28264    }];
28265    const colordBackgroundColor = w(currentBackgroundColor);
28266    const backgroundColorHasTransparency = colordBackgroundColor.alpha() < 1;
28267    const backgroundColorBrightness = colordBackgroundColor.brightness();
28268    const isReadableOptions = {
28269      level: 'AA',
28270      size: isLargeText || isLargeText !== false && fontSize >= 24 ? 'large' : 'small'
28271    };
28272    let message = '';
28273    let speakMessage = '';
28274    for (const item of textColors) {
28275      // If there is no color, go no further.
28276      if (!item.color) {
28277        continue;
28278      }
28279      const colordTextColor = w(item.color);
28280      const isColordTextReadable = colordTextColor.isReadable(colordBackgroundColor, isReadableOptions);
28281      const textHasTransparency = colordTextColor.alpha() < 1;
28282  
28283      // If the contrast is not readable.
28284      if (!isColordTextReadable) {
28285        // Don't show the message if the background or text is transparent.
28286        if (backgroundColorHasTransparency || textHasTransparency) {
28287          continue;
28288        }
28289        message = backgroundColorBrightness < colordTextColor.brightness() ? (0,external_wp_i18n_namespaceObject.sprintf)(
28290        // translators: %s is a type of text color, e.g., "text color" or "link color".
28291        (0,external_wp_i18n_namespaceObject.__)('This color combination may be hard for people to read. Try using a darker background color and/or a brighter %s.'), item.description) : (0,external_wp_i18n_namespaceObject.sprintf)(
28292        // translators: %s is a type of text color, e.g., "text color" or "link color".
28293        (0,external_wp_i18n_namespaceObject.__)('This color combination may be hard for people to read. Try using a brighter background color and/or a darker %s.'), item.description);
28294        speakMessage = (0,external_wp_i18n_namespaceObject.__)('This color combination may be hard for people to read.');
28295        // Break from the loop when we have a contrast warning.
28296        // These messages take priority over the transparency warning.
28297        break;
28298      }
28299  
28300      // If there is no contrast warning and the text is transparent,
28301      // show the transparent warning if alpha check is enabled.
28302      if (textHasTransparency && enableAlphaChecker) {
28303        message = (0,external_wp_i18n_namespaceObject.__)('Transparent text may be hard for people to read.');
28304        speakMessage = (0,external_wp_i18n_namespaceObject.__)('Transparent text may be hard for people to read.');
28305      }
28306    }
28307    if (!message) {
28308      return null;
28309    }
28310  
28311    // Note: The `Notice` component can speak messages via its `spokenMessage`
28312    // prop, but the contrast checker requires granular control over when the
28313    // announcements are made. Notably, the message will be re-announced if a
28314    // new color combination is selected and the contrast is still insufficient.
28315    (0,external_wp_a11y_namespaceObject.speak)(speakMessage);
28316    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
28317      className: "block-editor-contrast-checker",
28318      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Notice, {
28319        spokenMessage: null,
28320        status: "warning",
28321        isDismissible: false,
28322        children: message
28323      })
28324    });
28325  }
28326  
28327  /**
28328   * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/contrast-checker/README.md
28329   */
28330  /* harmony default export */ const contrast_checker = (ContrastChecker);
28331  
28332  ;// ./node_modules/@wordpress/block-editor/build-module/components/provider/block-refs-provider.js
28333  /**
28334   * WordPress dependencies
28335   */
28336  
28337  
28338  
28339  const BlockRefs = (0,external_wp_element_namespaceObject.createContext)({
28340    refsMap: (0,external_wp_compose_namespaceObject.observableMap)()
28341  });
28342  function BlockRefsProvider({
28343    children
28344  }) {
28345    const value = (0,external_wp_element_namespaceObject.useMemo)(() => ({
28346      refsMap: (0,external_wp_compose_namespaceObject.observableMap)()
28347    }), []);
28348    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockRefs.Provider, {
28349      value: value,
28350      children: children
28351    });
28352  }
28353  
28354  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-list/use-block-props/use-block-refs.js
28355  /**
28356   * WordPress dependencies
28357   */
28358  
28359  
28360  
28361  /**
28362   * Internal dependencies
28363   */
28364  
28365  
28366  /** @typedef {import('@wordpress/element').RefCallback} RefCallback */
28367  /** @typedef {import('@wordpress/element').Ref} Ref */
28368  
28369  /**
28370   * Provides a ref to the BlockRefs context.
28371   *
28372   * @param {string} clientId The client ID of the element ref.
28373   *
28374   * @return {RefCallback} Ref callback.
28375   */
28376  function useBlockRefProvider(clientId) {
28377    const {
28378      refsMap
28379    } = (0,external_wp_element_namespaceObject.useContext)(BlockRefs);
28380    return (0,external_wp_compose_namespaceObject.useRefEffect)(element => {
28381      refsMap.set(clientId, element);
28382      return () => refsMap.delete(clientId);
28383    }, [clientId]);
28384  }
28385  function assignRef(ref, value) {
28386    if (typeof ref === 'function') {
28387      ref(value);
28388    } else if (ref) {
28389      ref.current = value;
28390    }
28391  }
28392  
28393  /**
28394   * Tracks the DOM element for the block identified by `clientId` and assigns it to the `ref`
28395   * whenever it changes.
28396   *
28397   * @param {string} clientId The client ID to track.
28398   * @param {Ref}    ref      The ref object/callback to assign to.
28399   */
28400  function useBlockElementRef(clientId, ref) {
28401    const {
28402      refsMap
28403    } = (0,external_wp_element_namespaceObject.useContext)(BlockRefs);
28404    (0,external_wp_element_namespaceObject.useLayoutEffect)(() => {
28405      assignRef(ref, refsMap.get(clientId));
28406      const unsubscribe = refsMap.subscribe(clientId, () => assignRef(ref, refsMap.get(clientId)));
28407      return () => {
28408        unsubscribe();
28409        assignRef(ref, null);
28410      };
28411    }, [refsMap, clientId, ref]);
28412  }
28413  
28414  /**
28415   * Return the element for a given client ID. Updates whenever the element
28416   * changes, becomes available, or disappears.
28417   *
28418   * @param {string} clientId The client ID to an element for.
28419   *
28420   * @return {Element|null} The block's wrapper element.
28421   */
28422  function useBlockElement(clientId) {
28423    const [blockElement, setBlockElement] = (0,external_wp_element_namespaceObject.useState)(null);
28424    useBlockElementRef(clientId, setBlockElement);
28425    return blockElement;
28426  }
28427  
28428  ;// ./node_modules/@wordpress/block-editor/build-module/hooks/contrast-checker.js
28429  /**
28430   * WordPress dependencies
28431   */
28432  
28433  
28434  /**
28435   * Internal dependencies
28436   */
28437  
28438  
28439  
28440  function getComputedValue(node, property) {
28441    return node.ownerDocument.defaultView.getComputedStyle(node).getPropertyValue(property);
28442  }
28443  function getBlockElementColors(blockEl) {
28444    if (!blockEl) {
28445      return {};
28446    }
28447    const firstLinkElement = blockEl.querySelector('a');
28448    const linkColor = !!firstLinkElement?.innerText ? getComputedValue(firstLinkElement, 'color') : undefined;
28449    const textColor = getComputedValue(blockEl, 'color');
28450    let backgroundColorNode = blockEl;
28451    let backgroundColor = getComputedValue(backgroundColorNode, 'background-color');
28452    while (backgroundColor === 'rgba(0, 0, 0, 0)' && backgroundColorNode.parentNode && backgroundColorNode.parentNode.nodeType === backgroundColorNode.parentNode.ELEMENT_NODE) {
28453      backgroundColorNode = backgroundColorNode.parentNode;
28454      backgroundColor = getComputedValue(backgroundColorNode, 'background-color');
28455    }
28456    return {
28457      textColor,
28458      backgroundColor,
28459      linkColor
28460    };
28461  }
28462  function contrast_checker_reducer(prevColors, newColors) {
28463    const hasChanged = Object.keys(newColors).some(key => prevColors[key] !== newColors[key]);
28464  
28465    // Do not re-render if the colors have not changed.
28466    return hasChanged ? newColors : prevColors;
28467  }
28468  function BlockColorContrastChecker({
28469    clientId
28470  }) {
28471    const blockEl = useBlockElement(clientId);
28472    const [colors, setColors] = (0,external_wp_element_namespaceObject.useReducer)(contrast_checker_reducer, {});
28473  
28474    // There are so many things that can change the color of a block
28475    // So we perform this check on every render.
28476    (0,external_wp_element_namespaceObject.useLayoutEffect)(() => {
28477      if (!blockEl) {
28478        return;
28479      }
28480      function updateColors() {
28481        setColors(getBlockElementColors(blockEl));
28482      }
28483  
28484      // Combine `useLayoutEffect` and two rAF calls to ensure that values are read
28485      // after the current paint but before the next paint.
28486      window.requestAnimationFrame(() => window.requestAnimationFrame(updateColors));
28487    });
28488    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(contrast_checker, {
28489      backgroundColor: colors.backgroundColor,
28490      textColor: colors.textColor,
28491      linkColor: colors.linkColor,
28492      enableAlphaChecker: true
28493    });
28494  }
28495  
28496  ;// ./node_modules/@wordpress/block-editor/build-module/hooks/color.js
28497  /**
28498   * External dependencies
28499   */
28500  
28501  
28502  /**
28503   * WordPress dependencies
28504   */
28505  
28506  
28507  
28508  
28509  
28510  /**
28511   * Internal dependencies
28512   */
28513  
28514  
28515  
28516  
28517  
28518  
28519  
28520  
28521  
28522  
28523  const COLOR_SUPPORT_KEY = 'color';
28524  const hasColorSupport = blockNameOrType => {
28525    const colorSupport = (0,external_wp_blocks_namespaceObject.getBlockSupport)(blockNameOrType, COLOR_SUPPORT_KEY);
28526    return colorSupport && (colorSupport.link === true || colorSupport.gradient === true || colorSupport.background !== false || colorSupport.text !== false);
28527  };
28528  const hasLinkColorSupport = blockType => {
28529    if (external_wp_element_namespaceObject.Platform.OS !== 'web') {
28530      return false;
28531    }
28532    const colorSupport = (0,external_wp_blocks_namespaceObject.getBlockSupport)(blockType, COLOR_SUPPORT_KEY);
28533    return colorSupport !== null && typeof colorSupport === 'object' && !!colorSupport.link;
28534  };
28535  const hasGradientSupport = blockNameOrType => {
28536    const colorSupport = (0,external_wp_blocks_namespaceObject.getBlockSupport)(blockNameOrType, COLOR_SUPPORT_KEY);
28537    return colorSupport !== null && typeof colorSupport === 'object' && !!colorSupport.gradients;
28538  };
28539  const hasBackgroundColorSupport = blockType => {
28540    const colorSupport = (0,external_wp_blocks_namespaceObject.getBlockSupport)(blockType, COLOR_SUPPORT_KEY);
28541    return colorSupport && colorSupport.background !== false;
28542  };
28543  const hasTextColorSupport = blockType => {
28544    const colorSupport = (0,external_wp_blocks_namespaceObject.getBlockSupport)(blockType, COLOR_SUPPORT_KEY);
28545    return colorSupport && colorSupport.text !== false;
28546  };
28547  
28548  /**
28549   * Filters registered block settings, extending attributes to include
28550   * `backgroundColor` and `textColor` attribute.
28551   *
28552   * @param {Object} settings Original block settings.
28553   *
28554   * @return {Object} Filtered block settings.
28555   */
28556  function color_addAttributes(settings) {
28557    if (!hasColorSupport(settings)) {
28558      return settings;
28559    }
28560  
28561    // Allow blocks to specify their own attribute definition with default values if needed.
28562    if (!settings.attributes.backgroundColor) {
28563      Object.assign(settings.attributes, {
28564        backgroundColor: {
28565          type: 'string'
28566        }
28567      });
28568    }
28569    if (!settings.attributes.textColor) {
28570      Object.assign(settings.attributes, {
28571        textColor: {
28572          type: 'string'
28573        }
28574      });
28575    }
28576    if (hasGradientSupport(settings) && !settings.attributes.gradient) {
28577      Object.assign(settings.attributes, {
28578        gradient: {
28579          type: 'string'
28580        }
28581      });
28582    }
28583    return settings;
28584  }
28585  
28586  /**
28587   * Override props assigned to save component to inject colors classnames.
28588   *
28589   * @param {Object}        props           Additional props applied to save element.
28590   * @param {Object|string} blockNameOrType Block type.
28591   * @param {Object}        attributes      Block attributes.
28592   *
28593   * @return {Object} Filtered props applied to save element.
28594   */
28595  function color_addSaveProps(props, blockNameOrType, attributes) {
28596    if (!hasColorSupport(blockNameOrType) || shouldSkipSerialization(blockNameOrType, COLOR_SUPPORT_KEY)) {
28597      return props;
28598    }
28599    const hasGradient = hasGradientSupport(blockNameOrType);
28600  
28601    // I'd have preferred to avoid the "style" attribute usage here
28602    const {
28603      backgroundColor,
28604      textColor,
28605      gradient,
28606      style
28607    } = attributes;
28608    const shouldSerialize = feature => !shouldSkipSerialization(blockNameOrType, COLOR_SUPPORT_KEY, feature);
28609  
28610    // Primary color classes must come before the `has-text-color`,
28611    // `has-background` and `has-link-color` classes to maintain backwards
28612    // compatibility and avoid block invalidations.
28613    const textClass = shouldSerialize('text') ? getColorClassName('color', textColor) : undefined;
28614    const gradientClass = shouldSerialize('gradients') ? __experimentalGetGradientClass(gradient) : undefined;
28615    const backgroundClass = shouldSerialize('background') ? getColorClassName('background-color', backgroundColor) : undefined;
28616    const serializeHasBackground = shouldSerialize('background') || shouldSerialize('gradients');
28617    const hasBackground = backgroundColor || style?.color?.background || hasGradient && (gradient || style?.color?.gradient);
28618    const newClassName = dist_clsx(props.className, textClass, gradientClass, {
28619      // Don't apply the background class if there's a custom gradient.
28620      [backgroundClass]: (!hasGradient || !style?.color?.gradient) && !!backgroundClass,
28621      'has-text-color': shouldSerialize('text') && (textColor || style?.color?.text),
28622      'has-background': serializeHasBackground && hasBackground,
28623      'has-link-color': shouldSerialize('link') && style?.elements?.link?.color
28624    });
28625    props.className = newClassName ? newClassName : undefined;
28626    return props;
28627  }
28628  function color_styleToAttributes(style) {
28629    const textColorValue = style?.color?.text;
28630    const textColorSlug = textColorValue?.startsWith('var:preset|color|') ? textColorValue.substring('var:preset|color|'.length) : undefined;
28631    const backgroundColorValue = style?.color?.background;
28632    const backgroundColorSlug = backgroundColorValue?.startsWith('var:preset|color|') ? backgroundColorValue.substring('var:preset|color|'.length) : undefined;
28633    const gradientValue = style?.color?.gradient;
28634    const gradientSlug = gradientValue?.startsWith('var:preset|gradient|') ? gradientValue.substring('var:preset|gradient|'.length) : undefined;
28635    const updatedStyle = {
28636      ...style
28637    };
28638    updatedStyle.color = {
28639      ...updatedStyle.color,
28640      text: textColorSlug ? undefined : textColorValue,
28641      background: backgroundColorSlug ? undefined : backgroundColorValue,
28642      gradient: gradientSlug ? undefined : gradientValue
28643    };
28644    return {
28645      style: utils_cleanEmptyObject(updatedStyle),
28646      textColor: textColorSlug,
28647      backgroundColor: backgroundColorSlug,
28648      gradient: gradientSlug
28649    };
28650  }
28651  function color_attributesToStyle(attributes) {
28652    return {
28653      ...attributes.style,
28654      color: {
28655        ...attributes.style?.color,
28656        text: attributes.textColor ? 'var:preset|color|' + attributes.textColor : attributes.style?.color?.text,
28657        background: attributes.backgroundColor ? 'var:preset|color|' + attributes.backgroundColor : attributes.style?.color?.background,
28658        gradient: attributes.gradient ? 'var:preset|gradient|' + attributes.gradient : attributes.style?.color?.gradient
28659      }
28660    };
28661  }
28662  function ColorInspectorControl({
28663    children,
28664    resetAllFilter
28665  }) {
28666    const attributesResetAllFilter = (0,external_wp_element_namespaceObject.useCallback)(attributes => {
28667      const existingStyle = color_attributesToStyle(attributes);
28668      const updatedStyle = resetAllFilter(existingStyle);
28669      return {
28670        ...attributes,
28671        ...color_styleToAttributes(updatedStyle)
28672      };
28673    }, [resetAllFilter]);
28674    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls, {
28675      group: "color",
28676      resetAllFilter: attributesResetAllFilter,
28677      children: children
28678    });
28679  }
28680  function ColorEdit({
28681    clientId,
28682    name,
28683    setAttributes,
28684    settings
28685  }) {
28686    const isEnabled = useHasColorPanel(settings);
28687    function selector(select) {
28688      const {
28689        style,
28690        textColor,
28691        backgroundColor,
28692        gradient
28693      } = select(store).getBlockAttributes(clientId) || {};
28694      return {
28695        style,
28696        textColor,
28697        backgroundColor,
28698        gradient
28699      };
28700    }
28701    const {
28702      style,
28703      textColor,
28704      backgroundColor,
28705      gradient
28706    } = (0,external_wp_data_namespaceObject.useSelect)(selector, [clientId]);
28707    const value = (0,external_wp_element_namespaceObject.useMemo)(() => {
28708      return color_attributesToStyle({
28709        style,
28710        textColor,
28711        backgroundColor,
28712        gradient
28713      });
28714    }, [style, textColor, backgroundColor, gradient]);
28715    const onChange = newStyle => {
28716      setAttributes(color_styleToAttributes(newStyle));
28717    };
28718    if (!isEnabled) {
28719      return null;
28720    }
28721    const defaultControls = (0,external_wp_blocks_namespaceObject.getBlockSupport)(name, [COLOR_SUPPORT_KEY, '__experimentalDefaultControls']);
28722    const enableContrastChecking = external_wp_element_namespaceObject.Platform.OS === 'web' && !value?.color?.gradient && (settings?.color?.text || settings?.color?.link) &&
28723    // Contrast checking is enabled by default.
28724    // Deactivating it requires `enableContrastChecker` to have
28725    // an explicit value of `false`.
28726    false !== (0,external_wp_blocks_namespaceObject.getBlockSupport)(name, [COLOR_SUPPORT_KEY, 'enableContrastChecker']);
28727    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ColorPanel, {
28728      as: ColorInspectorControl,
28729      panelId: clientId,
28730      settings: settings,
28731      value: value,
28732      onChange: onChange,
28733      defaultControls: defaultControls,
28734      enableContrastChecker: false !== (0,external_wp_blocks_namespaceObject.getBlockSupport)(name, [COLOR_SUPPORT_KEY, 'enableContrastChecker']),
28735      children: enableContrastChecking && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockColorContrastChecker, {
28736        clientId: clientId
28737      })
28738    });
28739  }
28740  function color_useBlockProps({
28741    name,
28742    backgroundColor,
28743    textColor,
28744    gradient,
28745    style
28746  }) {
28747    const [userPalette, themePalette, defaultPalette] = use_settings_useSettings('color.palette.custom', 'color.palette.theme', 'color.palette.default');
28748    const colors = (0,external_wp_element_namespaceObject.useMemo)(() => [...(userPalette || []), ...(themePalette || []), ...(defaultPalette || [])], [userPalette, themePalette, defaultPalette]);
28749    if (!hasColorSupport(name) || shouldSkipSerialization(name, COLOR_SUPPORT_KEY)) {
28750      return {};
28751    }
28752    const extraStyles = {};
28753    if (textColor && !shouldSkipSerialization(name, COLOR_SUPPORT_KEY, 'text')) {
28754      extraStyles.color = getColorObjectByAttributeValues(colors, textColor)?.color;
28755    }
28756    if (backgroundColor && !shouldSkipSerialization(name, COLOR_SUPPORT_KEY, 'background')) {
28757      extraStyles.backgroundColor = getColorObjectByAttributeValues(colors, backgroundColor)?.color;
28758    }
28759    const saveProps = color_addSaveProps({
28760      style: extraStyles
28761    }, name, {
28762      textColor,
28763      backgroundColor,
28764      gradient,
28765      style
28766    });
28767    const hasBackgroundValue = backgroundColor || style?.color?.background || gradient || style?.color?.gradient;
28768    return {
28769      ...saveProps,
28770      className: dist_clsx(saveProps.className,
28771      // Add background image classes in the editor, if not already handled by background color values.
28772      !hasBackgroundValue && getBackgroundImageClasses(style))
28773    };
28774  }
28775  /* harmony default export */ const color = ({
28776    useBlockProps: color_useBlockProps,
28777    addSaveProps: color_addSaveProps,
28778    attributeKeys: ['backgroundColor', 'textColor', 'gradient', 'style'],
28779    hasSupport: hasColorSupport
28780  });
28781  const MIGRATION_PATHS = {
28782    linkColor: [['style', 'elements', 'link', 'color', 'text']],
28783    textColor: [['textColor'], ['style', 'color', 'text']],
28784    backgroundColor: [['backgroundColor'], ['style', 'color', 'background']],
28785    gradient: [['gradient'], ['style', 'color', 'gradient']]
28786  };
28787  function color_addTransforms(result, source, index, results) {
28788    const destinationBlockType = result.name;
28789    const activeSupports = {
28790      linkColor: hasLinkColorSupport(destinationBlockType),
28791      textColor: hasTextColorSupport(destinationBlockType),
28792      backgroundColor: hasBackgroundColorSupport(destinationBlockType),
28793      gradient: hasGradientSupport(destinationBlockType)
28794    };
28795    return transformStyles(activeSupports, MIGRATION_PATHS, result, source, index, results);
28796  }
28797  (0,external_wp_hooks_namespaceObject.addFilter)('blocks.registerBlockType', 'core/color/addAttribute', color_addAttributes);
28798  (0,external_wp_hooks_namespaceObject.addFilter)('blocks.switchToBlockType.transformedBlock', 'core/color/addTransforms', color_addTransforms);
28799  
28800  ;// ./node_modules/@wordpress/block-editor/build-module/components/font-family/index.js
28801  /**
28802   * External dependencies
28803   */
28804  
28805  
28806  /**
28807   * WordPress dependencies
28808   */
28809  
28810  
28811  
28812  
28813  /**
28814   * Internal dependencies
28815   */
28816  
28817  
28818  function FontFamilyControl({
28819    /** Start opting into the larger default height that will become the default size in a future version. */
28820    __next40pxDefaultSize = false,
28821    /** Start opting into the new margin-free styles that will become the default in a future version. */
28822    __nextHasNoMarginBottom = false,
28823    value = '',
28824    onChange,
28825    fontFamilies,
28826    className,
28827    ...props
28828  }) {
28829    var _options$find;
28830    const [blockLevelFontFamilies] = use_settings_useSettings('typography.fontFamilies');
28831    if (!fontFamilies) {
28832      fontFamilies = blockLevelFontFamilies;
28833    }
28834    if (!fontFamilies || fontFamilies.length === 0) {
28835      return null;
28836    }
28837    const options = [{
28838      key: '',
28839      name: (0,external_wp_i18n_namespaceObject.__)('Default')
28840    }, ...fontFamilies.map(({
28841      fontFamily,
28842      name
28843    }) => ({
28844      key: fontFamily,
28845      name: name || fontFamily,
28846      style: {
28847        fontFamily
28848      }
28849    }))];
28850    if (!__nextHasNoMarginBottom) {
28851      external_wp_deprecated_default()('Bottom margin styles for wp.blockEditor.FontFamilyControl', {
28852        since: '6.7',
28853        version: '7.0',
28854        hint: 'Set the `__nextHasNoMarginBottom` prop to true to start opting into the new styles, which will become the default in a future version'
28855      });
28856    }
28857    if (!__next40pxDefaultSize && (props.size === undefined || props.size === 'default')) {
28858      external_wp_deprecated_default()(`36px default size for wp.blockEditor.__experimentalFontFamilyControl`, {
28859        since: '6.8',
28860        version: '7.1',
28861        hint: 'Set the `__next40pxDefaultSize` prop to true to start opting into the new default size, which will become the default in a future version.'
28862      });
28863    }
28864    const selectedValue = (_options$find = options.find(option => option.key === value)) !== null && _options$find !== void 0 ? _options$find : '';
28865    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.CustomSelectControl, {
28866      __next40pxDefaultSize: __next40pxDefaultSize,
28867      __shouldNotWarnDeprecated36pxSize: true,
28868      label: (0,external_wp_i18n_namespaceObject.__)('Font'),
28869      value: selectedValue,
28870      onChange: ({
28871        selectedItem
28872      }) => onChange(selectedItem.key),
28873      options: options,
28874      className: dist_clsx('block-editor-font-family-control', className, {
28875        'is-next-has-no-margin-bottom': __nextHasNoMarginBottom
28876      }),
28877      ...props
28878    });
28879  }
28880  
28881  ;// ./node_modules/@wordpress/block-editor/build-module/components/font-appearance-control/index.js
28882  /**
28883   * WordPress dependencies
28884   */
28885  
28886  
28887  
28888  
28889  
28890  /**
28891   * Internal dependencies
28892   */
28893  
28894  
28895  /**
28896   * Adjusts font appearance field label in case either font styles or weights
28897   * are disabled.
28898   *
28899   * @param {boolean} hasFontStyles  Whether font styles are enabled and present.
28900   * @param {boolean} hasFontWeights Whether font weights are enabled and present.
28901   * @return {string} A label representing what font appearance is being edited.
28902   */
28903  
28904  const getFontAppearanceLabel = (hasFontStyles, hasFontWeights) => {
28905    if (!hasFontStyles) {
28906      return (0,external_wp_i18n_namespaceObject.__)('Font weight');
28907    }
28908    if (!hasFontWeights) {
28909      return (0,external_wp_i18n_namespaceObject.__)('Font style');
28910    }
28911    return (0,external_wp_i18n_namespaceObject.__)('Appearance');
28912  };
28913  
28914  /**
28915   * Control to display font style and weight options of the active font.
28916   *
28917   * @param {Object} props Component props.
28918   *
28919   * @return {Element} Font appearance control.
28920   */
28921  function FontAppearanceControl(props) {
28922    const {
28923      /** Start opting into the larger default height that will become the default size in a future version. */
28924      __next40pxDefaultSize = false,
28925      onChange,
28926      hasFontStyles = true,
28927      hasFontWeights = true,
28928      fontFamilyFaces,
28929      value: {
28930        fontStyle,
28931        fontWeight
28932      },
28933      ...otherProps
28934    } = props;
28935    const hasStylesOrWeights = hasFontStyles || hasFontWeights;
28936    const label = getFontAppearanceLabel(hasFontStyles, hasFontWeights);
28937    const defaultOption = {
28938      key: 'default',
28939      name: (0,external_wp_i18n_namespaceObject.__)('Default'),
28940      style: {
28941        fontStyle: undefined,
28942        fontWeight: undefined
28943      }
28944    };
28945    const {
28946      fontStyles,
28947      fontWeights,
28948      combinedStyleAndWeightOptions
28949    } = getFontStylesAndWeights(fontFamilyFaces);
28950  
28951    // Generates select options for combined font styles and weights.
28952    const combineOptions = () => {
28953      const combinedOptions = [defaultOption];
28954      if (combinedStyleAndWeightOptions) {
28955        combinedOptions.push(...combinedStyleAndWeightOptions);
28956      }
28957      return combinedOptions;
28958    };
28959  
28960    // Generates select options for font styles only.
28961    const styleOptions = () => {
28962      const combinedOptions = [defaultOption];
28963      fontStyles.forEach(({
28964        name,
28965        value
28966      }) => {
28967        combinedOptions.push({
28968          key: value,
28969          name,
28970          style: {
28971            fontStyle: value,
28972            fontWeight: undefined
28973          }
28974        });
28975      });
28976      return combinedOptions;
28977    };
28978  
28979    // Generates select options for font weights only.
28980    const weightOptions = () => {
28981      const combinedOptions = [defaultOption];
28982      fontWeights.forEach(({
28983        name,
28984        value
28985      }) => {
28986        combinedOptions.push({
28987          key: value,
28988          name,
28989          style: {
28990            fontStyle: undefined,
28991            fontWeight: value
28992          }
28993        });
28994      });
28995      return combinedOptions;
28996    };
28997  
28998    // Map font styles and weights to select options.
28999    const selectOptions = (0,external_wp_element_namespaceObject.useMemo)(() => {
29000      // Display combined available font style and weight options.
29001      if (hasFontStyles && hasFontWeights) {
29002        return combineOptions();
29003      }
29004  
29005      // Display only font style options or font weight options.
29006      return hasFontStyles ? styleOptions() : weightOptions();
29007    }, [props.options, fontStyles, fontWeights, combinedStyleAndWeightOptions]);
29008  
29009    // Find current selection by comparing font style & weight against options,
29010    // and fall back to the Default option if there is no matching option.
29011    const currentSelection = selectOptions.find(option => option.style.fontStyle === fontStyle && option.style.fontWeight === fontWeight) || selectOptions[0];
29012  
29013    // Adjusts screen reader description based on styles or weights.
29014    const getDescribedBy = () => {
29015      if (!currentSelection) {
29016        return (0,external_wp_i18n_namespaceObject.__)('No selected font appearance');
29017      }
29018      if (!hasFontStyles) {
29019        return (0,external_wp_i18n_namespaceObject.sprintf)(
29020        // translators: %s: Currently selected font weight.
29021        (0,external_wp_i18n_namespaceObject.__)('Currently selected font weight: %s'), currentSelection.name);
29022      }
29023      if (!hasFontWeights) {
29024        return (0,external_wp_i18n_namespaceObject.sprintf)(
29025        // translators: %s: Currently selected font style.
29026        (0,external_wp_i18n_namespaceObject.__)('Currently selected font style: %s'), currentSelection.name);
29027      }
29028      return (0,external_wp_i18n_namespaceObject.sprintf)(
29029      // translators: %s: Currently selected font appearance.
29030      (0,external_wp_i18n_namespaceObject.__)('Currently selected font appearance: %s'), currentSelection.name);
29031    };
29032    if (!__next40pxDefaultSize && (otherProps.size === undefined || otherProps.size === 'default')) {
29033      external_wp_deprecated_default()(`36px default size for wp.blockEditor.__experimentalFontAppearanceControl`, {
29034        since: '6.8',
29035        version: '7.1',
29036        hint: 'Set the `__next40pxDefaultSize` prop to true to start opting into the new default size, which will become the default in a future version.'
29037      });
29038    }
29039    return hasStylesOrWeights && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.CustomSelectControl, {
29040      ...otherProps,
29041      className: "components-font-appearance-control",
29042      __next40pxDefaultSize: __next40pxDefaultSize,
29043      __shouldNotWarnDeprecated36pxSize: true,
29044      label: label,
29045      describedBy: getDescribedBy(),
29046      options: selectOptions,
29047      value: currentSelection,
29048      onChange: ({
29049        selectedItem
29050      }) => onChange(selectedItem.style)
29051    });
29052  }
29053  
29054  ;// ./node_modules/@wordpress/block-editor/build-module/components/line-height-control/utils.js
29055  const BASE_DEFAULT_VALUE = 1.5;
29056  const STEP = 0.01;
29057  /**
29058   * A spin factor of 10 allows the spin controls to increment/decrement by 0.1.
29059   * e.g. A line-height value of 1.55 will increment to 1.65.
29060   */
29061  const SPIN_FACTOR = 10;
29062  /**
29063   * There are varying value types within LineHeightControl:
29064   *
29065   * {undefined} Initial value. No changes from the user.
29066   * {string} Input value. Value consumed/outputted by the input. Empty would be ''.
29067   * {number} Block attribute type. Input value needs to be converted for attribute setting.
29068   *
29069   * Note: If the value is undefined, the input requires it to be an empty string ('')
29070   * in order to be considered "controlled" by props (rather than internal state).
29071   */
29072  const RESET_VALUE = '';
29073  
29074  /**
29075   * Determines if the lineHeight attribute has been properly defined.
29076   *
29077   * @param {any} lineHeight The value to check.
29078   *
29079   * @return {boolean} Whether the lineHeight attribute is valid.
29080   */
29081  function isLineHeightDefined(lineHeight) {
29082    return lineHeight !== undefined && lineHeight !== RESET_VALUE;
29083  }
29084  
29085  ;// ./node_modules/@wordpress/block-editor/build-module/components/line-height-control/index.js
29086  /**
29087   * WordPress dependencies
29088   */
29089  
29090  
29091  
29092  
29093  /**
29094   * Internal dependencies
29095   */
29096  
29097  
29098  const line_height_control_LineHeightControl = ({
29099    /** Start opting into the larger default height that will become the default size in a future version. */
29100    __next40pxDefaultSize = false,
29101    value: lineHeight,
29102    onChange,
29103    __unstableInputWidth = '60px',
29104    ...otherProps
29105  }) => {
29106    const isDefined = isLineHeightDefined(lineHeight);
29107    const adjustNextValue = (nextValue, wasTypedOrPasted) => {
29108      // Set the next value without modification if lineHeight has been defined.
29109      if (isDefined) {
29110        return nextValue;
29111      }
29112  
29113      /**
29114       * The following logic handles the initial spin up/down action
29115       * (from an undefined value state) so that the next values are better suited for
29116       * line-height rendering. For example, the first spin up should immediately
29117       * go to 1.6, rather than the normally expected 0.1.
29118       *
29119       * Spin up/down actions can be triggered by keydowns of the up/down arrow keys,
29120       * dragging the input or by clicking the spin buttons.
29121       */
29122      const spin = STEP * SPIN_FACTOR;
29123      switch (`$nextValue}`) {
29124        case `$spin}`:
29125          // Increment by spin value.
29126          return BASE_DEFAULT_VALUE + spin;
29127        case '0':
29128          {
29129            // This means the user explicitly input '0', rather than using the
29130            // spin down action from an undefined value state.
29131            if (wasTypedOrPasted) {
29132              return nextValue;
29133            }
29134            // Decrement by spin value.
29135            return BASE_DEFAULT_VALUE - spin;
29136          }
29137        case '':
29138          return BASE_DEFAULT_VALUE;
29139        default:
29140          return nextValue;
29141      }
29142    };
29143    const stateReducer = (state, action) => {
29144      // Be careful when changing this — cross-browser behavior of the
29145      // `inputType` field in `input` events are inconsistent.
29146      // For example, Firefox emits an input event with inputType="insertReplacementText"
29147      // on spin button clicks, while other browsers do not even emit an input event.
29148      const wasTypedOrPasted = ['insertText', 'insertFromPaste'].includes(action.payload.event.nativeEvent?.inputType);
29149      const value = adjustNextValue(state.value, wasTypedOrPasted);
29150      return {
29151        ...state,
29152        value
29153      };
29154    };
29155    const value = isDefined ? lineHeight : RESET_VALUE;
29156    const handleOnChange = (nextValue, {
29157      event
29158    }) => {
29159      if (nextValue === '') {
29160        onChange();
29161        return;
29162      }
29163      if (event.type === 'click') {
29164        onChange(adjustNextValue(`$nextValue}`, false));
29165        return;
29166      }
29167      onChange(`$nextValue}`);
29168    };
29169    if (!__next40pxDefaultSize && (otherProps.size === undefined || otherProps.size === 'default')) {
29170      external_wp_deprecated_default()(`36px default size for wp.blockEditor.LineHeightControl`, {
29171        since: '6.8',
29172        version: '7.1',
29173        hint: 'Set the `__next40pxDefaultSize` prop to true to start opting into the new default size, which will become the default in a future version.'
29174      });
29175    }
29176    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
29177      className: "block-editor-line-height-control",
29178      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalNumberControl, {
29179        ...otherProps,
29180        __shouldNotWarnDeprecated36pxSize: true,
29181        __next40pxDefaultSize: __next40pxDefaultSize,
29182        __unstableInputWidth: __unstableInputWidth,
29183        __unstableStateReducer: stateReducer,
29184        onChange: handleOnChange,
29185        label: (0,external_wp_i18n_namespaceObject.__)('Line height'),
29186        placeholder: BASE_DEFAULT_VALUE,
29187        step: STEP,
29188        spinFactor: SPIN_FACTOR,
29189        value: value,
29190        min: 0,
29191        spinControls: "custom"
29192      })
29193    });
29194  };
29195  
29196  /**
29197   * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/line-height-control/README.md
29198   */
29199  /* harmony default export */ const line_height_control = (line_height_control_LineHeightControl);
29200  
29201  ;// ./node_modules/@wordpress/block-editor/build-module/components/letter-spacing-control/index.js
29202  /**
29203   * WordPress dependencies
29204   */
29205  
29206  
29207  
29208  
29209  /**
29210   * Internal dependencies
29211   */
29212  
29213  
29214  /**
29215   * Control for letter-spacing.
29216   *
29217   * @param {Object}                  props                       Component props.
29218   * @param {boolean}                 props.__next40pxDefaultSize Start opting into the larger default height that will become the default size in a future version.
29219   * @param {string}                  props.value                 Currently selected letter-spacing.
29220   * @param {Function}                props.onChange              Handles change in letter-spacing selection.
29221   * @param {string|number|undefined} props.__unstableInputWidth  Input width to pass through to inner UnitControl. Should be a valid CSS value.
29222   *
29223   * @return {Element} Letter-spacing control.
29224   */
29225  
29226  function LetterSpacingControl({
29227    __next40pxDefaultSize = false,
29228    value,
29229    onChange,
29230    __unstableInputWidth = '60px',
29231    ...otherProps
29232  }) {
29233    const [availableUnits] = use_settings_useSettings('spacing.units');
29234    const units = (0,external_wp_components_namespaceObject.__experimentalUseCustomUnits)({
29235      availableUnits: availableUnits || ['px', 'em', 'rem'],
29236      defaultValues: {
29237        px: 2,
29238        em: 0.2,
29239        rem: 0.2
29240      }
29241    });
29242    if (!__next40pxDefaultSize && (otherProps.size === undefined || otherProps.size === 'default')) {
29243      external_wp_deprecated_default()(`36px default size for wp.blockEditor.__experimentalLetterSpacingControl`, {
29244        since: '6.8',
29245        version: '7.1',
29246        hint: 'Set the `__next40pxDefaultSize` prop to true to start opting into the new default size, which will become the default in a future version.'
29247      });
29248    }
29249    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalUnitControl, {
29250      __next40pxDefaultSize: __next40pxDefaultSize,
29251      __shouldNotWarnDeprecated36pxSize: true,
29252      ...otherProps,
29253      label: (0,external_wp_i18n_namespaceObject.__)('Letter spacing'),
29254      value: value,
29255      __unstableInputWidth: __unstableInputWidth,
29256      units: units,
29257      onChange: onChange
29258    });
29259  }
29260  
29261  ;// ./node_modules/@wordpress/icons/build-module/library/align-left.js
29262  /**
29263   * WordPress dependencies
29264   */
29265  
29266  
29267  const alignLeft = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
29268    xmlns: "http://www.w3.org/2000/svg",
29269    viewBox: "0 0 24 24",
29270    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
29271      d: "M13 5.5H4V4h9v1.5Zm7 7H4V11h16v1.5Zm-7 7H4V18h9v1.5Z"
29272    })
29273  });
29274  /* harmony default export */ const align_left = (alignLeft);
29275  
29276  ;// ./node_modules/@wordpress/icons/build-module/library/align-center.js
29277  /**
29278   * WordPress dependencies
29279   */
29280  
29281  
29282  const alignCenter = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
29283    xmlns: "http://www.w3.org/2000/svg",
29284    viewBox: "0 0 24 24",
29285    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
29286      d: "M7.5 5.5h9V4h-9v1.5Zm-3.5 7h16V11H4v1.5Zm3.5 7h9V18h-9v1.5Z"
29287    })
29288  });
29289  /* harmony default export */ const align_center = (alignCenter);
29290  
29291  ;// ./node_modules/@wordpress/icons/build-module/library/align-right.js
29292  /**
29293   * WordPress dependencies
29294   */
29295  
29296  
29297  const alignRight = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
29298    xmlns: "http://www.w3.org/2000/svg",
29299    viewBox: "0 0 24 24",
29300    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
29301      d: "M11.111 5.5H20V4h-8.889v1.5ZM4 12.5h16V11H4v1.5Zm7.111 7H20V18h-8.889v1.5Z"
29302    })
29303  });
29304  /* harmony default export */ const align_right = (alignRight);
29305  
29306  ;// ./node_modules/@wordpress/icons/build-module/library/align-justify.js
29307  /**
29308   * WordPress dependencies
29309   */
29310  
29311  
29312  const alignJustify = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
29313    xmlns: "http://www.w3.org/2000/svg",
29314    viewBox: "0 0 24 24",
29315    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
29316      d: "M4 12.8h16v-1.5H4v1.5zm0 7h12.4v-1.5H4v1.5zM4 4.3v1.5h16V4.3H4z"
29317    })
29318  });
29319  /* harmony default export */ const align_justify = (alignJustify);
29320  
29321  ;// ./node_modules/@wordpress/block-editor/build-module/components/text-alignment-control/index.js
29322  /**
29323   * External dependencies
29324   */
29325  
29326  
29327  /**
29328   * WordPress dependencies
29329   */
29330  
29331  
29332  
29333  
29334  
29335  const TEXT_ALIGNMENT_OPTIONS = [{
29336    label: (0,external_wp_i18n_namespaceObject.__)('Align text left'),
29337    value: 'left',
29338    icon: align_left
29339  }, {
29340    label: (0,external_wp_i18n_namespaceObject.__)('Align text center'),
29341    value: 'center',
29342    icon: align_center
29343  }, {
29344    label: (0,external_wp_i18n_namespaceObject.__)('Align text right'),
29345    value: 'right',
29346    icon: align_right
29347  }, {
29348    label: (0,external_wp_i18n_namespaceObject.__)('Justify text'),
29349    value: 'justify',
29350    icon: align_justify
29351  }];
29352  const DEFAULT_OPTIONS = ['left', 'center', 'right'];
29353  
29354  /**
29355   * Control to facilitate text alignment selections.
29356   *
29357   * @param {Object}   props           Component props.
29358   * @param {string}   props.className Class name to add to the control.
29359   * @param {string}   props.value     Currently selected text alignment.
29360   * @param {Function} props.onChange  Handles change in text alignment selection.
29361   * @param {string[]} props.options   Array of text alignment options to display.
29362   *
29363   * @return {Element} Text alignment control.
29364   */
29365  function TextAlignmentControl({
29366    className,
29367    value,
29368    onChange,
29369    options = DEFAULT_OPTIONS
29370  }) {
29371    const validOptions = (0,external_wp_element_namespaceObject.useMemo)(() => TEXT_ALIGNMENT_OPTIONS.filter(option => options.includes(option.value)), [options]);
29372    if (!validOptions.length) {
29373      return null;
29374    }
29375    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControl, {
29376      isDeselectable: true,
29377      __nextHasNoMarginBottom: true,
29378      __next40pxDefaultSize: true,
29379      label: (0,external_wp_i18n_namespaceObject.__)('Text alignment'),
29380      className: dist_clsx('block-editor-text-alignment-control', className),
29381      value: value,
29382      onChange: newValue => {
29383        onChange(newValue === value ? undefined : newValue);
29384      },
29385      children: validOptions.map(option => {
29386        return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControlOptionIcon, {
29387          value: option.value,
29388          icon: option.icon,
29389          label: option.label
29390        }, option.value);
29391      })
29392    });
29393  }
29394  
29395  ;// ./node_modules/@wordpress/icons/build-module/library/format-uppercase.js
29396  /**
29397   * WordPress dependencies
29398   */
29399  
29400  
29401  const formatUppercase = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
29402    xmlns: "http://www.w3.org/2000/svg",
29403    viewBox: "0 0 24 24",
29404    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
29405      d: "M6.1 6.8L2.1 18h1.6l1.1-3h4.3l1.1 3h1.6l-4-11.2H6.1zm-.8 6.8L7 8.9l1.7 4.7H5.3zm15.1-.7c-.4-.5-.9-.8-1.6-1 .4-.2.7-.5.8-.9.2-.4.3-.9.3-1.4 0-.9-.3-1.6-.8-2-.6-.5-1.3-.7-2.4-.7h-3.5V18h4.2c1.1 0 2-.3 2.6-.8.6-.6 1-1.4 1-2.4-.1-.8-.3-1.4-.6-1.9zm-5.7-4.7h1.8c.6 0 1.1.1 1.4.4.3.2.5.7.5 1.3 0 .6-.2 1.1-.5 1.3-.3.2-.8.4-1.4.4h-1.8V8.2zm4 8c-.4.3-.9.5-1.5.5h-2.6v-3.8h2.6c1.4 0 2 .6 2 1.9.1.6-.1 1-.5 1.4z"
29406    })
29407  });
29408  /* harmony default export */ const format_uppercase = (formatUppercase);
29409  
29410  ;// ./node_modules/@wordpress/icons/build-module/library/format-lowercase.js
29411  /**
29412   * WordPress dependencies
29413   */
29414  
29415  
29416  const formatLowercase = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
29417    xmlns: "http://www.w3.org/2000/svg",
29418    viewBox: "0 0 24 24",
29419    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
29420      d: "M11 16.8c-.1-.1-.2-.3-.3-.5v-2.6c0-.9-.1-1.7-.3-2.2-.2-.5-.5-.9-.9-1.2-.4-.2-.9-.3-1.6-.3-.5 0-1 .1-1.5.2s-.9.3-1.2.6l.2 1.2c.4-.3.7-.4 1.1-.5.3-.1.7-.2 1-.2.6 0 1 .1 1.3.4.3.2.4.7.4 1.4-1.2 0-2.3.2-3.3.7s-1.4 1.1-1.4 2.1c0 .7.2 1.2.7 1.6.4.4 1 .6 1.8.6.9 0 1.7-.4 2.4-1.2.1.3.2.5.4.7.1.2.3.3.6.4.3.1.6.1 1.1.1h.1l.2-1.2h-.1c-.4.1-.6 0-.7-.1zM9.2 16c-.2.3-.5.6-.9.8-.3.1-.7.2-1.1.2-.4 0-.7-.1-.9-.3-.2-.2-.3-.5-.3-.9 0-.6.2-1 .7-1.3.5-.3 1.3-.4 2.5-.5v2zm10.6-3.9c-.3-.6-.7-1.1-1.2-1.5-.6-.4-1.2-.6-1.9-.6-.5 0-.9.1-1.4.3-.4.2-.8.5-1.1.8V6h-1.4v12h1.3l.2-1c.2.4.6.6 1 .8.4.2.9.3 1.4.3.7 0 1.2-.2 1.8-.5.5-.4 1-.9 1.3-1.5.3-.6.5-1.3.5-2.1-.1-.6-.2-1.3-.5-1.9zm-1.7 4c-.4.5-.9.8-1.6.8s-1.2-.2-1.7-.7c-.4-.5-.7-1.2-.7-2.1 0-.9.2-1.6.7-2.1.4-.5 1-.7 1.7-.7s1.2.3 1.6.8c.4.5.6 1.2.6 2s-.2 1.4-.6 2z"
29421    })
29422  });
29423  /* harmony default export */ const format_lowercase = (formatLowercase);
29424  
29425  ;// ./node_modules/@wordpress/icons/build-module/library/format-capitalize.js
29426  /**
29427   * WordPress dependencies
29428   */
29429  
29430  
29431  const formatCapitalize = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
29432    xmlns: "http://www.w3.org/2000/svg",
29433    viewBox: "0 0 24 24",
29434    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
29435      d: "M7.1 6.8L3.1 18h1.6l1.1-3h4.3l1.1 3h1.6l-4-11.2H7.1zm-.8 6.8L8 8.9l1.7 4.7H6.3zm14.5-1.5c-.3-.6-.7-1.1-1.2-1.5-.6-.4-1.2-.6-1.9-.6-.5 0-.9.1-1.4.3-.4.2-.8.5-1.1.8V6h-1.4v12h1.3l.2-1c.2.4.6.6 1 .8.4.2.9.3 1.4.3.7 0 1.2-.2 1.8-.5.5-.4 1-.9 1.3-1.5.3-.6.5-1.3.5-2.1-.1-.6-.2-1.3-.5-1.9zm-1.7 4c-.4.5-.9.8-1.6.8s-1.2-.2-1.7-.7c-.4-.5-.7-1.2-.7-2.1 0-.9.2-1.6.7-2.1.4-.5 1-.7 1.7-.7s1.2.3 1.6.8c.4.5.6 1.2.6 2 .1.8-.2 1.4-.6 2z"
29436    })
29437  });
29438  /* harmony default export */ const format_capitalize = (formatCapitalize);
29439  
29440  ;// ./node_modules/@wordpress/block-editor/build-module/components/text-transform-control/index.js
29441  /**
29442   * External dependencies
29443   */
29444  
29445  
29446  /**
29447   * WordPress dependencies
29448   */
29449  
29450  
29451  
29452  
29453  const TEXT_TRANSFORMS = [{
29454    label: (0,external_wp_i18n_namespaceObject.__)('None'),
29455    value: 'none',
29456    icon: library_reset
29457  }, {
29458    label: (0,external_wp_i18n_namespaceObject.__)('Uppercase'),
29459    value: 'uppercase',
29460    icon: format_uppercase
29461  }, {
29462    label: (0,external_wp_i18n_namespaceObject.__)('Lowercase'),
29463    value: 'lowercase',
29464    icon: format_lowercase
29465  }, {
29466    label: (0,external_wp_i18n_namespaceObject.__)('Capitalize'),
29467    value: 'capitalize',
29468    icon: format_capitalize
29469  }];
29470  
29471  /**
29472   * Control to facilitate text transform selections.
29473   *
29474   * @param {Object}   props           Component props.
29475   * @param {string}   props.className Class name to add to the control.
29476   * @param {string}   props.value     Currently selected text transform.
29477   * @param {Function} props.onChange  Handles change in text transform selection.
29478   *
29479   * @return {Element} Text transform control.
29480   */
29481  function TextTransformControl({
29482    className,
29483    value,
29484    onChange
29485  }) {
29486    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControl, {
29487      isDeselectable: true,
29488      __nextHasNoMarginBottom: true,
29489      __next40pxDefaultSize: true,
29490      label: (0,external_wp_i18n_namespaceObject.__)('Letter case'),
29491      className: dist_clsx('block-editor-text-transform-control', className),
29492      value: value,
29493      onChange: newValue => {
29494        onChange(newValue === value ? undefined : newValue);
29495      },
29496      children: TEXT_TRANSFORMS.map(option => {
29497        return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControlOptionIcon, {
29498          value: option.value,
29499          icon: option.icon,
29500          label: option.label
29501        }, option.value);
29502      })
29503    });
29504  }
29505  
29506  ;// ./node_modules/@wordpress/icons/build-module/library/format-underline.js
29507  /**
29508   * WordPress dependencies
29509   */
29510  
29511  
29512  const formatUnderline = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
29513    xmlns: "http://www.w3.org/2000/svg",
29514    viewBox: "0 0 24 24",
29515    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
29516      d: "M7 18v1h10v-1H7zm5-2c1.5 0 2.6-.4 3.4-1.2.8-.8 1.1-2 1.1-3.5V5H15v5.8c0 1.2-.2 2.1-.6 2.8-.4.7-1.2 1-2.4 1s-2-.3-2.4-1c-.4-.7-.6-1.6-.6-2.8V5H7.5v6.2c0 1.5.4 2.7 1.1 3.5.8.9 1.9 1.3 3.4 1.3z"
29517    })
29518  });
29519  /* harmony default export */ const format_underline = (formatUnderline);
29520  
29521  ;// ./node_modules/@wordpress/icons/build-module/library/format-strikethrough.js
29522  /**
29523   * WordPress dependencies
29524   */
29525  
29526  
29527  const formatStrikethrough = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
29528    xmlns: "http://www.w3.org/2000/svg",
29529    viewBox: "0 0 24 24",
29530    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
29531      d: "M9.1 9v-.5c0-.6.2-1.1.7-1.4.5-.3 1.2-.5 2-.5.7 0 1.4.1 2.1.3.7.2 1.4.5 2.1.9l.2-1.9c-.6-.3-1.2-.5-1.9-.7-.8-.1-1.6-.2-2.4-.2-1.5 0-2.7.3-3.6 1-.8.7-1.2 1.5-1.2 2.6V9h2zM20 12H4v1h8.3c.3.1.6.2.8.3.5.2.9.5 1.1.8.3.3.4.7.4 1.2 0 .7-.2 1.1-.8 1.5-.5.3-1.2.5-2.1.5-.8 0-1.6-.1-2.4-.3-.8-.2-1.5-.5-2.2-.8L7 18.1c.5.2 1.2.4 2 .6.8.2 1.6.3 2.4.3 1.7 0 3-.3 3.9-1 .9-.7 1.3-1.6 1.3-2.8 0-.9-.2-1.7-.7-2.2H20v-1z"
29532    })
29533  });
29534  /* harmony default export */ const format_strikethrough = (formatStrikethrough);
29535  
29536  ;// ./node_modules/@wordpress/block-editor/build-module/components/text-decoration-control/index.js
29537  /**
29538   * External dependencies
29539   */
29540  
29541  
29542  /**
29543   * WordPress dependencies
29544   */
29545  
29546  
29547  
29548  
29549  const TEXT_DECORATIONS = [{
29550    label: (0,external_wp_i18n_namespaceObject.__)('None'),
29551    value: 'none',
29552    icon: library_reset
29553  }, {
29554    label: (0,external_wp_i18n_namespaceObject.__)('Underline'),
29555    value: 'underline',
29556    icon: format_underline
29557  }, {
29558    label: (0,external_wp_i18n_namespaceObject.__)('Strikethrough'),
29559    value: 'line-through',
29560    icon: format_strikethrough
29561  }];
29562  
29563  /**
29564   * Control to facilitate text decoration selections.
29565   *
29566   * @param {Object}   props           Component props.
29567   * @param {string}   props.value     Currently selected text decoration.
29568   * @param {Function} props.onChange  Handles change in text decoration selection.
29569   * @param {string}   props.className Additional class name to apply.
29570   *
29571   * @return {Element} Text decoration control.
29572   */
29573  function TextDecorationControl({
29574    value,
29575    onChange,
29576    className
29577  }) {
29578    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControl, {
29579      isDeselectable: true,
29580      __nextHasNoMarginBottom: true,
29581      __next40pxDefaultSize: true,
29582      label: (0,external_wp_i18n_namespaceObject.__)('Decoration'),
29583      className: dist_clsx('block-editor-text-decoration-control', className),
29584      value: value,
29585      onChange: newValue => {
29586        onChange(newValue === value ? undefined : newValue);
29587      },
29588      children: TEXT_DECORATIONS.map(option => {
29589        return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControlOptionIcon, {
29590          value: option.value,
29591          icon: option.icon,
29592          label: option.label
29593        }, option.value);
29594      })
29595    });
29596  }
29597  
29598  ;// ./node_modules/@wordpress/icons/build-module/library/text-horizontal.js
29599  /**
29600   * WordPress dependencies
29601   */
29602  
29603  
29604  const textHorizontal = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
29605    xmlns: "http://www.w3.org/2000/svg",
29606    viewBox: "0 0 24 24",
29607    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
29608      d: "M8.2 14.4h3.9L13 17h1.7L11 6.5H9.3L5.6 17h1.7l.9-2.6zm2-5.5 1.4 4H8.8l1.4-4zm7.4 7.5-1.3.8.8 1.4H5.5V20h14.3l-2.2-3.6z"
29609    })
29610  });
29611  /* harmony default export */ const text_horizontal = (textHorizontal);
29612  
29613  ;// ./node_modules/@wordpress/icons/build-module/library/text-vertical.js
29614  /**
29615   * WordPress dependencies
29616   */
29617  
29618  
29619  const textVertical = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
29620    xmlns: "http://www.w3.org/2000/svg",
29621    viewBox: "0 0 24 24",
29622    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
29623      d: "M7 5.6v1.7l2.6.9v3.9L7 13v1.7L17.5 11V9.3L7 5.6zm4.2 6V8.8l4 1.4-4 1.4zm-5.7 5.6V5.5H4v14.3l3.6-2.2-.8-1.3-1.3.9z"
29624    })
29625  });
29626  /* harmony default export */ const text_vertical = (textVertical);
29627  
29628  ;// ./node_modules/@wordpress/block-editor/build-module/components/writing-mode-control/index.js
29629  /**
29630   * External dependencies
29631   */
29632  
29633  
29634  /**
29635   * WordPress dependencies
29636   */
29637  
29638  
29639  
29640  
29641  const WRITING_MODES = [{
29642    label: (0,external_wp_i18n_namespaceObject.__)('Horizontal'),
29643    value: 'horizontal-tb',
29644    icon: text_horizontal
29645  }, {
29646    label: (0,external_wp_i18n_namespaceObject.__)('Vertical'),
29647    value: (0,external_wp_i18n_namespaceObject.isRTL)() ? 'vertical-lr' : 'vertical-rl',
29648    icon: text_vertical
29649  }];
29650  
29651  /**
29652   * Control to facilitate writing mode selections.
29653   *
29654   * @param {Object}   props           Component props.
29655   * @param {string}   props.className Class name to add to the control.
29656   * @param {string}   props.value     Currently selected writing mode.
29657   * @param {Function} props.onChange  Handles change in the writing mode selection.
29658   *
29659   * @return {Element} Writing Mode control.
29660   */
29661  function WritingModeControl({
29662    className,
29663    value,
29664    onChange
29665  }) {
29666    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControl, {
29667      isDeselectable: true,
29668      __nextHasNoMarginBottom: true,
29669      __next40pxDefaultSize: true,
29670      label: (0,external_wp_i18n_namespaceObject.__)('Orientation'),
29671      className: dist_clsx('block-editor-writing-mode-control', className),
29672      value: value,
29673      onChange: newValue => {
29674        onChange(newValue === value ? undefined : newValue);
29675      },
29676      children: WRITING_MODES.map(option => {
29677        return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControlOptionIcon, {
29678          value: option.value,
29679          icon: option.icon,
29680          label: option.label
29681        }, option.value);
29682      })
29683    });
29684  }
29685  
29686  ;// ./node_modules/@wordpress/block-editor/build-module/components/global-styles/typography-panel.js
29687  /**
29688   * WordPress dependencies
29689   */
29690  
29691  
29692  
29693  
29694  /**
29695   * Internal dependencies
29696   */
29697  
29698  
29699  
29700  
29701  
29702  
29703  
29704  
29705  
29706  
29707  
29708  
29709  const MIN_TEXT_COLUMNS = 1;
29710  const MAX_TEXT_COLUMNS = 6;
29711  function useHasTypographyPanel(settings) {
29712    const hasFontFamily = useHasFontFamilyControl(settings);
29713    const hasLineHeight = useHasLineHeightControl(settings);
29714    const hasFontAppearance = useHasAppearanceControl(settings);
29715    const hasLetterSpacing = useHasLetterSpacingControl(settings);
29716    const hasTextAlign = useHasTextAlignmentControl(settings);
29717    const hasTextTransform = useHasTextTransformControl(settings);
29718    const hasTextDecoration = useHasTextDecorationControl(settings);
29719    const hasWritingMode = useHasWritingModeControl(settings);
29720    const hasTextColumns = useHasTextColumnsControl(settings);
29721    const hasFontSize = useHasFontSizeControl(settings);
29722    return hasFontFamily || hasLineHeight || hasFontAppearance || hasLetterSpacing || hasTextAlign || hasTextTransform || hasFontSize || hasTextDecoration || hasWritingMode || hasTextColumns;
29723  }
29724  function useHasFontSizeControl(settings) {
29725    return settings?.typography?.defaultFontSizes !== false && settings?.typography?.fontSizes?.default?.length || settings?.typography?.fontSizes?.theme?.length || settings?.typography?.fontSizes?.custom?.length || settings?.typography?.customFontSize;
29726  }
29727  function useHasFontFamilyControl(settings) {
29728    return ['default', 'theme', 'custom'].some(key => settings?.typography?.fontFamilies?.[key]?.length);
29729  }
29730  function useHasLineHeightControl(settings) {
29731    return settings?.typography?.lineHeight;
29732  }
29733  function useHasAppearanceControl(settings) {
29734    return settings?.typography?.fontStyle || settings?.typography?.fontWeight;
29735  }
29736  function useAppearanceControlLabel(settings) {
29737    if (!settings?.typography?.fontStyle) {
29738      return (0,external_wp_i18n_namespaceObject.__)('Font weight');
29739    }
29740    if (!settings?.typography?.fontWeight) {
29741      return (0,external_wp_i18n_namespaceObject.__)('Font style');
29742    }
29743    return (0,external_wp_i18n_namespaceObject.__)('Appearance');
29744  }
29745  function useHasLetterSpacingControl(settings) {
29746    return settings?.typography?.letterSpacing;
29747  }
29748  function useHasTextTransformControl(settings) {
29749    return settings?.typography?.textTransform;
29750  }
29751  function useHasTextAlignmentControl(settings) {
29752    return settings?.typography?.textAlign;
29753  }
29754  function useHasTextDecorationControl(settings) {
29755    return settings?.typography?.textDecoration;
29756  }
29757  function useHasWritingModeControl(settings) {
29758    return settings?.typography?.writingMode;
29759  }
29760  function useHasTextColumnsControl(settings) {
29761    return settings?.typography?.textColumns;
29762  }
29763  
29764  /**
29765   * Concatenate all the font sizes into a single list for the font size picker.
29766   *
29767   * @param {Object} settings The global styles settings.
29768   *
29769   * @return {Array} The merged font sizes.
29770   */
29771  function getMergedFontSizes(settings) {
29772    var _fontSizes$custom, _fontSizes$theme, _fontSizes$default;
29773    const fontSizes = settings?.typography?.fontSizes;
29774    const defaultFontSizesEnabled = !!settings?.typography?.defaultFontSizes;
29775    return [...((_fontSizes$custom = fontSizes?.custom) !== null && _fontSizes$custom !== void 0 ? _fontSizes$custom : []), ...((_fontSizes$theme = fontSizes?.theme) !== null && _fontSizes$theme !== void 0 ? _fontSizes$theme : []), ...(defaultFontSizesEnabled ? (_fontSizes$default = fontSizes?.default) !== null && _fontSizes$default !== void 0 ? _fontSizes$default : [] : [])];
29776  }
29777  function TypographyToolsPanel({
29778    resetAllFilter,
29779    onChange,
29780    value,
29781    panelId,
29782    children
29783  }) {
29784    const dropdownMenuProps = useToolsPanelDropdownMenuProps();
29785    const resetAll = () => {
29786      const updatedValue = resetAllFilter(value);
29787      onChange(updatedValue);
29788    };
29789    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanel, {
29790      label: (0,external_wp_i18n_namespaceObject.__)('Typography'),
29791      resetAll: resetAll,
29792      panelId: panelId,
29793      dropdownMenuProps: dropdownMenuProps,
29794      children: children
29795    });
29796  }
29797  const typography_panel_DEFAULT_CONTROLS = {
29798    fontFamily: true,
29799    fontSize: true,
29800    fontAppearance: true,
29801    lineHeight: true,
29802    letterSpacing: true,
29803    textAlign: true,
29804    textTransform: true,
29805    textDecoration: true,
29806    writingMode: true,
29807    textColumns: true
29808  };
29809  function TypographyPanel({
29810    as: Wrapper = TypographyToolsPanel,
29811    value,
29812    onChange,
29813    inheritedValue = value,
29814    settings,
29815    panelId,
29816    defaultControls = typography_panel_DEFAULT_CONTROLS
29817  }) {
29818    const decodeValue = rawValue => getValueFromVariable({
29819      settings
29820    }, '', rawValue);
29821  
29822    // Font Family
29823    const hasFontFamilyEnabled = useHasFontFamilyControl(settings);
29824    const fontFamily = decodeValue(inheritedValue?.typography?.fontFamily);
29825    const {
29826      fontFamilies,
29827      fontFamilyFaces
29828    } = (0,external_wp_element_namespaceObject.useMemo)(() => {
29829      return getMergedFontFamiliesAndFontFamilyFaces(settings, fontFamily);
29830    }, [settings, fontFamily]);
29831    const setFontFamily = newValue => {
29832      const slug = fontFamilies?.find(({
29833        fontFamily: f
29834      }) => f === newValue)?.slug;
29835      onChange(setImmutably(value, ['typography', 'fontFamily'], slug ? `var:preset|font-family|$slug}` : newValue || undefined));
29836    };
29837    const hasFontFamily = () => !!value?.typography?.fontFamily;
29838    const resetFontFamily = () => setFontFamily(undefined);
29839  
29840    // Font Size
29841    const hasFontSizeEnabled = useHasFontSizeControl(settings);
29842    const disableCustomFontSizes = !settings?.typography?.customFontSize;
29843    const mergedFontSizes = getMergedFontSizes(settings);
29844    const fontSize = decodeValue(inheritedValue?.typography?.fontSize);
29845    const setFontSize = (newValue, metadata) => {
29846      const actualValue = !!metadata?.slug ? `var:preset|font-size|$metadata?.slug}` : newValue;
29847      onChange(setImmutably(value, ['typography', 'fontSize'], actualValue || undefined));
29848    };
29849    const hasFontSize = () => !!value?.typography?.fontSize;
29850    const resetFontSize = () => setFontSize(undefined);
29851  
29852    // Appearance
29853    const hasAppearanceControl = useHasAppearanceControl(settings);
29854    const appearanceControlLabel = useAppearanceControlLabel(settings);
29855    const hasFontStyles = settings?.typography?.fontStyle;
29856    const hasFontWeights = settings?.typography?.fontWeight;
29857    const fontStyle = decodeValue(inheritedValue?.typography?.fontStyle);
29858    const fontWeight = decodeValue(inheritedValue?.typography?.fontWeight);
29859    const {
29860      nearestFontStyle,
29861      nearestFontWeight
29862    } = findNearestStyleAndWeight(fontFamilyFaces, fontStyle, fontWeight);
29863    const setFontAppearance = (0,external_wp_element_namespaceObject.useCallback)(({
29864      fontStyle: newFontStyle,
29865      fontWeight: newFontWeight
29866    }) => {
29867      // Only update the font style and weight if they have changed.
29868      if (newFontStyle !== fontStyle || newFontWeight !== fontWeight) {
29869        onChange({
29870          ...value,
29871          typography: {
29872            ...value?.typography,
29873            fontStyle: newFontStyle || undefined,
29874            fontWeight: newFontWeight || undefined
29875          }
29876        });
29877      }
29878    }, [fontStyle, fontWeight, onChange, value]);
29879    const hasFontAppearance = () => !!value?.typography?.fontStyle || !!value?.typography?.fontWeight;
29880    const resetFontAppearance = (0,external_wp_element_namespaceObject.useCallback)(() => {
29881      setFontAppearance({});
29882    }, [setFontAppearance]);
29883  
29884    // Check if previous font style and weight values are available in the new font family.
29885    (0,external_wp_element_namespaceObject.useEffect)(() => {
29886      if (nearestFontStyle && nearestFontWeight) {
29887        setFontAppearance({
29888          fontStyle: nearestFontStyle,
29889          fontWeight: nearestFontWeight
29890        });
29891      } else {
29892        // Reset font appearance if there are no available styles or weights.
29893        resetFontAppearance();
29894      }
29895    }, [nearestFontStyle, nearestFontWeight, resetFontAppearance, setFontAppearance]);
29896  
29897    // Line Height
29898    const hasLineHeightEnabled = useHasLineHeightControl(settings);
29899    const lineHeight = decodeValue(inheritedValue?.typography?.lineHeight);
29900    const setLineHeight = newValue => {
29901      onChange(setImmutably(value, ['typography', 'lineHeight'], newValue || undefined));
29902    };
29903    const hasLineHeight = () => value?.typography?.lineHeight !== undefined;
29904    const resetLineHeight = () => setLineHeight(undefined);
29905  
29906    // Letter Spacing
29907    const hasLetterSpacingControl = useHasLetterSpacingControl(settings);
29908    const letterSpacing = decodeValue(inheritedValue?.typography?.letterSpacing);
29909    const setLetterSpacing = newValue => {
29910      onChange(setImmutably(value, ['typography', 'letterSpacing'], newValue || undefined));
29911    };
29912    const hasLetterSpacing = () => !!value?.typography?.letterSpacing;
29913    const resetLetterSpacing = () => setLetterSpacing(undefined);
29914  
29915    // Text Columns
29916    const hasTextColumnsControl = useHasTextColumnsControl(settings);
29917    const textColumns = decodeValue(inheritedValue?.typography?.textColumns);
29918    const setTextColumns = newValue => {
29919      onChange(setImmutably(value, ['typography', 'textColumns'], newValue || undefined));
29920    };
29921    const hasTextColumns = () => !!value?.typography?.textColumns;
29922    const resetTextColumns = () => setTextColumns(undefined);
29923  
29924    // Text Transform
29925    const hasTextTransformControl = useHasTextTransformControl(settings);
29926    const textTransform = decodeValue(inheritedValue?.typography?.textTransform);
29927    const setTextTransform = newValue => {
29928      onChange(setImmutably(value, ['typography', 'textTransform'], newValue || undefined));
29929    };
29930    const hasTextTransform = () => !!value?.typography?.textTransform;
29931    const resetTextTransform = () => setTextTransform(undefined);
29932  
29933    // Text Decoration
29934    const hasTextDecorationControl = useHasTextDecorationControl(settings);
29935    const textDecoration = decodeValue(inheritedValue?.typography?.textDecoration);
29936    const setTextDecoration = newValue => {
29937      onChange(setImmutably(value, ['typography', 'textDecoration'], newValue || undefined));
29938    };
29939    const hasTextDecoration = () => !!value?.typography?.textDecoration;
29940    const resetTextDecoration = () => setTextDecoration(undefined);
29941  
29942    // Text Orientation
29943    const hasWritingModeControl = useHasWritingModeControl(settings);
29944    const writingMode = decodeValue(inheritedValue?.typography?.writingMode);
29945    const setWritingMode = newValue => {
29946      onChange(setImmutably(value, ['typography', 'writingMode'], newValue || undefined));
29947    };
29948    const hasWritingMode = () => !!value?.typography?.writingMode;
29949    const resetWritingMode = () => setWritingMode(undefined);
29950  
29951    // Text Alignment
29952    const hasTextAlignmentControl = useHasTextAlignmentControl(settings);
29953    const textAlign = decodeValue(inheritedValue?.typography?.textAlign);
29954    const setTextAlign = newValue => {
29955      onChange(setImmutably(value, ['typography', 'textAlign'], newValue || undefined));
29956    };
29957    const hasTextAlign = () => !!value?.typography?.textAlign;
29958    const resetTextAlign = () => setTextAlign(undefined);
29959    const resetAllFilter = (0,external_wp_element_namespaceObject.useCallback)(previousValue => {
29960      return {
29961        ...previousValue,
29962        typography: {}
29963      };
29964    }, []);
29965    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(Wrapper, {
29966      resetAllFilter: resetAllFilter,
29967      value: value,
29968      onChange: onChange,
29969      panelId: panelId,
29970      children: [hasFontFamilyEnabled && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanelItem, {
29971        label: (0,external_wp_i18n_namespaceObject.__)('Font'),
29972        hasValue: hasFontFamily,
29973        onDeselect: resetFontFamily,
29974        isShownByDefault: defaultControls.fontFamily,
29975        panelId: panelId,
29976        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(FontFamilyControl, {
29977          fontFamilies: fontFamilies,
29978          value: fontFamily,
29979          onChange: setFontFamily,
29980          size: "__unstable-large",
29981          __nextHasNoMarginBottom: true
29982        })
29983      }), hasFontSizeEnabled && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanelItem, {
29984        label: (0,external_wp_i18n_namespaceObject.__)('Size'),
29985        hasValue: hasFontSize,
29986        onDeselect: resetFontSize,
29987        isShownByDefault: defaultControls.fontSize,
29988        panelId: panelId,
29989        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FontSizePicker, {
29990          value: fontSize,
29991          onChange: setFontSize,
29992          fontSizes: mergedFontSizes,
29993          disableCustomFontSizes: disableCustomFontSizes,
29994          withReset: false,
29995          withSlider: true,
29996          size: "__unstable-large"
29997        })
29998      }), hasAppearanceControl && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanelItem, {
29999        className: "single-column",
30000        label: appearanceControlLabel,
30001        hasValue: hasFontAppearance,
30002        onDeselect: resetFontAppearance,
30003        isShownByDefault: defaultControls.fontAppearance,
30004        panelId: panelId,
30005        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(FontAppearanceControl, {
30006          value: {
30007            fontStyle,
30008            fontWeight
30009          },
30010          onChange: setFontAppearance,
30011          hasFontStyles: hasFontStyles,
30012          hasFontWeights: hasFontWeights,
30013          fontFamilyFaces: fontFamilyFaces,
30014          size: "__unstable-large"
30015        })
30016      }), hasLineHeightEnabled && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanelItem, {
30017        className: "single-column",
30018        label: (0,external_wp_i18n_namespaceObject.__)('Line height'),
30019        hasValue: hasLineHeight,
30020        onDeselect: resetLineHeight,
30021        isShownByDefault: defaultControls.lineHeight,
30022        panelId: panelId,
30023        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(line_height_control, {
30024          __unstableInputWidth: "auto",
30025          value: lineHeight,
30026          onChange: setLineHeight,
30027          size: "__unstable-large"
30028        })
30029      }), hasLetterSpacingControl && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanelItem, {
30030        className: "single-column",
30031        label: (0,external_wp_i18n_namespaceObject.__)('Letter spacing'),
30032        hasValue: hasLetterSpacing,
30033        onDeselect: resetLetterSpacing,
30034        isShownByDefault: defaultControls.letterSpacing,
30035        panelId: panelId,
30036        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(LetterSpacingControl, {
30037          value: letterSpacing,
30038          onChange: setLetterSpacing,
30039          size: "__unstable-large",
30040          __unstableInputWidth: "auto"
30041        })
30042      }), hasTextColumnsControl && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanelItem, {
30043        className: "single-column",
30044        label: (0,external_wp_i18n_namespaceObject.__)('Columns'),
30045        hasValue: hasTextColumns,
30046        onDeselect: resetTextColumns,
30047        isShownByDefault: defaultControls.textColumns,
30048        panelId: panelId,
30049        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalNumberControl, {
30050          label: (0,external_wp_i18n_namespaceObject.__)('Columns'),
30051          max: MAX_TEXT_COLUMNS,
30052          min: MIN_TEXT_COLUMNS,
30053          onChange: setTextColumns,
30054          size: "__unstable-large",
30055          spinControls: "custom",
30056          value: textColumns,
30057          initialPosition: 1
30058        })
30059      }), hasTextDecorationControl && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanelItem, {
30060        className: "single-column",
30061        label: (0,external_wp_i18n_namespaceObject.__)('Decoration'),
30062        hasValue: hasTextDecoration,
30063        onDeselect: resetTextDecoration,
30064        isShownByDefault: defaultControls.textDecoration,
30065        panelId: panelId,
30066        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(TextDecorationControl, {
30067          value: textDecoration,
30068          onChange: setTextDecoration,
30069          size: "__unstable-large",
30070          __unstableInputWidth: "auto"
30071        })
30072      }), hasWritingModeControl && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanelItem, {
30073        className: "single-column",
30074        label: (0,external_wp_i18n_namespaceObject.__)('Orientation'),
30075        hasValue: hasWritingMode,
30076        onDeselect: resetWritingMode,
30077        isShownByDefault: defaultControls.writingMode,
30078        panelId: panelId,
30079        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(WritingModeControl, {
30080          value: writingMode,
30081          onChange: setWritingMode,
30082          size: "__unstable-large",
30083          __nextHasNoMarginBottom: true
30084        })
30085      }), hasTextTransformControl && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanelItem, {
30086        label: (0,external_wp_i18n_namespaceObject.__)('Letter case'),
30087        hasValue: hasTextTransform,
30088        onDeselect: resetTextTransform,
30089        isShownByDefault: defaultControls.textTransform,
30090        panelId: panelId,
30091        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(TextTransformControl, {
30092          value: textTransform,
30093          onChange: setTextTransform,
30094          showNone: true,
30095          isBlock: true,
30096          size: "__unstable-large",
30097          __nextHasNoMarginBottom: true
30098        })
30099      }), hasTextAlignmentControl && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanelItem, {
30100        label: (0,external_wp_i18n_namespaceObject.__)('Text alignment'),
30101        hasValue: hasTextAlign,
30102        onDeselect: resetTextAlign,
30103        isShownByDefault: defaultControls.textAlign,
30104        panelId: panelId,
30105        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(TextAlignmentControl, {
30106          value: textAlign,
30107          onChange: setTextAlign,
30108          size: "__unstable-large",
30109          __nextHasNoMarginBottom: true
30110        })
30111      })]
30112    });
30113  }
30114  
30115  ;// ./node_modules/@wordpress/block-editor/build-module/hooks/line-height.js
30116  /**
30117   * WordPress dependencies
30118   */
30119  
30120  
30121  /**
30122   * Internal dependencies
30123   */
30124  
30125  
30126  
30127  
30128  const LINE_HEIGHT_SUPPORT_KEY = 'typography.lineHeight';
30129  
30130  /**
30131   * Inspector control panel containing the line height related configuration
30132   *
30133   * @param {Object} props
30134   *
30135   * @return {Element} Line height edit element.
30136   */
30137  function LineHeightEdit(props) {
30138    const {
30139      attributes: {
30140        style
30141      },
30142      setAttributes
30143    } = props;
30144    const onChange = newLineHeightValue => {
30145      const newStyle = {
30146        ...style,
30147        typography: {
30148          ...style?.typography,
30149          lineHeight: newLineHeightValue
30150        }
30151      };
30152      setAttributes({
30153        style: cleanEmptyObject(newStyle)
30154      });
30155    };
30156    return /*#__PURE__*/_jsx(LineHeightControl, {
30157      __unstableInputWidth: "100%",
30158      value: style?.typography?.lineHeight,
30159      onChange: onChange,
30160      size: "__unstable-large"
30161    });
30162  }
30163  
30164  /**
30165   * Custom hook that checks if line-height settings have been disabled.
30166   *
30167   * @param {string} name The name of the block.
30168   * @return {boolean} Whether setting is disabled.
30169   */
30170  function useIsLineHeightDisabled({
30171    name: blockName
30172  } = {}) {
30173    const [isEnabled] = useSettings('typography.lineHeight');
30174    return !isEnabled || !hasBlockSupport(blockName, LINE_HEIGHT_SUPPORT_KEY);
30175  }
30176  
30177  ;// external ["wp","tokenList"]
30178  const external_wp_tokenList_namespaceObject = window["wp"]["tokenList"];
30179  var external_wp_tokenList_default = /*#__PURE__*/__webpack_require__.n(external_wp_tokenList_namespaceObject);
30180  ;// ./node_modules/@wordpress/block-editor/build-module/hooks/font-family.js
30181  /**
30182   * WordPress dependencies
30183   */
30184  
30185  
30186  
30187  
30188  
30189  /**
30190   * Internal dependencies
30191   */
30192  
30193  
30194  
30195  const FONT_FAMILY_SUPPORT_KEY = 'typography.__experimentalFontFamily';
30196  const {
30197    kebabCase: font_family_kebabCase
30198  } = unlock(external_wp_components_namespaceObject.privateApis);
30199  
30200  /**
30201   * Filters registered block settings, extending attributes to include
30202   * the `fontFamily` attribute.
30203   *
30204   * @param {Object} settings Original block settings
30205   * @return {Object}         Filtered block settings
30206   */
30207  function font_family_addAttributes(settings) {
30208    if (!(0,external_wp_blocks_namespaceObject.hasBlockSupport)(settings, FONT_FAMILY_SUPPORT_KEY)) {
30209      return settings;
30210    }
30211  
30212    // Allow blocks to specify a default value if needed.
30213    if (!settings.attributes.fontFamily) {
30214      Object.assign(settings.attributes, {
30215        fontFamily: {
30216          type: 'string'
30217        }
30218      });
30219    }
30220    return settings;
30221  }
30222  
30223  /**
30224   * Override props assigned to save component to inject font family.
30225   *
30226   * @param {Object} props      Additional props applied to save element
30227   * @param {Object} blockType  Block type
30228   * @param {Object} attributes Block attributes
30229   * @return {Object}           Filtered props applied to save element
30230   */
30231  function font_family_addSaveProps(props, blockType, attributes) {
30232    if (!(0,external_wp_blocks_namespaceObject.hasBlockSupport)(blockType, FONT_FAMILY_SUPPORT_KEY)) {
30233      return props;
30234    }
30235    if (shouldSkipSerialization(blockType, TYPOGRAPHY_SUPPORT_KEY, 'fontFamily')) {
30236      return props;
30237    }
30238    if (!attributes?.fontFamily) {
30239      return props;
30240    }
30241  
30242    // Use TokenList to dedupe classes.
30243    const classes = new (external_wp_tokenList_default())(props.className);
30244    classes.add(`has-$font_family_kebabCase(attributes?.fontFamily)}-font-family`);
30245    const newClassName = classes.value;
30246    props.className = newClassName ? newClassName : undefined;
30247    return props;
30248  }
30249  function font_family_useBlockProps({
30250    name,
30251    fontFamily
30252  }) {
30253    return font_family_addSaveProps({}, name, {
30254      fontFamily
30255    });
30256  }
30257  /* harmony default export */ const font_family = ({
30258    useBlockProps: font_family_useBlockProps,
30259    addSaveProps: font_family_addSaveProps,
30260    attributeKeys: ['fontFamily'],
30261    hasSupport(name) {
30262      return (0,external_wp_blocks_namespaceObject.hasBlockSupport)(name, FONT_FAMILY_SUPPORT_KEY);
30263    }
30264  });
30265  
30266  /**
30267   * Resets the font family block support attribute. This can be used when
30268   * disabling the font family support controls for a block via a progressive
30269   * discovery panel.
30270   *
30271   * @param {Object} props               Block props.
30272   * @param {Object} props.setAttributes Function to set block's attributes.
30273   */
30274  function resetFontFamily({
30275    setAttributes
30276  }) {
30277    setAttributes({
30278      fontFamily: undefined
30279    });
30280  }
30281  (0,external_wp_hooks_namespaceObject.addFilter)('blocks.registerBlockType', 'core/fontFamily/addAttribute', font_family_addAttributes);
30282  
30283  ;// ./node_modules/@wordpress/block-editor/build-module/components/font-sizes/utils.js
30284  /**
30285   * WordPress dependencies
30286   */
30287  
30288  
30289  /**
30290   * Internal dependencies
30291   */
30292  
30293  const {
30294    kebabCase: utils_kebabCase
30295  } = unlock(external_wp_components_namespaceObject.privateApis);
30296  
30297  /**
30298   *  Returns the font size object based on an array of named font sizes and the namedFontSize and customFontSize values.
30299   *     If namedFontSize is undefined or not found in fontSizes an object with just the size value based on customFontSize is returned.
30300   *
30301   * @param {Array}   fontSizes               Array of font size objects containing at least the "name" and "size" values as properties.
30302   * @param {?string} fontSizeAttribute       Content of the font size attribute (slug).
30303   * @param {?number} customFontSizeAttribute Contents of the custom font size attribute (value).
30304   *
30305   * @return {?Object} If fontSizeAttribute is set and an equal slug is found in fontSizes it returns the font size object for that slug.
30306   *                      Otherwise, an object with just the size value based on customFontSize is returned.
30307   */
30308  const utils_getFontSize = (fontSizes, fontSizeAttribute, customFontSizeAttribute) => {
30309    if (fontSizeAttribute) {
30310      const fontSizeObject = fontSizes?.find(({
30311        slug
30312      }) => slug === fontSizeAttribute);
30313      if (fontSizeObject) {
30314        return fontSizeObject;
30315      }
30316    }
30317    return {
30318      size: customFontSizeAttribute
30319    };
30320  };
30321  
30322  /**
30323   * Returns the corresponding font size object for a given value.
30324   *
30325   * @param {Array}  fontSizes Array of font size objects.
30326   * @param {number} value     Font size value.
30327   *
30328   * @return {Object} Font size object.
30329   */
30330  function utils_getFontSizeObjectByValue(fontSizes, value) {
30331    const fontSizeObject = fontSizes?.find(({
30332      size
30333    }) => size === value);
30334    if (fontSizeObject) {
30335      return fontSizeObject;
30336    }
30337    return {
30338      size: value
30339    };
30340  }
30341  
30342  /**
30343   * Returns a class based on fontSizeName.
30344   *
30345   * @param {string} fontSizeSlug Slug of the fontSize.
30346   *
30347   * @return {string | undefined} String with the class corresponding to the fontSize passed.
30348   *                  The class is generated by appending 'has-' followed by fontSizeSlug in kebabCase and ending with '-font-size'.
30349   */
30350  function getFontSizeClass(fontSizeSlug) {
30351    if (!fontSizeSlug) {
30352      return;
30353    }
30354    return `has-$utils_kebabCase(fontSizeSlug)}-font-size`;
30355  }
30356  
30357  ;// ./node_modules/@wordpress/block-editor/build-module/hooks/font-size.js
30358  /**
30359   * WordPress dependencies
30360   */
30361  
30362  
30363  
30364  
30365  /**
30366   * Internal dependencies
30367   */
30368  
30369  
30370  
30371  
30372  
30373  
30374  const FONT_SIZE_SUPPORT_KEY = 'typography.fontSize';
30375  
30376  /**
30377   * Filters registered block settings, extending attributes to include
30378   * `fontSize` and `fontWeight` attributes.
30379   *
30380   * @param {Object} settings Original block settings.
30381   *
30382   * @return {Object} Filtered block settings.
30383   */
30384  function font_size_addAttributes(settings) {
30385    if (!(0,external_wp_blocks_namespaceObject.hasBlockSupport)(settings, FONT_SIZE_SUPPORT_KEY)) {
30386      return settings;
30387    }
30388  
30389    // Allow blocks to specify a default value if needed.
30390    if (!settings.attributes.fontSize) {
30391      Object.assign(settings.attributes, {
30392        fontSize: {
30393          type: 'string'
30394        }
30395      });
30396    }
30397    return settings;
30398  }
30399  
30400  /**
30401   * Override props assigned to save component to inject font size.
30402   *
30403   * @param {Object} props           Additional props applied to save element.
30404   * @param {Object} blockNameOrType Block type.
30405   * @param {Object} attributes      Block attributes.
30406   *
30407   * @return {Object} Filtered props applied to save element.
30408   */
30409  function font_size_addSaveProps(props, blockNameOrType, attributes) {
30410    if (!(0,external_wp_blocks_namespaceObject.hasBlockSupport)(blockNameOrType, FONT_SIZE_SUPPORT_KEY)) {
30411      return props;
30412    }
30413    if (shouldSkipSerialization(blockNameOrType, TYPOGRAPHY_SUPPORT_KEY, 'fontSize')) {
30414      return props;
30415    }
30416  
30417    // Use TokenList to dedupe classes.
30418    const classes = new (external_wp_tokenList_default())(props.className);
30419    classes.add(getFontSizeClass(attributes.fontSize));
30420    const newClassName = classes.value;
30421    props.className = newClassName ? newClassName : undefined;
30422    return props;
30423  }
30424  
30425  /**
30426   * Inspector control panel containing the font size related configuration
30427   *
30428   * @param {Object} props
30429   *
30430   * @return {Element} Font size edit element.
30431   */
30432  function FontSizeEdit(props) {
30433    const {
30434      attributes: {
30435        fontSize,
30436        style
30437      },
30438      setAttributes
30439    } = props;
30440    const [fontSizes] = useSettings('typography.fontSizes');
30441    const onChange = value => {
30442      const fontSizeSlug = getFontSizeObjectByValue(fontSizes, value).slug;
30443      setAttributes({
30444        style: cleanEmptyObject({
30445          ...style,
30446          typography: {
30447            ...style?.typography,
30448            fontSize: fontSizeSlug ? undefined : value
30449          }
30450        }),
30451        fontSize: fontSizeSlug
30452      });
30453    };
30454    const fontSizeObject = getFontSize(fontSizes, fontSize, style?.typography?.fontSize);
30455    const fontSizeValue = fontSizeObject?.size || style?.typography?.fontSize || fontSize;
30456    return /*#__PURE__*/_jsx(FontSizePicker, {
30457      onChange: onChange,
30458      value: fontSizeValue,
30459      withReset: false,
30460      withSlider: true,
30461      size: "__unstable-large"
30462    });
30463  }
30464  
30465  /**
30466   * Custom hook that checks if font-size settings have been disabled.
30467   *
30468   * @param {string} name The name of the block.
30469   * @return {boolean} Whether setting is disabled.
30470   */
30471  function useIsFontSizeDisabled({
30472    name: blockName
30473  } = {}) {
30474    const [fontSizes] = useSettings('typography.fontSizes');
30475    const hasFontSizes = !!fontSizes?.length;
30476    return !hasBlockSupport(blockName, FONT_SIZE_SUPPORT_KEY) || !hasFontSizes;
30477  }
30478  function font_size_useBlockProps({
30479    name,
30480    fontSize,
30481    style
30482  }) {
30483    const [fontSizes, fluidTypographySettings, layoutSettings] = use_settings_useSettings('typography.fontSizes', 'typography.fluid', 'layout');
30484  
30485    /*
30486     * Only add inline styles if the block supports font sizes,
30487     * doesn't skip serialization of font sizes,
30488     * and has either a custom font size or a preset font size.
30489     */
30490    if (!(0,external_wp_blocks_namespaceObject.hasBlockSupport)(name, FONT_SIZE_SUPPORT_KEY) || shouldSkipSerialization(name, TYPOGRAPHY_SUPPORT_KEY, 'fontSize') || !fontSize && !style?.typography?.fontSize) {
30491      return;
30492    }
30493    let props;
30494    if (style?.typography?.fontSize) {
30495      props = {
30496        style: {
30497          fontSize: getTypographyFontSizeValue({
30498            size: style.typography.fontSize
30499          }, {
30500            typography: {
30501              fluid: fluidTypographySettings
30502            },
30503            layout: layoutSettings
30504          })
30505        }
30506      };
30507    }
30508    if (fontSize) {
30509      props = {
30510        style: {
30511          fontSize: utils_getFontSize(fontSizes, fontSize, style?.typography?.fontSize).size
30512        }
30513      };
30514    }
30515    if (!props) {
30516      return;
30517    }
30518    return font_size_addSaveProps(props, name, {
30519      fontSize
30520    });
30521  }
30522  /* harmony default export */ const font_size = ({
30523    useBlockProps: font_size_useBlockProps,
30524    addSaveProps: font_size_addSaveProps,
30525    attributeKeys: ['fontSize', 'style'],
30526    hasSupport(name) {
30527      return (0,external_wp_blocks_namespaceObject.hasBlockSupport)(name, FONT_SIZE_SUPPORT_KEY);
30528    }
30529  });
30530  const font_size_MIGRATION_PATHS = {
30531    fontSize: [['fontSize'], ['style', 'typography', 'fontSize']]
30532  };
30533  function font_size_addTransforms(result, source, index, results) {
30534    const destinationBlockType = result.name;
30535    const activeSupports = {
30536      fontSize: (0,external_wp_blocks_namespaceObject.hasBlockSupport)(destinationBlockType, FONT_SIZE_SUPPORT_KEY)
30537    };
30538    return transformStyles(activeSupports, font_size_MIGRATION_PATHS, result, source, index, results);
30539  }
30540  (0,external_wp_hooks_namespaceObject.addFilter)('blocks.registerBlockType', 'core/font/addAttribute', font_size_addAttributes);
30541  (0,external_wp_hooks_namespaceObject.addFilter)('blocks.switchToBlockType.transformedBlock', 'core/font-size/addTransforms', font_size_addTransforms);
30542  
30543  ;// ./node_modules/@wordpress/block-editor/build-module/components/alignment-control/ui.js
30544  /**
30545   * WordPress dependencies
30546   */
30547  
30548  
30549  
30550  
30551  const DEFAULT_ALIGNMENT_CONTROLS = [{
30552    icon: align_left,
30553    title: (0,external_wp_i18n_namespaceObject.__)('Align text left'),
30554    align: 'left'
30555  }, {
30556    icon: align_center,
30557    title: (0,external_wp_i18n_namespaceObject.__)('Align text center'),
30558    align: 'center'
30559  }, {
30560    icon: align_right,
30561    title: (0,external_wp_i18n_namespaceObject.__)('Align text right'),
30562    align: 'right'
30563  }];
30564  const ui_POPOVER_PROPS = {
30565    placement: 'bottom-start'
30566  };
30567  function AlignmentUI({
30568    value,
30569    onChange,
30570    alignmentControls = DEFAULT_ALIGNMENT_CONTROLS,
30571    label = (0,external_wp_i18n_namespaceObject.__)('Align text'),
30572    description = (0,external_wp_i18n_namespaceObject.__)('Change text alignment'),
30573    isCollapsed = true,
30574    isToolbar
30575  }) {
30576    function applyOrUnset(align) {
30577      return () => onChange(value === align ? undefined : align);
30578    }
30579    const activeAlignment = alignmentControls.find(control => control.align === value);
30580    function setIcon() {
30581      if (activeAlignment) {
30582        return activeAlignment.icon;
30583      }
30584      return (0,external_wp_i18n_namespaceObject.isRTL)() ? align_right : align_left;
30585    }
30586    const UIComponent = isToolbar ? external_wp_components_namespaceObject.ToolbarGroup : external_wp_components_namespaceObject.ToolbarDropdownMenu;
30587    const extraProps = isToolbar ? {
30588      isCollapsed
30589    } : {
30590      toggleProps: {
30591        description
30592      },
30593      popoverProps: ui_POPOVER_PROPS
30594    };
30595    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(UIComponent, {
30596      icon: setIcon(),
30597      label: label,
30598      controls: alignmentControls.map(control => {
30599        const {
30600          align
30601        } = control;
30602        const isActive = value === align;
30603        return {
30604          ...control,
30605          isActive,
30606          role: isCollapsed ? 'menuitemradio' : undefined,
30607          onClick: applyOrUnset(align)
30608        };
30609      }),
30610      ...extraProps
30611    });
30612  }
30613  /* harmony default export */ const alignment_control_ui = (AlignmentUI);
30614  
30615  ;// ./node_modules/@wordpress/block-editor/build-module/components/alignment-control/index.js
30616  /**
30617   * Internal dependencies
30618   */
30619  
30620  
30621  const AlignmentControl = props => {
30622    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(alignment_control_ui, {
30623      ...props,
30624      isToolbar: false
30625    });
30626  };
30627  const AlignmentToolbar = props => {
30628    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(alignment_control_ui, {
30629      ...props,
30630      isToolbar: true
30631    });
30632  };
30633  
30634  /**
30635   * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/alignment-control/README.md
30636   */
30637  
30638  
30639  ;// ./node_modules/@wordpress/block-editor/build-module/hooks/text-align.js
30640  /**
30641   * External dependencies
30642   */
30643  
30644  
30645  /**
30646   * WordPress dependencies
30647   */
30648  
30649  
30650  
30651  
30652  /**
30653   * Internal dependencies
30654   */
30655  
30656  
30657  
30658  
30659  
30660  const TEXT_ALIGN_SUPPORT_KEY = 'typography.textAlign';
30661  const text_align_TEXT_ALIGNMENT_OPTIONS = [{
30662    icon: align_left,
30663    title: (0,external_wp_i18n_namespaceObject.__)('Align text left'),
30664    align: 'left'
30665  }, {
30666    icon: align_center,
30667    title: (0,external_wp_i18n_namespaceObject.__)('Align text center'),
30668    align: 'center'
30669  }, {
30670    icon: align_right,
30671    title: (0,external_wp_i18n_namespaceObject.__)('Align text right'),
30672    align: 'right'
30673  }];
30674  const VALID_TEXT_ALIGNMENTS = ['left', 'center', 'right'];
30675  const NO_TEXT_ALIGNMENTS = [];
30676  
30677  /**
30678   * Returns the valid text alignments.
30679   * Takes into consideration the text aligns supported by a block.
30680   * Exported just for testing purposes, not exported outside the module.
30681   *
30682   * @param {?boolean|string[]} blockTextAlign Text aligns supported by the block.
30683   *
30684   * @return {string[]} Valid text alignments.
30685   */
30686  function getValidTextAlignments(blockTextAlign) {
30687    if (Array.isArray(blockTextAlign)) {
30688      return VALID_TEXT_ALIGNMENTS.filter(textAlign => blockTextAlign.includes(textAlign));
30689    }
30690    return blockTextAlign === true ? VALID_TEXT_ALIGNMENTS : NO_TEXT_ALIGNMENTS;
30691  }
30692  function BlockEditTextAlignmentToolbarControlsPure({
30693    style,
30694    name: blockName,
30695    setAttributes
30696  }) {
30697    const settings = useBlockSettings(blockName);
30698    const hasTextAlignControl = settings?.typography?.textAlign;
30699    const blockEditingMode = useBlockEditingMode();
30700    if (!hasTextAlignControl || blockEditingMode !== 'default') {
30701      return null;
30702    }
30703    const validTextAlignments = getValidTextAlignments((0,external_wp_blocks_namespaceObject.getBlockSupport)(blockName, TEXT_ALIGN_SUPPORT_KEY));
30704    if (!validTextAlignments.length) {
30705      return null;
30706    }
30707    const textAlignmentControls = text_align_TEXT_ALIGNMENT_OPTIONS.filter(control => validTextAlignments.includes(control.align));
30708    const onChange = newTextAlignValue => {
30709      const newStyle = {
30710        ...style,
30711        typography: {
30712          ...style?.typography,
30713          textAlign: newTextAlignValue
30714        }
30715      };
30716      setAttributes({
30717        style: utils_cleanEmptyObject(newStyle)
30718      });
30719    };
30720    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_controls, {
30721      group: "block",
30722      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(AlignmentControl, {
30723        value: style?.typography?.textAlign,
30724        onChange: onChange,
30725        alignmentControls: textAlignmentControls
30726      })
30727    });
30728  }
30729  /* harmony default export */ const text_align = ({
30730    edit: BlockEditTextAlignmentToolbarControlsPure,
30731    useBlockProps: text_align_useBlockProps,
30732    addSaveProps: addAssignedTextAlign,
30733    attributeKeys: ['style'],
30734    hasSupport(name) {
30735      return (0,external_wp_blocks_namespaceObject.hasBlockSupport)(name, TEXT_ALIGN_SUPPORT_KEY, false);
30736    }
30737  });
30738  function text_align_useBlockProps({
30739    name,
30740    style
30741  }) {
30742    if (!style?.typography?.textAlign) {
30743      return null;
30744    }
30745    const validTextAlignments = getValidTextAlignments((0,external_wp_blocks_namespaceObject.getBlockSupport)(name, TEXT_ALIGN_SUPPORT_KEY));
30746    if (!validTextAlignments.length) {
30747      return null;
30748    }
30749    if (shouldSkipSerialization(name, TYPOGRAPHY_SUPPORT_KEY, 'textAlign')) {
30750      return null;
30751    }
30752    const textAlign = style.typography.textAlign;
30753    const className = dist_clsx({
30754      [`has-text-align-$textAlign}`]: textAlign
30755    });
30756    return {
30757      className
30758    };
30759  }
30760  
30761  /**
30762   * Override props assigned to save component to inject text alignment class
30763   * name if block supports it.
30764   *
30765   * @param {Object} props      Additional props applied to save element.
30766   * @param {Object} blockType  Block type.
30767   * @param {Object} attributes Block attributes.
30768   *
30769   * @return {Object} Filtered props applied to save element.
30770   */
30771  function addAssignedTextAlign(props, blockType, attributes) {
30772    if (!attributes?.style?.typography?.textAlign) {
30773      return props;
30774    }
30775    const {
30776      textAlign
30777    } = attributes.style.typography;
30778    const blockTextAlign = (0,external_wp_blocks_namespaceObject.getBlockSupport)(blockType, TEXT_ALIGN_SUPPORT_KEY);
30779    const isTextAlignValid = getValidTextAlignments(blockTextAlign).includes(textAlign);
30780    if (isTextAlignValid && !shouldSkipSerialization(blockType, TYPOGRAPHY_SUPPORT_KEY, 'textAlign')) {
30781      props.className = dist_clsx(`has-text-align-$textAlign}`, props.className);
30782    }
30783    return props;
30784  }
30785  
30786  ;// ./node_modules/@wordpress/block-editor/build-module/hooks/typography.js
30787  /**
30788   * WordPress dependencies
30789   */
30790  
30791  
30792  
30793  
30794  /**
30795   * Internal dependencies
30796   */
30797  
30798  
30799  
30800  
30801  
30802  
30803  
30804  
30805  
30806  function omit(object, keys) {
30807    return Object.fromEntries(Object.entries(object).filter(([key]) => !keys.includes(key)));
30808  }
30809  const LETTER_SPACING_SUPPORT_KEY = 'typography.__experimentalLetterSpacing';
30810  const TEXT_TRANSFORM_SUPPORT_KEY = 'typography.__experimentalTextTransform';
30811  const TEXT_DECORATION_SUPPORT_KEY = 'typography.__experimentalTextDecoration';
30812  const TEXT_COLUMNS_SUPPORT_KEY = 'typography.textColumns';
30813  const FONT_STYLE_SUPPORT_KEY = 'typography.__experimentalFontStyle';
30814  const FONT_WEIGHT_SUPPORT_KEY = 'typography.__experimentalFontWeight';
30815  const WRITING_MODE_SUPPORT_KEY = 'typography.__experimentalWritingMode';
30816  const TYPOGRAPHY_SUPPORT_KEY = 'typography';
30817  const TYPOGRAPHY_SUPPORT_KEYS = [LINE_HEIGHT_SUPPORT_KEY, FONT_SIZE_SUPPORT_KEY, FONT_STYLE_SUPPORT_KEY, FONT_WEIGHT_SUPPORT_KEY, FONT_FAMILY_SUPPORT_KEY, TEXT_ALIGN_SUPPORT_KEY, TEXT_COLUMNS_SUPPORT_KEY, TEXT_DECORATION_SUPPORT_KEY, WRITING_MODE_SUPPORT_KEY, TEXT_TRANSFORM_SUPPORT_KEY, LETTER_SPACING_SUPPORT_KEY];
30818  function typography_styleToAttributes(style) {
30819    const updatedStyle = {
30820      ...omit(style, ['fontFamily'])
30821    };
30822    const fontSizeValue = style?.typography?.fontSize;
30823    const fontFamilyValue = style?.typography?.fontFamily;
30824    const fontSizeSlug = fontSizeValue?.startsWith('var:preset|font-size|') ? fontSizeValue.substring('var:preset|font-size|'.length) : undefined;
30825    const fontFamilySlug = fontFamilyValue?.startsWith('var:preset|font-family|') ? fontFamilyValue.substring('var:preset|font-family|'.length) : undefined;
30826    updatedStyle.typography = {
30827      ...omit(updatedStyle.typography, ['fontFamily']),
30828      fontSize: fontSizeSlug ? undefined : fontSizeValue
30829    };
30830    return {
30831      style: utils_cleanEmptyObject(updatedStyle),
30832      fontFamily: fontFamilySlug,
30833      fontSize: fontSizeSlug
30834    };
30835  }
30836  function typography_attributesToStyle(attributes) {
30837    return {
30838      ...attributes.style,
30839      typography: {
30840        ...attributes.style?.typography,
30841        fontFamily: attributes.fontFamily ? 'var:preset|font-family|' + attributes.fontFamily : undefined,
30842        fontSize: attributes.fontSize ? 'var:preset|font-size|' + attributes.fontSize : attributes.style?.typography?.fontSize
30843      }
30844    };
30845  }
30846  function TypographyInspectorControl({
30847    children,
30848    resetAllFilter
30849  }) {
30850    const attributesResetAllFilter = (0,external_wp_element_namespaceObject.useCallback)(attributes => {
30851      const existingStyle = typography_attributesToStyle(attributes);
30852      const updatedStyle = resetAllFilter(existingStyle);
30853      return {
30854        ...attributes,
30855        ...typography_styleToAttributes(updatedStyle)
30856      };
30857    }, [resetAllFilter]);
30858    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls, {
30859      group: "typography",
30860      resetAllFilter: attributesResetAllFilter,
30861      children: children
30862    });
30863  }
30864  function typography_TypographyPanel({
30865    clientId,
30866    name,
30867    setAttributes,
30868    settings
30869  }) {
30870    function selector(select) {
30871      const {
30872        style,
30873        fontFamily,
30874        fontSize
30875      } = select(store).getBlockAttributes(clientId) || {};
30876      return {
30877        style,
30878        fontFamily,
30879        fontSize
30880      };
30881    }
30882    const {
30883      style,
30884      fontFamily,
30885      fontSize
30886    } = (0,external_wp_data_namespaceObject.useSelect)(selector, [clientId]);
30887    const isEnabled = useHasTypographyPanel(settings);
30888    const value = (0,external_wp_element_namespaceObject.useMemo)(() => typography_attributesToStyle({
30889      style,
30890      fontFamily,
30891      fontSize
30892    }), [style, fontSize, fontFamily]);
30893    const onChange = newStyle => {
30894      setAttributes(typography_styleToAttributes(newStyle));
30895    };
30896    if (!isEnabled) {
30897      return null;
30898    }
30899    const defaultControls = (0,external_wp_blocks_namespaceObject.getBlockSupport)(name, [TYPOGRAPHY_SUPPORT_KEY, '__experimentalDefaultControls']);
30900    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(TypographyPanel, {
30901      as: TypographyInspectorControl,
30902      panelId: clientId,
30903      settings: settings,
30904      value: value,
30905      onChange: onChange,
30906      defaultControls: defaultControls
30907    });
30908  }
30909  const hasTypographySupport = blockName => {
30910    return TYPOGRAPHY_SUPPORT_KEYS.some(key => hasBlockSupport(blockName, key));
30911  };
30912  
30913  ;// ./node_modules/@wordpress/block-editor/build-module/components/spacing-sizes-control/hooks/use-spacing-sizes.js
30914  /**
30915   * WordPress dependencies
30916   */
30917  
30918  
30919  
30920  /**
30921   * Internal dependencies
30922   */
30923  
30924  
30925  const use_spacing_sizes_EMPTY_ARRAY = [];
30926  const compare = new Intl.Collator('und', {
30927    numeric: true
30928  }).compare;
30929  function useSpacingSizes() {
30930    const [customSpacingSizes, themeSpacingSizes, defaultSpacingSizes, defaultSpacingSizesEnabled] = use_settings_useSettings('spacing.spacingSizes.custom', 'spacing.spacingSizes.theme', 'spacing.spacingSizes.default', 'spacing.defaultSpacingSizes');
30931    const customSizes = customSpacingSizes !== null && customSpacingSizes !== void 0 ? customSpacingSizes : use_spacing_sizes_EMPTY_ARRAY;
30932    const themeSizes = themeSpacingSizes !== null && themeSpacingSizes !== void 0 ? themeSpacingSizes : use_spacing_sizes_EMPTY_ARRAY;
30933    const defaultSizes = defaultSpacingSizes && defaultSpacingSizesEnabled !== false ? defaultSpacingSizes : use_spacing_sizes_EMPTY_ARRAY;
30934    return (0,external_wp_element_namespaceObject.useMemo)(() => {
30935      const sizes = [{
30936        name: (0,external_wp_i18n_namespaceObject.__)('None'),
30937        slug: '0',
30938        size: 0
30939      }, ...customSizes, ...themeSizes, ...defaultSizes];
30940  
30941      // Using numeric slugs opts-in to sorting by slug.
30942      if (sizes.every(({
30943        slug
30944      }) => /^[0-9]/.test(slug))) {
30945        sizes.sort((a, b) => compare(a.slug, b.slug));
30946      }
30947      return sizes.length > RANGE_CONTROL_MAX_SIZE ? [{
30948        name: (0,external_wp_i18n_namespaceObject.__)('Default'),
30949        slug: 'default',
30950        size: undefined
30951      }, ...sizes] : sizes;
30952    }, [customSizes, themeSizes, defaultSizes]);
30953  }
30954  
30955  ;// ./node_modules/@wordpress/icons/build-module/library/settings.js
30956  /**
30957   * WordPress dependencies
30958   */
30959  
30960  
30961  const settings_settings = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_primitives_namespaceObject.SVG, {
30962    xmlns: "http://www.w3.org/2000/svg",
30963    viewBox: "0 0 24 24",
30964    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
30965      d: "m19 7.5h-7.628c-.3089-.87389-1.1423-1.5-2.122-1.5-.97966 0-1.81309.62611-2.12197 1.5h-2.12803v1.5h2.12803c.30888.87389 1.14231 1.5 2.12197 1.5.9797 0 1.8131-.62611 2.122-1.5h7.628z"
30966    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
30967      d: "m19 15h-2.128c-.3089-.8739-1.1423-1.5-2.122-1.5s-1.8131.6261-2.122 1.5h-7.628v1.5h7.628c.3089.8739 1.1423 1.5 2.122 1.5s1.8131-.6261 2.122-1.5h2.128z"
30968    })]
30969  });
30970  /* harmony default export */ const library_settings = (settings_settings);
30971  
30972  ;// ./node_modules/@wordpress/block-editor/build-module/components/spacing-sizes-control/input-controls/spacing-input-control.js
30973  /**
30974   * WordPress dependencies
30975   */
30976  
30977  
30978  
30979  
30980  
30981  
30982  
30983  /**
30984   * Internal dependencies
30985   */
30986  
30987  
30988  
30989  
30990  const CUSTOM_VALUE_SETTINGS = {
30991    px: {
30992      max: 300,
30993      steps: 1
30994    },
30995    '%': {
30996      max: 100,
30997      steps: 1
30998    },
30999    vw: {
31000      max: 100,
31001      steps: 1
31002    },
31003    vh: {
31004      max: 100,
31005      steps: 1
31006    },
31007    em: {
31008      max: 10,
31009      steps: 0.1
31010    },
31011    rm: {
31012      max: 10,
31013      steps: 0.1
31014    },
31015    svw: {
31016      max: 100,
31017      steps: 1
31018    },
31019    lvw: {
31020      max: 100,
31021      steps: 1
31022    },
31023    dvw: {
31024      max: 100,
31025      steps: 1
31026    },
31027    svh: {
31028      max: 100,
31029      steps: 1
31030    },
31031    lvh: {
31032      max: 100,
31033      steps: 1
31034    },
31035    dvh: {
31036      max: 100,
31037      steps: 1
31038    },
31039    vi: {
31040      max: 100,
31041      steps: 1
31042    },
31043    svi: {
31044      max: 100,
31045      steps: 1
31046    },
31047    lvi: {
31048      max: 100,
31049      steps: 1
31050    },
31051    dvi: {
31052      max: 100,
31053      steps: 1
31054    },
31055    vb: {
31056      max: 100,
31057      steps: 1
31058    },
31059    svb: {
31060      max: 100,
31061      steps: 1
31062    },
31063    lvb: {
31064      max: 100,
31065      steps: 1
31066    },
31067    dvb: {
31068      max: 100,
31069      steps: 1
31070    },
31071    vmin: {
31072      max: 100,
31073      steps: 1
31074    },
31075    svmin: {
31076      max: 100,
31077      steps: 1
31078    },
31079    lvmin: {
31080      max: 100,
31081      steps: 1
31082    },
31083    dvmin: {
31084      max: 100,
31085      steps: 1
31086    },
31087    vmax: {
31088      max: 100,
31089      steps: 1
31090    },
31091    svmax: {
31092      max: 100,
31093      steps: 1
31094    },
31095    lvmax: {
31096      max: 100,
31097      steps: 1
31098    },
31099    dvmax: {
31100      max: 100,
31101      steps: 1
31102    }
31103  };
31104  function SpacingInputControl({
31105    icon,
31106    isMixed = false,
31107    minimumCustomValue,
31108    onChange,
31109    onMouseOut,
31110    onMouseOver,
31111    showSideInLabel = true,
31112    side,
31113    spacingSizes,
31114    type,
31115    value
31116  }) {
31117    var _CUSTOM_VALUE_SETTING, _CUSTOM_VALUE_SETTING2;
31118    // Treat value as a preset value if the passed in value matches the value of one of the spacingSizes.
31119    value = getPresetValueFromCustomValue(value, spacingSizes);
31120    let selectListSizes = spacingSizes;
31121    const showRangeControl = spacingSizes.length <= RANGE_CONTROL_MAX_SIZE;
31122    const disableCustomSpacingSizes = (0,external_wp_data_namespaceObject.useSelect)(select => {
31123      const editorSettings = select(store).getSettings();
31124      return editorSettings?.disableCustomSpacingSizes;
31125    });
31126    const [showCustomValueControl, setShowCustomValueControl] = (0,external_wp_element_namespaceObject.useState)(!disableCustomSpacingSizes && value !== undefined && !isValueSpacingPreset(value));
31127    const [minValue, setMinValue] = (0,external_wp_element_namespaceObject.useState)(minimumCustomValue);
31128    const previousValue = (0,external_wp_compose_namespaceObject.usePrevious)(value);
31129    if (!!value && previousValue !== value && !isValueSpacingPreset(value) && showCustomValueControl !== true) {
31130      setShowCustomValueControl(true);
31131    }
31132    const [availableUnits] = use_settings_useSettings('spacing.units');
31133    const units = (0,external_wp_components_namespaceObject.__experimentalUseCustomUnits)({
31134      availableUnits: availableUnits || ['px', 'em', 'rem']
31135    });
31136    let currentValue = null;
31137    const showCustomValueInSelectList = !showRangeControl && !showCustomValueControl && value !== undefined && (!isValueSpacingPreset(value) || isValueSpacingPreset(value) && isMixed);
31138    if (showCustomValueInSelectList) {
31139      selectListSizes = [...spacingSizes, {
31140        name: !isMixed ?
31141        // translators: %s: A custom measurement, e.g. a number followed by a unit like 12px.
31142        (0,external_wp_i18n_namespaceObject.sprintf)((0,external_wp_i18n_namespaceObject.__)('Custom (%s)'), value) : (0,external_wp_i18n_namespaceObject.__)('Mixed'),
31143        slug: 'custom',
31144        size: value
31145      }];
31146      currentValue = selectListSizes.length - 1;
31147    } else if (!isMixed) {
31148      currentValue = !showCustomValueControl ? getSliderValueFromPreset(value, spacingSizes) : getCustomValueFromPreset(value, spacingSizes);
31149    }
31150    const selectedUnit = (0,external_wp_element_namespaceObject.useMemo)(() => (0,external_wp_components_namespaceObject.__experimentalParseQuantityAndUnitFromRawValue)(currentValue), [currentValue])[1] || units[0]?.value;
31151    const setInitialValue = () => {
31152      if (value === undefined) {
31153        onChange('0');
31154      }
31155    };
31156    const customTooltipContent = newValue => value === undefined ? undefined : spacingSizes[newValue]?.name;
31157    const customRangeValue = parseFloat(currentValue, 10);
31158    const getNewCustomValue = newSize => {
31159      const isNumeric = !isNaN(parseFloat(newSize));
31160      const nextValue = isNumeric ? newSize : undefined;
31161      return nextValue;
31162    };
31163    const getNewPresetValue = (newSize, controlType) => {
31164      const size = parseInt(newSize, 10);
31165      if (controlType === 'selectList') {
31166        if (size === 0) {
31167          return undefined;
31168        }
31169        if (size === 1) {
31170          return '0';
31171        }
31172      } else if (size === 0) {
31173        return '0';
31174      }
31175      return `var:preset|spacing|$spacingSizes[newSize]?.slug}`;
31176    };
31177    const handleCustomValueSliderChange = next => {
31178      onChange([next, selectedUnit].join(''));
31179    };
31180    const allPlaceholder = isMixed ? (0,external_wp_i18n_namespaceObject.__)('Mixed') : null;
31181    const options = selectListSizes.map((size, index) => ({
31182      key: index,
31183      name: size.name
31184    }));
31185    const marks = spacingSizes.slice(1, spacingSizes.length - 1).map((_newValue, index) => ({
31186      value: index + 1,
31187      label: undefined
31188    }));
31189    const sideLabel = ALL_SIDES.includes(side) && showSideInLabel ? LABELS[side] : '';
31190    const typeLabel = showSideInLabel ? type?.toLowerCase() : type;
31191    const ariaLabel = (0,external_wp_i18n_namespaceObject.sprintf)(
31192    // translators: 1: The side of the block being modified (top, bottom, left etc.). 2. Type of spacing being modified (padding, margin, etc).
31193    (0,external_wp_i18n_namespaceObject._x)('%1$s %2$s', 'spacing'), sideLabel, typeLabel).trim();
31194    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalHStack, {
31195      className: "spacing-sizes-control__wrapper",
31196      children: [icon && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Icon, {
31197        className: "spacing-sizes-control__icon",
31198        icon: icon,
31199        size: 24
31200      }), showCustomValueControl && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
31201        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalUnitControl, {
31202          onMouseOver: onMouseOver,
31203          onMouseOut: onMouseOut,
31204          onFocus: onMouseOver,
31205          onBlur: onMouseOut,
31206          onChange: newSize => onChange(getNewCustomValue(newSize)),
31207          value: currentValue,
31208          units: units,
31209          min: minValue,
31210          placeholder: allPlaceholder,
31211          disableUnits: isMixed,
31212          label: ariaLabel,
31213          hideLabelFromVision: true,
31214          className: "spacing-sizes-control__custom-value-input",
31215          size: "__unstable-large",
31216          onDragStart: () => {
31217            if (value?.charAt(0) === '-') {
31218              setMinValue(0);
31219            }
31220          },
31221          onDrag: () => {
31222            if (value?.charAt(0) === '-') {
31223              setMinValue(0);
31224            }
31225          },
31226          onDragEnd: () => {
31227            setMinValue(minimumCustomValue);
31228          }
31229        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.RangeControl, {
31230          __next40pxDefaultSize: true,
31231          onMouseOver: onMouseOver,
31232          onMouseOut: onMouseOut,
31233          onFocus: onMouseOver,
31234          onBlur: onMouseOut,
31235          value: customRangeValue,
31236          min: 0,
31237          max: (_CUSTOM_VALUE_SETTING = CUSTOM_VALUE_SETTINGS[selectedUnit]?.max) !== null && _CUSTOM_VALUE_SETTING !== void 0 ? _CUSTOM_VALUE_SETTING : 10,
31238          step: (_CUSTOM_VALUE_SETTING2 = CUSTOM_VALUE_SETTINGS[selectedUnit]?.steps) !== null && _CUSTOM_VALUE_SETTING2 !== void 0 ? _CUSTOM_VALUE_SETTING2 : 0.1,
31239          withInputField: false,
31240          onChange: handleCustomValueSliderChange,
31241          className: "spacing-sizes-control__custom-value-range",
31242          __nextHasNoMarginBottom: true,
31243          label: ariaLabel,
31244          hideLabelFromVision: true
31245        })]
31246      }), showRangeControl && !showCustomValueControl && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.RangeControl, {
31247        __next40pxDefaultSize: true,
31248        onMouseOver: onMouseOver,
31249        onMouseOut: onMouseOut,
31250        className: "spacing-sizes-control__range-control",
31251        value: currentValue,
31252        onChange: newSize => onChange(getNewPresetValue(newSize)),
31253        onMouseDown: event => {
31254          // If mouse down is near start of range set initial value to 0, which
31255          // prevents the user have to drag right then left to get 0 setting.
31256          if (event?.nativeEvent?.offsetX < 35) {
31257            setInitialValue();
31258          }
31259        },
31260        withInputField: false,
31261        "aria-valuenow": currentValue,
31262        "aria-valuetext": spacingSizes[currentValue]?.name,
31263        renderTooltipContent: customTooltipContent,
31264        min: 0,
31265        max: spacingSizes.length - 1,
31266        marks: marks,
31267        label: ariaLabel,
31268        hideLabelFromVision: true,
31269        __nextHasNoMarginBottom: true,
31270        onFocus: onMouseOver,
31271        onBlur: onMouseOut
31272      }), !showRangeControl && !showCustomValueControl && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.CustomSelectControl, {
31273        className: "spacing-sizes-control__custom-select-control",
31274        value:
31275        // passing empty string as a fallback to continue using the
31276        // component in controlled mode
31277        options.find(option => option.key === currentValue) || '',
31278        onChange: selection => {
31279          onChange(getNewPresetValue(selection.selectedItem.key, 'selectList'));
31280        },
31281        options: options,
31282        label: ariaLabel,
31283        hideLabelFromVision: true,
31284        size: "__unstable-large",
31285        onMouseOver: onMouseOver,
31286        onMouseOut: onMouseOut,
31287        onFocus: onMouseOver,
31288        onBlur: onMouseOut
31289      }), !disableCustomSpacingSizes && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
31290        label: showCustomValueControl ? (0,external_wp_i18n_namespaceObject.__)('Use size preset') : (0,external_wp_i18n_namespaceObject.__)('Set custom size'),
31291        icon: library_settings,
31292        onClick: () => {
31293          setShowCustomValueControl(!showCustomValueControl);
31294        },
31295        isPressed: showCustomValueControl,
31296        size: "small",
31297        className: "spacing-sizes-control__custom-toggle",
31298        iconSize: 24
31299      })]
31300    });
31301  }
31302  
31303  ;// ./node_modules/@wordpress/block-editor/build-module/components/spacing-sizes-control/input-controls/axial.js
31304  /**
31305   * Internal dependencies
31306   */
31307  
31308  
31309  
31310  const groupedSides = ['vertical', 'horizontal'];
31311  function AxialInputControls({
31312    minimumCustomValue,
31313    onChange,
31314    onMouseOut,
31315    onMouseOver,
31316    sides,
31317    spacingSizes,
31318    type,
31319    values
31320  }) {
31321    const createHandleOnChange = side => next => {
31322      if (!onChange) {
31323        return;
31324      }
31325  
31326      // Encode the existing value into the preset value if the passed in value matches the value of one of the spacingSizes.
31327      const nextValues = {
31328        ...Object.keys(values).reduce((acc, key) => {
31329          acc[key] = getPresetValueFromCustomValue(values[key], spacingSizes);
31330          return acc;
31331        }, {})
31332      };
31333      if (side === 'vertical') {
31334        nextValues.top = next;
31335        nextValues.bottom = next;
31336      }
31337      if (side === 'horizontal') {
31338        nextValues.left = next;
31339        nextValues.right = next;
31340      }
31341      onChange(nextValues);
31342    };
31343  
31344    // Filter sides if custom configuration provided, maintaining default order.
31345    const filteredSides = sides?.length ? groupedSides.filter(side => hasAxisSupport(sides, side)) : groupedSides;
31346    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_ReactJSXRuntime_namespaceObject.Fragment, {
31347      children: filteredSides.map(side => {
31348        const axisValue = side === 'vertical' ? values.top : values.left;
31349        return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(SpacingInputControl, {
31350          icon: ICONS[side],
31351          label: LABELS[side],
31352          minimumCustomValue: minimumCustomValue,
31353          onChange: createHandleOnChange(side),
31354          onMouseOut: onMouseOut,
31355          onMouseOver: onMouseOver,
31356          side: side,
31357          spacingSizes: spacingSizes,
31358          type: type,
31359          value: axisValue,
31360          withInputField: false
31361        }, `spacing-sizes-control-$side}`);
31362      })
31363    });
31364  }
31365  
31366  ;// ./node_modules/@wordpress/block-editor/build-module/components/spacing-sizes-control/input-controls/separated.js
31367  /**
31368   * Internal dependencies
31369   */
31370  
31371  
31372  
31373  function SeparatedInputControls({
31374    minimumCustomValue,
31375    onChange,
31376    onMouseOut,
31377    onMouseOver,
31378    sides,
31379    spacingSizes,
31380    type,
31381    values
31382  }) {
31383    // Filter sides if custom configuration provided, maintaining default order.
31384    const filteredSides = sides?.length ? ALL_SIDES.filter(side => sides.includes(side)) : ALL_SIDES;
31385    const createHandleOnChange = side => next => {
31386      // Encode the existing value into the preset value if the passed in value matches the value of one of the spacingSizes.
31387      const nextValues = {
31388        ...Object.keys(values).reduce((acc, key) => {
31389          acc[key] = getPresetValueFromCustomValue(values[key], spacingSizes);
31390          return acc;
31391        }, {})
31392      };
31393      nextValues[side] = next;
31394      onChange(nextValues);
31395    };
31396    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_ReactJSXRuntime_namespaceObject.Fragment, {
31397      children: filteredSides.map(side => {
31398        return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(SpacingInputControl, {
31399          icon: ICONS[side],
31400          label: LABELS[side],
31401          minimumCustomValue: minimumCustomValue,
31402          onChange: createHandleOnChange(side),
31403          onMouseOut: onMouseOut,
31404          onMouseOver: onMouseOver,
31405          side: side,
31406          spacingSizes: spacingSizes,
31407          type: type,
31408          value: values[side],
31409          withInputField: false
31410        }, `spacing-sizes-control-$side}`);
31411      })
31412    });
31413  }
31414  
31415  ;// ./node_modules/@wordpress/block-editor/build-module/components/spacing-sizes-control/input-controls/single.js
31416  /**
31417   * Internal dependencies
31418   */
31419  
31420  
31421  
31422  function SingleInputControl({
31423    minimumCustomValue,
31424    onChange,
31425    onMouseOut,
31426    onMouseOver,
31427    showSideInLabel,
31428    side,
31429    spacingSizes,
31430    type,
31431    values
31432  }) {
31433    const createHandleOnChange = currentSide => next => {
31434      // Encode the existing value into the preset value if the passed in value matches the value of one of the spacingSizes.
31435      const nextValues = {
31436        ...Object.keys(values).reduce((acc, key) => {
31437          acc[key] = getPresetValueFromCustomValue(values[key], spacingSizes);
31438          return acc;
31439        }, {})
31440      };
31441      nextValues[currentSide] = next;
31442      onChange(nextValues);
31443    };
31444    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(SpacingInputControl, {
31445      label: LABELS[side],
31446      minimumCustomValue: minimumCustomValue,
31447      onChange: createHandleOnChange(side),
31448      onMouseOut: onMouseOut,
31449      onMouseOver: onMouseOver,
31450      showSideInLabel: showSideInLabel,
31451      side: side,
31452      spacingSizes: spacingSizes,
31453      type: type,
31454      value: values[side],
31455      withInputField: false
31456    });
31457  }
31458  
31459  ;// ./node_modules/@wordpress/block-editor/build-module/components/spacing-sizes-control/linked-button.js
31460  /**
31461   * WordPress dependencies
31462   */
31463  
31464  
31465  
31466  
31467  function linked_button_LinkedButton({
31468    isLinked,
31469    ...props
31470  }) {
31471    const label = isLinked ? (0,external_wp_i18n_namespaceObject.__)('Unlink sides') : (0,external_wp_i18n_namespaceObject.__)('Link sides');
31472    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
31473      ...props,
31474      size: "small",
31475      icon: isLinked ? library_link : link_off,
31476      iconSize: 24,
31477      label: label
31478    });
31479  }
31480  
31481  ;// ./node_modules/@wordpress/block-editor/build-module/components/spacing-sizes-control/index.js
31482  /**
31483   * WordPress dependencies
31484   */
31485  
31486  
31487  
31488  
31489  /**
31490   * Internal dependencies
31491   */
31492  
31493  
31494  
31495  
31496  
31497  
31498  
31499  /**
31500   * A flexible control for managing spacing values in the block editor. Supports single, axial,
31501   * and separated input controls for different spacing configurations with automatic view selection
31502   * based on current values and available sides.
31503   *
31504   * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/spacing-sizes-control/README.md
31505   *
31506   * @example
31507   * ```jsx
31508   * import { __experimentalSpacingSizesControl as SpacingSizesControl } from '@wordpress/block-editor';
31509   * import { useState } from '@wordpress/element';
31510   *
31511   * function Example() {
31512   *   const [ sides, setSides ] = useState( {
31513   *     top: '0px',
31514   *     right: '0px',
31515   *     bottom: '0px',
31516   *     left: '0px',
31517   *   } );
31518   *
31519   *   return (
31520   *     <SpacingSizesControl
31521   *       values={ sides }
31522   *       onChange={ setSides }
31523   *       label="Sides"
31524   *     />
31525   *   );
31526   * }
31527   * ```
31528   *
31529   * @param {Object}   props                    Component props.
31530   * @param {Object}   props.inputProps         Additional props for input controls.
31531   * @param {string}   props.label              Label for the control.
31532   * @param {number}   props.minimumCustomValue Minimum value for custom input.
31533   * @param {Function} props.onChange           Called when spacing values change.
31534   * @param {Function} props.onMouseOut         Called when mouse leaves the control.
31535   * @param {Function} props.onMouseOver        Called when mouse enters the control.
31536   * @param {boolean}  props.showSideInLabel    Show side in control label.
31537   * @param {Array}    props.sides              Available sides for control.
31538   * @param {boolean}  props.useSelect          Use select control for predefined values.
31539   * @param {Object}   props.values             Current spacing values.
31540   * @return {Element}                         Spacing sizes control component.
31541   */
31542  
31543  function SpacingSizesControl({
31544    inputProps,
31545    label: labelProp,
31546    minimumCustomValue = 0,
31547    onChange,
31548    onMouseOut,
31549    onMouseOver,
31550    showSideInLabel = true,
31551    sides = ALL_SIDES,
31552    useSelect,
31553    values
31554  }) {
31555    const spacingSizes = useSpacingSizes();
31556    const inputValues = values || DEFAULT_VALUES;
31557    const hasOneSide = sides?.length === 1;
31558    const hasOnlyAxialSides = sides?.includes('horizontal') && sides?.includes('vertical') && sides?.length === 2;
31559    const [view, setView] = (0,external_wp_element_namespaceObject.useState)(getInitialView(inputValues, sides));
31560    const toggleLinked = () => {
31561      setView(view === VIEWS.axial ? VIEWS.custom : VIEWS.axial);
31562    };
31563    const handleOnChange = nextValue => {
31564      const newValues = {
31565        ...values,
31566        ...nextValue
31567      };
31568      onChange(newValues);
31569    };
31570    const inputControlProps = {
31571      ...inputProps,
31572      minimumCustomValue,
31573      onChange: handleOnChange,
31574      onMouseOut,
31575      onMouseOver,
31576      sides,
31577      spacingSizes,
31578      type: labelProp,
31579      useSelect,
31580      values: inputValues
31581    };
31582    const renderControls = () => {
31583      if (view === VIEWS.axial) {
31584        return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(AxialInputControls, {
31585          ...inputControlProps
31586        });
31587      }
31588      if (view === VIEWS.custom) {
31589        return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(SeparatedInputControls, {
31590          ...inputControlProps
31591        });
31592      }
31593      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(SingleInputControl, {
31594        side: view,
31595        ...inputControlProps,
31596        showSideInLabel: showSideInLabel
31597      });
31598    };
31599    const sideLabel = ALL_SIDES.includes(view) && showSideInLabel ? LABELS[view] : '';
31600    const label = (0,external_wp_i18n_namespaceObject.sprintf)(
31601    // translators: 1: The side of the block being modified (top, bottom, left etc.). 2. Type of spacing being modified (padding, margin, etc).
31602    (0,external_wp_i18n_namespaceObject._x)('%1$s %2$s', 'spacing'), labelProp, sideLabel).trim();
31603    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("fieldset", {
31604      className: "spacing-sizes-control",
31605      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalHStack, {
31606        className: "spacing-sizes-control__header",
31607        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.BaseControl.VisualLabel, {
31608          as: "legend",
31609          className: "spacing-sizes-control__label",
31610          children: label
31611        }), !hasOneSide && !hasOnlyAxialSides && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(linked_button_LinkedButton, {
31612          label: labelProp,
31613          onClick: toggleLinked,
31614          isLinked: view === VIEWS.axial
31615        })]
31616      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalVStack, {
31617        spacing: 0.5,
31618        children: renderControls()
31619      })]
31620    });
31621  }
31622  
31623  ;// ./node_modules/@wordpress/block-editor/build-module/components/height-control/index.js
31624  /**
31625   * WordPress dependencies
31626   */
31627  
31628  
31629  
31630  
31631  /**
31632   * Internal dependencies
31633   */
31634  
31635  
31636  const RANGE_CONTROL_CUSTOM_SETTINGS = {
31637    px: {
31638      max: 1000,
31639      step: 1
31640    },
31641    '%': {
31642      max: 100,
31643      step: 1
31644    },
31645    vw: {
31646      max: 100,
31647      step: 1
31648    },
31649    vh: {
31650      max: 100,
31651      step: 1
31652    },
31653    em: {
31654      max: 50,
31655      step: 0.1
31656    },
31657    rem: {
31658      max: 50,
31659      step: 0.1
31660    },
31661    svw: {
31662      max: 100,
31663      step: 1
31664    },
31665    lvw: {
31666      max: 100,
31667      step: 1
31668    },
31669    dvw: {
31670      max: 100,
31671      step: 1
31672    },
31673    svh: {
31674      max: 100,
31675      step: 1
31676    },
31677    lvh: {
31678      max: 100,
31679      step: 1
31680    },
31681    dvh: {
31682      max: 100,
31683      step: 1
31684    },
31685    vi: {
31686      max: 100,
31687      step: 1
31688    },
31689    svi: {
31690      max: 100,
31691      step: 1
31692    },
31693    lvi: {
31694      max: 100,
31695      step: 1
31696    },
31697    dvi: {
31698      max: 100,
31699      step: 1
31700    },
31701    vb: {
31702      max: 100,
31703      step: 1
31704    },
31705    svb: {
31706      max: 100,
31707      step: 1
31708    },
31709    lvb: {
31710      max: 100,
31711      step: 1
31712    },
31713    dvb: {
31714      max: 100,
31715      step: 1
31716    },
31717    vmin: {
31718      max: 100,
31719      step: 1
31720    },
31721    svmin: {
31722      max: 100,
31723      step: 1
31724    },
31725    lvmin: {
31726      max: 100,
31727      step: 1
31728    },
31729    dvmin: {
31730      max: 100,
31731      step: 1
31732    },
31733    vmax: {
31734      max: 100,
31735      step: 1
31736    },
31737    svmax: {
31738      max: 100,
31739      step: 1
31740    },
31741    lvmax: {
31742      max: 100,
31743      step: 1
31744    },
31745    dvmax: {
31746      max: 100,
31747      step: 1
31748    }
31749  };
31750  
31751  /**
31752   * HeightControl renders a linked unit control and range control for adjusting the height of a block.
31753   *
31754   * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/height-control/README.md
31755   *
31756   * @param {Object}                     props
31757   * @param {?string}                    props.label    A label for the control.
31758   * @param {( value: string ) => void } props.onChange Called when the height changes.
31759   * @param {string}                     props.value    The current height value.
31760   *
31761   * @return {Component} The component to be rendered.
31762   */
31763  function HeightControl({
31764    label = (0,external_wp_i18n_namespaceObject.__)('Height'),
31765    onChange,
31766    value
31767  }) {
31768    var _RANGE_CONTROL_CUSTOM, _RANGE_CONTROL_CUSTOM2;
31769    const customRangeValue = parseFloat(value);
31770    const [availableUnits] = use_settings_useSettings('spacing.units');
31771    const units = (0,external_wp_components_namespaceObject.__experimentalUseCustomUnits)({
31772      availableUnits: availableUnits || ['%', 'px', 'em', 'rem', 'vh', 'vw']
31773    });
31774    const selectedUnit = (0,external_wp_element_namespaceObject.useMemo)(() => (0,external_wp_components_namespaceObject.__experimentalParseQuantityAndUnitFromRawValue)(value), [value])[1] || units[0]?.value || 'px';
31775    const handleSliderChange = next => {
31776      onChange([next, selectedUnit].join(''));
31777    };
31778    const handleUnitChange = newUnit => {
31779      // Attempt to smooth over differences between currentUnit and newUnit.
31780      // This should slightly improve the experience of switching between unit types.
31781      const [currentValue, currentUnit] = (0,external_wp_components_namespaceObject.__experimentalParseQuantityAndUnitFromRawValue)(value);
31782      if (['em', 'rem'].includes(newUnit) && currentUnit === 'px') {
31783        // Convert pixel value to an approximate of the new unit, assuming a root size of 16px.
31784        onChange((currentValue / 16).toFixed(2) + newUnit);
31785      } else if (['em', 'rem'].includes(currentUnit) && newUnit === 'px') {
31786        // Convert to pixel value assuming a root size of 16px.
31787        onChange(Math.round(currentValue * 16) + newUnit);
31788      } else if (['%', 'vw', 'svw', 'lvw', 'dvw', 'vh', 'svh', 'lvh', 'dvh', 'vi', 'svi', 'lvi', 'dvi', 'vb', 'svb', 'lvb', 'dvb', 'vmin', 'svmin', 'lvmin', 'dvmin', 'vmax', 'svmax', 'lvmax', 'dvmax'].includes(newUnit) && currentValue > 100) {
31789        // When converting to `%` or viewport-relative units, cap the new value at 100.
31790        onChange(100 + newUnit);
31791      }
31792    };
31793    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("fieldset", {
31794      className: "block-editor-height-control",
31795      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.BaseControl.VisualLabel, {
31796        as: "legend",
31797        children: label
31798      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.Flex, {
31799        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FlexItem, {
31800          isBlock: true,
31801          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalUnitControl, {
31802            value: value,
31803            units: units,
31804            onChange: onChange,
31805            onUnitChange: handleUnitChange,
31806            min: 0,
31807            size: "__unstable-large",
31808            label: label,
31809            hideLabelFromVision: true
31810          })
31811        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FlexItem, {
31812          isBlock: true,
31813          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalSpacer, {
31814            marginX: 2,
31815            marginBottom: 0,
31816            children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.RangeControl, {
31817              __next40pxDefaultSize: true,
31818              value: customRangeValue,
31819              min: 0,
31820              max: (_RANGE_CONTROL_CUSTOM = RANGE_CONTROL_CUSTOM_SETTINGS[selectedUnit]?.max) !== null && _RANGE_CONTROL_CUSTOM !== void 0 ? _RANGE_CONTROL_CUSTOM : 100,
31821              step: (_RANGE_CONTROL_CUSTOM2 = RANGE_CONTROL_CUSTOM_SETTINGS[selectedUnit]?.step) !== null && _RANGE_CONTROL_CUSTOM2 !== void 0 ? _RANGE_CONTROL_CUSTOM2 : 0.1,
31822              withInputField: false,
31823              onChange: handleSliderChange,
31824              __nextHasNoMarginBottom: true,
31825              label: label,
31826              hideLabelFromVision: true
31827            })
31828          })
31829        })]
31830      })]
31831    });
31832  }
31833  
31834  ;// ./node_modules/@wordpress/block-editor/build-module/components/grid/use-get-number-of-blocks-before-cell.js
31835  /**
31836   * WordPress dependencies
31837   */
31838  
31839  
31840  /**
31841   * Internal dependencies
31842   */
31843  
31844  function useGetNumberOfBlocksBeforeCell(gridClientId, numColumns) {
31845    const {
31846      getBlockOrder,
31847      getBlockAttributes
31848    } = (0,external_wp_data_namespaceObject.useSelect)(store);
31849    const getNumberOfBlocksBeforeCell = (column, row) => {
31850      const targetIndex = (row - 1) * numColumns + column - 1;
31851      let count = 0;
31852      for (const clientId of getBlockOrder(gridClientId)) {
31853        var _getBlockAttributes$s;
31854        const {
31855          columnStart,
31856          rowStart
31857        } = (_getBlockAttributes$s = getBlockAttributes(clientId).style?.layout) !== null && _getBlockAttributes$s !== void 0 ? _getBlockAttributes$s : {};
31858        const cellIndex = (rowStart - 1) * numColumns + columnStart - 1;
31859        if (cellIndex < targetIndex) {
31860          count++;
31861        }
31862      }
31863      return count;
31864    };
31865    return getNumberOfBlocksBeforeCell;
31866  }
31867  
31868  ;// ./node_modules/@wordpress/block-editor/build-module/components/child-layout-control/index.js
31869  /**
31870   * WordPress dependencies
31871   */
31872  
31873  
31874  
31875  
31876  
31877  /**
31878   * Internal dependencies
31879   */
31880  
31881  
31882  
31883  
31884  function helpText(selfStretch, parentLayout) {
31885    const {
31886      orientation = 'horizontal'
31887    } = parentLayout;
31888    if (selfStretch === 'fill') {
31889      return (0,external_wp_i18n_namespaceObject.__)('Stretch to fill available space.');
31890    }
31891    if (selfStretch === 'fixed' && orientation === 'horizontal') {
31892      return (0,external_wp_i18n_namespaceObject.__)('Specify a fixed width.');
31893    } else if (selfStretch === 'fixed') {
31894      return (0,external_wp_i18n_namespaceObject.__)('Specify a fixed height.');
31895    }
31896    return (0,external_wp_i18n_namespaceObject.__)('Fit contents.');
31897  }
31898  
31899  /**
31900   * Form to edit the child layout value.
31901   *
31902   * @param {Object}   props                  Props.
31903   * @param {Object}   props.value            The child layout value.
31904   * @param {Function} props.onChange         Function to update the child layout value.
31905   * @param {Object}   props.parentLayout     The parent layout value.
31906   *
31907   * @param {boolean}  props.isShownByDefault
31908   * @param {string}   props.panelId
31909   * @return {Element} child layout edit element.
31910   */
31911  function ChildLayoutControl({
31912    value: childLayout = {},
31913    onChange,
31914    parentLayout,
31915    isShownByDefault,
31916    panelId
31917  }) {
31918    const {
31919      type: parentType,
31920      default: {
31921        type: defaultParentType = 'default'
31922      } = {}
31923    } = parentLayout !== null && parentLayout !== void 0 ? parentLayout : {};
31924    const parentLayoutType = parentType || defaultParentType;
31925    if (parentLayoutType === 'flex') {
31926      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(FlexControls, {
31927        childLayout: childLayout,
31928        onChange: onChange,
31929        parentLayout: parentLayout,
31930        isShownByDefault: isShownByDefault,
31931        panelId: panelId
31932      });
31933    } else if (parentLayoutType === 'grid') {
31934      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(GridControls, {
31935        childLayout: childLayout,
31936        onChange: onChange,
31937        parentLayout: parentLayout,
31938        isShownByDefault: isShownByDefault,
31939        panelId: panelId
31940      });
31941    }
31942    return null;
31943  }
31944  function FlexControls({
31945    childLayout,
31946    onChange,
31947    parentLayout,
31948    isShownByDefault,
31949    panelId
31950  }) {
31951    const {
31952      selfStretch,
31953      flexSize
31954    } = childLayout;
31955    const {
31956      orientation = 'horizontal'
31957    } = parentLayout !== null && parentLayout !== void 0 ? parentLayout : {};
31958    const hasFlexValue = () => !!selfStretch;
31959    const flexResetLabel = orientation === 'horizontal' ? (0,external_wp_i18n_namespaceObject.__)('Width') : (0,external_wp_i18n_namespaceObject.__)('Height');
31960    const [availableUnits] = use_settings_useSettings('spacing.units');
31961    const units = (0,external_wp_components_namespaceObject.__experimentalUseCustomUnits)({
31962      availableUnits: availableUnits || ['%', 'px', 'em', 'rem', 'vh', 'vw']
31963    });
31964    const resetFlex = () => {
31965      onChange({
31966        selfStretch: undefined,
31967        flexSize: undefined
31968      });
31969    };
31970    (0,external_wp_element_namespaceObject.useEffect)(() => {
31971      if (selfStretch === 'fixed' && !flexSize) {
31972        onChange({
31973          ...childLayout,
31974          selfStretch: 'fit'
31975        });
31976      }
31977    }, []);
31978    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalVStack, {
31979      as: external_wp_components_namespaceObject.__experimentalToolsPanelItem,
31980      spacing: 2,
31981      hasValue: hasFlexValue,
31982      label: flexResetLabel,
31983      onDeselect: resetFlex,
31984      isShownByDefault: isShownByDefault,
31985      panelId: panelId,
31986      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalToggleGroupControl, {
31987        __nextHasNoMarginBottom: true,
31988        size: "__unstable-large",
31989        label: childLayoutOrientation(parentLayout),
31990        value: selfStretch || 'fit',
31991        help: helpText(selfStretch, parentLayout),
31992        onChange: value => {
31993          const newFlexSize = value !== 'fixed' ? null : flexSize;
31994          onChange({
31995            selfStretch: value,
31996            flexSize: newFlexSize
31997          });
31998        },
31999        isBlock: true,
32000        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControlOption, {
32001          value: "fit",
32002          label: (0,external_wp_i18n_namespaceObject._x)('Fit', 'Intrinsic block width in flex layout')
32003        }, "fit"), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControlOption, {
32004          value: "fill",
32005          label: (0,external_wp_i18n_namespaceObject._x)('Grow', 'Block with expanding width in flex layout')
32006        }, "fill"), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControlOption, {
32007          value: "fixed",
32008          label: (0,external_wp_i18n_namespaceObject._x)('Fixed', 'Block with fixed width in flex layout')
32009        }, "fixed")]
32010      }), selfStretch === 'fixed' && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalUnitControl, {
32011        size: "__unstable-large",
32012        units: units,
32013        onChange: value => {
32014          onChange({
32015            selfStretch,
32016            flexSize: value
32017          });
32018        },
32019        value: flexSize,
32020        label: flexResetLabel,
32021        hideLabelFromVision: true
32022      })]
32023    });
32024  }
32025  function childLayoutOrientation(parentLayout) {
32026    const {
32027      orientation = 'horizontal'
32028    } = parentLayout;
32029    return orientation === 'horizontal' ? (0,external_wp_i18n_namespaceObject.__)('Width') : (0,external_wp_i18n_namespaceObject.__)('Height');
32030  }
32031  function GridControls({
32032    childLayout,
32033    onChange,
32034    parentLayout,
32035    isShownByDefault,
32036    panelId
32037  }) {
32038    const {
32039      columnStart,
32040      rowStart,
32041      columnSpan,
32042      rowSpan
32043    } = childLayout;
32044    const {
32045      columnCount = 3,
32046      rowCount
32047    } = parentLayout !== null && parentLayout !== void 0 ? parentLayout : {};
32048    const rootClientId = (0,external_wp_data_namespaceObject.useSelect)(select => select(store).getBlockRootClientId(panelId));
32049    const {
32050      moveBlocksToPosition,
32051      __unstableMarkNextChangeAsNotPersistent
32052    } = (0,external_wp_data_namespaceObject.useDispatch)(store);
32053    const getNumberOfBlocksBeforeCell = useGetNumberOfBlocksBeforeCell(rootClientId, columnCount);
32054    const hasStartValue = () => !!columnStart || !!rowStart;
32055    const hasSpanValue = () => !!columnSpan || !!rowSpan;
32056    const resetGridStarts = () => {
32057      onChange({
32058        columnStart: undefined,
32059        rowStart: undefined
32060      });
32061    };
32062    const resetGridSpans = () => {
32063      onChange({
32064        columnSpan: undefined,
32065        rowSpan: undefined
32066      });
32067    };
32068    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
32069      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalHStack, {
32070        as: external_wp_components_namespaceObject.__experimentalToolsPanelItem,
32071        hasValue: hasSpanValue,
32072        label: (0,external_wp_i18n_namespaceObject.__)('Grid span'),
32073        onDeselect: resetGridSpans,
32074        isShownByDefault: isShownByDefault,
32075        panelId: panelId,
32076        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalInputControl, {
32077          size: "__unstable-large",
32078          label: (0,external_wp_i18n_namespaceObject.__)('Column span'),
32079          type: "number",
32080          onChange: value => {
32081            // Don't allow unsetting.
32082            const newColumnSpan = value === '' ? 1 : parseInt(value, 10);
32083            onChange({
32084              columnStart,
32085              rowStart,
32086              rowSpan,
32087              columnSpan: newColumnSpan
32088            });
32089          },
32090          value: columnSpan !== null && columnSpan !== void 0 ? columnSpan : 1,
32091          min: 1
32092        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalInputControl, {
32093          size: "__unstable-large",
32094          label: (0,external_wp_i18n_namespaceObject.__)('Row span'),
32095          type: "number",
32096          onChange: value => {
32097            // Don't allow unsetting.
32098            const newRowSpan = value === '' ? 1 : parseInt(value, 10);
32099            onChange({
32100              columnStart,
32101              rowStart,
32102              columnSpan,
32103              rowSpan: newRowSpan
32104            });
32105          },
32106          value: rowSpan !== null && rowSpan !== void 0 ? rowSpan : 1,
32107          min: 1
32108        })]
32109      }), window.__experimentalEnableGridInteractivity && columnCount &&
32110      /*#__PURE__*/
32111      // Use Flex with an explicit width on the FlexItem instead of HStack to
32112      // work around an issue in webkit where inputs with a max attribute are
32113      // sized incorrectly.
32114      (0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.Flex, {
32115        as: external_wp_components_namespaceObject.__experimentalToolsPanelItem,
32116        hasValue: hasStartValue,
32117        label: (0,external_wp_i18n_namespaceObject.__)('Grid placement'),
32118        onDeselect: resetGridStarts,
32119        isShownByDefault: false,
32120        panelId: panelId,
32121        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FlexItem, {
32122          style: {
32123            width: '50%'
32124          },
32125          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalInputControl, {
32126            size: "__unstable-large",
32127            label: (0,external_wp_i18n_namespaceObject.__)('Column'),
32128            type: "number",
32129            onChange: value => {
32130              // Don't allow unsetting.
32131              const newColumnStart = value === '' ? 1 : parseInt(value, 10);
32132              onChange({
32133                columnStart: newColumnStart,
32134                rowStart,
32135                columnSpan,
32136                rowSpan
32137              });
32138              __unstableMarkNextChangeAsNotPersistent();
32139              moveBlocksToPosition([panelId], rootClientId, rootClientId, getNumberOfBlocksBeforeCell(newColumnStart, rowStart));
32140            },
32141            value: columnStart !== null && columnStart !== void 0 ? columnStart : 1,
32142            min: 1,
32143            max: columnCount ? columnCount - (columnSpan !== null && columnSpan !== void 0 ? columnSpan : 1) + 1 : undefined
32144          })
32145        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FlexItem, {
32146          style: {
32147            width: '50%'
32148          },
32149          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalInputControl, {
32150            size: "__unstable-large",
32151            label: (0,external_wp_i18n_namespaceObject.__)('Row'),
32152            type: "number",
32153            onChange: value => {
32154              // Don't allow unsetting.
32155              const newRowStart = value === '' ? 1 : parseInt(value, 10);
32156              onChange({
32157                columnStart,
32158                rowStart: newRowStart,
32159                columnSpan,
32160                rowSpan
32161              });
32162              __unstableMarkNextChangeAsNotPersistent();
32163              moveBlocksToPosition([panelId], rootClientId, rootClientId, getNumberOfBlocksBeforeCell(columnStart, newRowStart));
32164            },
32165            value: rowStart !== null && rowStart !== void 0 ? rowStart : 1,
32166            min: 1,
32167            max: rowCount ? rowCount - (rowSpan !== null && rowSpan !== void 0 ? rowSpan : 1) + 1 : undefined
32168          })
32169        })]
32170      })]
32171    });
32172  }
32173  
32174  ;// ./node_modules/@wordpress/block-editor/build-module/components/dimensions-tool/aspect-ratio-tool.js
32175  /**
32176   * WordPress dependencies
32177   */
32178  
32179  
32180  /**
32181   * Internal dependencies
32182   */
32183  
32184  
32185  /**
32186   * @typedef {import('@wordpress/components/build-types/select-control/types').SelectControlProps} SelectControlProps
32187   */
32188  
32189  /**
32190   * @callback AspectRatioToolPropsOnChange
32191   * @param {string} [value] New aspect ratio value.
32192   * @return {void} No return.
32193   */
32194  
32195  /**
32196   * @typedef {Object} AspectRatioToolProps
32197   * @property {string}                       [panelId]          ID of the panel this tool is associated with.
32198   * @property {string}                       [value]            Current aspect ratio value.
32199   * @property {AspectRatioToolPropsOnChange} [onChange]         Callback to update the aspect ratio value.
32200   * @property {SelectControlProps[]}         [options]          Aspect ratio options.
32201   * @property {string}                       [defaultValue]     Default aspect ratio value.
32202   * @property {boolean}                      [isShownByDefault] Whether the tool is shown by default.
32203   */
32204  
32205  function AspectRatioTool({
32206    panelId,
32207    value,
32208    onChange = () => {},
32209    options,
32210    defaultValue = 'auto',
32211    hasValue,
32212    isShownByDefault = true
32213  }) {
32214    // Match the CSS default so if the value is used directly in CSS it will look correct in the control.
32215    const displayValue = value !== null && value !== void 0 ? value : 'auto';
32216    const [defaultRatios, themeRatios, showDefaultRatios] = use_settings_useSettings('dimensions.aspectRatios.default', 'dimensions.aspectRatios.theme', 'dimensions.defaultAspectRatios');
32217    const themeOptions = themeRatios?.map(({
32218      name,
32219      ratio
32220    }) => ({
32221      label: name,
32222      value: ratio
32223    }));
32224    const defaultOptions = defaultRatios?.map(({
32225      name,
32226      ratio
32227    }) => ({
32228      label: name,
32229      value: ratio
32230    }));
32231    const aspectRatioOptions = [{
32232      label: (0,external_wp_i18n_namespaceObject._x)('Original', 'Aspect ratio option for dimensions control'),
32233      value: 'auto'
32234    }, ...(showDefaultRatios ? defaultOptions : []), ...(themeOptions ? themeOptions : []), {
32235      label: (0,external_wp_i18n_namespaceObject._x)('Custom', 'Aspect ratio option for dimensions control'),
32236      value: 'custom',
32237      disabled: true,
32238      hidden: true
32239    }];
32240    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanelItem, {
32241      hasValue: hasValue ? hasValue : () => displayValue !== defaultValue,
32242      label: (0,external_wp_i18n_namespaceObject.__)('Aspect ratio'),
32243      onDeselect: () => onChange(undefined),
32244      isShownByDefault: isShownByDefault,
32245      panelId: panelId,
32246      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.SelectControl, {
32247        label: (0,external_wp_i18n_namespaceObject.__)('Aspect ratio'),
32248        value: displayValue,
32249        options: options !== null && options !== void 0 ? options : aspectRatioOptions,
32250        onChange: onChange,
32251        size: "__unstable-large",
32252        __nextHasNoMarginBottom: true
32253      })
32254    });
32255  }
32256  
32257  ;// ./node_modules/@wordpress/block-editor/build-module/components/global-styles/dimensions-panel.js
32258  /**
32259   * External dependencies
32260   */
32261  
32262  
32263  /**
32264   * WordPress dependencies
32265   */
32266  
32267  
32268  
32269  
32270  
32271  /**
32272   * Internal dependencies
32273   */
32274  
32275  
32276  
32277  
32278  
32279  
32280  
32281  
32282  const AXIAL_SIDES = ['horizontal', 'vertical'];
32283  function useHasDimensionsPanel(settings) {
32284    const hasContentSize = useHasContentSize(settings);
32285    const hasWideSize = useHasWideSize(settings);
32286    const hasPadding = useHasPadding(settings);
32287    const hasMargin = useHasMargin(settings);
32288    const hasGap = useHasGap(settings);
32289    const hasMinHeight = useHasMinHeight(settings);
32290    const hasAspectRatio = useHasAspectRatio(settings);
32291    const hasChildLayout = useHasChildLayout(settings);
32292    return external_wp_element_namespaceObject.Platform.OS === 'web' && (hasContentSize || hasWideSize || hasPadding || hasMargin || hasGap || hasMinHeight || hasAspectRatio || hasChildLayout);
32293  }
32294  function useHasContentSize(settings) {
32295    return settings?.layout?.contentSize;
32296  }
32297  function useHasWideSize(settings) {
32298    return settings?.layout?.wideSize;
32299  }
32300  function useHasPadding(settings) {
32301    return settings?.spacing?.padding;
32302  }
32303  function useHasMargin(settings) {
32304    return settings?.spacing?.margin;
32305  }
32306  function useHasGap(settings) {
32307    return settings?.spacing?.blockGap;
32308  }
32309  function useHasMinHeight(settings) {
32310    return settings?.dimensions?.minHeight;
32311  }
32312  function useHasAspectRatio(settings) {
32313    return settings?.dimensions?.aspectRatio;
32314  }
32315  function useHasChildLayout(settings) {
32316    var _settings$parentLayou;
32317    const {
32318      type: parentLayoutType = 'default',
32319      default: {
32320        type: defaultParentLayoutType = 'default'
32321      } = {},
32322      allowSizingOnChildren = false
32323    } = (_settings$parentLayou = settings?.parentLayout) !== null && _settings$parentLayou !== void 0 ? _settings$parentLayou : {};
32324    const support = (defaultParentLayoutType === 'flex' || parentLayoutType === 'flex' || defaultParentLayoutType === 'grid' || parentLayoutType === 'grid') && allowSizingOnChildren;
32325    return !!settings?.layout && support;
32326  }
32327  function useHasSpacingPresets(settings) {
32328    const {
32329      defaultSpacingSizes,
32330      spacingSizes
32331    } = settings?.spacing || {};
32332    return defaultSpacingSizes !== false && spacingSizes?.default?.length > 0 || spacingSizes?.theme?.length > 0 || spacingSizes?.custom?.length > 0;
32333  }
32334  function filterValuesBySides(values, sides) {
32335    // If no custom side configuration, all sides are opted into by default.
32336    // Without any values, we have nothing to filter either.
32337    if (!sides || !values) {
32338      return values;
32339    }
32340  
32341    // Only include sides opted into within filtered values.
32342    const filteredValues = {};
32343    sides.forEach(side => {
32344      if (side === 'vertical') {
32345        filteredValues.top = values.top;
32346        filteredValues.bottom = values.bottom;
32347      }
32348      if (side === 'horizontal') {
32349        filteredValues.left = values.left;
32350        filteredValues.right = values.right;
32351      }
32352      filteredValues[side] = values?.[side];
32353    });
32354    return filteredValues;
32355  }
32356  function splitStyleValue(value) {
32357    // Check for shorthand value (a string value).
32358    if (value && typeof value === 'string') {
32359      // Convert to value for individual sides for BoxControl.
32360      return {
32361        top: value,
32362        right: value,
32363        bottom: value,
32364        left: value
32365      };
32366    }
32367    return value;
32368  }
32369  function splitGapValue(value, isAxialGap) {
32370    if (!value) {
32371      return value;
32372    }
32373  
32374    // Check for shorthand value (a string value).
32375    if (typeof value === 'string') {
32376      /*
32377       * Map the string value to appropriate sides for the spacing control depending
32378       * on whether the current block has axial gap support or not.
32379       *
32380       * Note: The axial value pairs must match for the spacing control to display
32381       * the appropriate horizontal/vertical sliders.
32382       */
32383      return isAxialGap ? {
32384        top: value,
32385        right: value,
32386        bottom: value,
32387        left: value
32388      } : {
32389        top: value
32390      };
32391    }
32392    return {
32393      ...value,
32394      right: value?.left,
32395      bottom: value?.top
32396    };
32397  }
32398  function DimensionsToolsPanel({
32399    resetAllFilter,
32400    onChange,
32401    value,
32402    panelId,
32403    children
32404  }) {
32405    const dropdownMenuProps = useToolsPanelDropdownMenuProps();
32406    const resetAll = () => {
32407      const updatedValue = resetAllFilter(value);
32408      onChange(updatedValue);
32409    };
32410    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanel, {
32411      label: (0,external_wp_i18n_namespaceObject.__)('Dimensions'),
32412      resetAll: resetAll,
32413      panelId: panelId,
32414      dropdownMenuProps: dropdownMenuProps,
32415      children: children
32416    });
32417  }
32418  const dimensions_panel_DEFAULT_CONTROLS = {
32419    contentSize: true,
32420    wideSize: true,
32421    padding: true,
32422    margin: true,
32423    blockGap: true,
32424    minHeight: true,
32425    aspectRatio: true,
32426    childLayout: true
32427  };
32428  function DimensionsPanel({
32429    as: Wrapper = DimensionsToolsPanel,
32430    value,
32431    onChange,
32432    inheritedValue = value,
32433    settings,
32434    panelId,
32435    defaultControls = dimensions_panel_DEFAULT_CONTROLS,
32436    onVisualize = () => {},
32437    // Special case because the layout controls are not part of the dimensions panel
32438    // in global styles but not in block inspector.
32439    includeLayoutControls = false
32440  }) {
32441    var _defaultControls$cont, _defaultControls$wide, _defaultControls$padd, _defaultControls$marg, _defaultControls$bloc, _defaultControls$chil, _defaultControls$minH, _defaultControls$aspe;
32442    const {
32443      dimensions,
32444      spacing
32445    } = settings;
32446    const decodeValue = rawValue => {
32447      if (rawValue && typeof rawValue === 'object') {
32448        return Object.keys(rawValue).reduce((acc, key) => {
32449          acc[key] = getValueFromVariable({
32450            settings: {
32451              dimensions,
32452              spacing
32453            }
32454          }, '', rawValue[key]);
32455          return acc;
32456        }, {});
32457      }
32458      return getValueFromVariable({
32459        settings: {
32460          dimensions,
32461          spacing
32462        }
32463      }, '', rawValue);
32464    };
32465    const showSpacingPresetsControl = useHasSpacingPresets(settings);
32466    const units = (0,external_wp_components_namespaceObject.__experimentalUseCustomUnits)({
32467      availableUnits: settings?.spacing?.units || ['%', 'px', 'em', 'rem', 'vw']
32468    });
32469  
32470    //Minimum Margin Value
32471    const minimumMargin = -Infinity;
32472    const [minMarginValue, setMinMarginValue] = (0,external_wp_element_namespaceObject.useState)(minimumMargin);
32473  
32474    // Content Width
32475    const showContentSizeControl = useHasContentSize(settings) && includeLayoutControls;
32476    const contentSizeValue = decodeValue(inheritedValue?.layout?.contentSize);
32477    const setContentSizeValue = newValue => {
32478      onChange(setImmutably(value, ['layout', 'contentSize'], newValue || undefined));
32479    };
32480    const hasUserSetContentSizeValue = () => !!value?.layout?.contentSize;
32481    const resetContentSizeValue = () => setContentSizeValue(undefined);
32482  
32483    // Wide Width
32484    const showWideSizeControl = useHasWideSize(settings) && includeLayoutControls;
32485    const wideSizeValue = decodeValue(inheritedValue?.layout?.wideSize);
32486    const setWideSizeValue = newValue => {
32487      onChange(setImmutably(value, ['layout', 'wideSize'], newValue || undefined));
32488    };
32489    const hasUserSetWideSizeValue = () => !!value?.layout?.wideSize;
32490    const resetWideSizeValue = () => setWideSizeValue(undefined);
32491  
32492    // Padding
32493    const showPaddingControl = useHasPadding(settings);
32494    const rawPadding = decodeValue(inheritedValue?.spacing?.padding);
32495    const paddingValues = splitStyleValue(rawPadding);
32496    const paddingSides = Array.isArray(settings?.spacing?.padding) ? settings?.spacing?.padding : settings?.spacing?.padding?.sides;
32497    const isAxialPadding = paddingSides && paddingSides.some(side => AXIAL_SIDES.includes(side));
32498    const setPaddingValues = newPaddingValues => {
32499      const padding = filterValuesBySides(newPaddingValues, paddingSides);
32500      onChange(setImmutably(value, ['spacing', 'padding'], padding));
32501    };
32502    const hasPaddingValue = () => !!value?.spacing?.padding && Object.keys(value?.spacing?.padding).length;
32503    const resetPaddingValue = () => setPaddingValues(undefined);
32504    const onMouseOverPadding = () => onVisualize('padding');
32505  
32506    // Margin
32507    const showMarginControl = useHasMargin(settings);
32508    const rawMargin = decodeValue(inheritedValue?.spacing?.margin);
32509    const marginValues = splitStyleValue(rawMargin);
32510    const marginSides = Array.isArray(settings?.spacing?.margin) ? settings?.spacing?.margin : settings?.spacing?.margin?.sides;
32511    const isAxialMargin = marginSides && marginSides.some(side => AXIAL_SIDES.includes(side));
32512    const setMarginValues = newMarginValues => {
32513      const margin = filterValuesBySides(newMarginValues, marginSides);
32514      onChange(setImmutably(value, ['spacing', 'margin'], margin));
32515    };
32516    const hasMarginValue = () => !!value?.spacing?.margin && Object.keys(value?.spacing?.margin).length;
32517    const resetMarginValue = () => setMarginValues(undefined);
32518    const onMouseOverMargin = () => onVisualize('margin');
32519  
32520    // Block Gap
32521    const showGapControl = useHasGap(settings);
32522    const gapSides = Array.isArray(settings?.spacing?.blockGap) ? settings?.spacing?.blockGap : settings?.spacing?.blockGap?.sides;
32523    const isAxialGap = gapSides && gapSides.some(side => AXIAL_SIDES.includes(side));
32524    const gapValue = decodeValue(inheritedValue?.spacing?.blockGap);
32525    const gapValues = splitGapValue(gapValue, isAxialGap);
32526    const setGapValue = newGapValue => {
32527      onChange(setImmutably(value, ['spacing', 'blockGap'], newGapValue));
32528    };
32529    const setGapValues = nextBoxGapValue => {
32530      if (!nextBoxGapValue) {
32531        setGapValue(null);
32532      }
32533      // If axial gap is not enabled, treat the 'top' value as the shorthand gap value.
32534      if (!isAxialGap && nextBoxGapValue?.hasOwnProperty('top')) {
32535        setGapValue(nextBoxGapValue.top);
32536      } else {
32537        setGapValue({
32538          top: nextBoxGapValue?.top,
32539          left: nextBoxGapValue?.left
32540        });
32541      }
32542    };
32543    const resetGapValue = () => setGapValue(undefined);
32544    const hasGapValue = () => !!value?.spacing?.blockGap;
32545  
32546    // Min Height
32547    const showMinHeightControl = useHasMinHeight(settings);
32548    const minHeightValue = decodeValue(inheritedValue?.dimensions?.minHeight);
32549    const setMinHeightValue = newValue => {
32550      const tempValue = setImmutably(value, ['dimensions', 'minHeight'], newValue);
32551      // Apply min-height, while removing any applied aspect ratio.
32552      onChange(setImmutably(tempValue, ['dimensions', 'aspectRatio'], undefined));
32553    };
32554    const resetMinHeightValue = () => {
32555      setMinHeightValue(undefined);
32556    };
32557    const hasMinHeightValue = () => !!value?.dimensions?.minHeight;
32558  
32559    // Aspect Ratio
32560    const showAspectRatioControl = useHasAspectRatio(settings);
32561    const aspectRatioValue = decodeValue(inheritedValue?.dimensions?.aspectRatio);
32562    const setAspectRatioValue = newValue => {
32563      const tempValue = setImmutably(value, ['dimensions', 'aspectRatio'], newValue);
32564      // Apply aspect-ratio, while removing any applied min-height.
32565      onChange(setImmutably(tempValue, ['dimensions', 'minHeight'], undefined));
32566    };
32567    const hasAspectRatioValue = () => !!value?.dimensions?.aspectRatio;
32568  
32569    // Child Layout
32570    const showChildLayoutControl = useHasChildLayout(settings);
32571    const childLayout = inheritedValue?.layout;
32572    const setChildLayout = newChildLayout => {
32573      onChange({
32574        ...value,
32575        layout: {
32576          ...newChildLayout
32577        }
32578      });
32579    };
32580    const resetAllFilter = (0,external_wp_element_namespaceObject.useCallback)(previousValue => {
32581      return {
32582        ...previousValue,
32583        layout: utils_cleanEmptyObject({
32584          ...previousValue?.layout,
32585          contentSize: undefined,
32586          wideSize: undefined,
32587          selfStretch: undefined,
32588          flexSize: undefined,
32589          columnStart: undefined,
32590          rowStart: undefined,
32591          columnSpan: undefined,
32592          rowSpan: undefined
32593        }),
32594        spacing: {
32595          ...previousValue?.spacing,
32596          padding: undefined,
32597          margin: undefined,
32598          blockGap: undefined
32599        },
32600        dimensions: {
32601          ...previousValue?.dimensions,
32602          minHeight: undefined,
32603          aspectRatio: undefined
32604        }
32605      };
32606    }, []);
32607    const onMouseLeaveControls = () => onVisualize(false);
32608    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(Wrapper, {
32609      resetAllFilter: resetAllFilter,
32610      value: value,
32611      onChange: onChange,
32612      panelId: panelId,
32613      children: [(showContentSizeControl || showWideSizeControl) && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("span", {
32614        className: "span-columns",
32615        children: (0,external_wp_i18n_namespaceObject.__)('Set the width of the main content area.')
32616      }), showContentSizeControl && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanelItem, {
32617        label: (0,external_wp_i18n_namespaceObject.__)('Content width'),
32618        hasValue: hasUserSetContentSizeValue,
32619        onDeselect: resetContentSizeValue,
32620        isShownByDefault: (_defaultControls$cont = defaultControls.contentSize) !== null && _defaultControls$cont !== void 0 ? _defaultControls$cont : dimensions_panel_DEFAULT_CONTROLS.contentSize,
32621        panelId: panelId,
32622        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalUnitControl, {
32623          __next40pxDefaultSize: true,
32624          label: (0,external_wp_i18n_namespaceObject.__)('Content width'),
32625          labelPosition: "top",
32626          value: contentSizeValue || '',
32627          onChange: nextContentSize => {
32628            setContentSizeValue(nextContentSize);
32629          },
32630          units: units,
32631          prefix: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalInputControlPrefixWrapper, {
32632            variant: "icon",
32633            children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(build_module_icon, {
32634              icon: align_none
32635            })
32636          })
32637        })
32638      }), showWideSizeControl && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanelItem, {
32639        label: (0,external_wp_i18n_namespaceObject.__)('Wide width'),
32640        hasValue: hasUserSetWideSizeValue,
32641        onDeselect: resetWideSizeValue,
32642        isShownByDefault: (_defaultControls$wide = defaultControls.wideSize) !== null && _defaultControls$wide !== void 0 ? _defaultControls$wide : dimensions_panel_DEFAULT_CONTROLS.wideSize,
32643        panelId: panelId,
32644        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalUnitControl, {
32645          __next40pxDefaultSize: true,
32646          label: (0,external_wp_i18n_namespaceObject.__)('Wide width'),
32647          labelPosition: "top",
32648          value: wideSizeValue || '',
32649          onChange: nextWideSize => {
32650            setWideSizeValue(nextWideSize);
32651          },
32652          units: units,
32653          prefix: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalInputControlPrefixWrapper, {
32654            variant: "icon",
32655            children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(build_module_icon, {
32656              icon: stretch_wide
32657            })
32658          })
32659        })
32660      }), showPaddingControl && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalToolsPanelItem, {
32661        hasValue: hasPaddingValue,
32662        label: (0,external_wp_i18n_namespaceObject.__)('Padding'),
32663        onDeselect: resetPaddingValue,
32664        isShownByDefault: (_defaultControls$padd = defaultControls.padding) !== null && _defaultControls$padd !== void 0 ? _defaultControls$padd : dimensions_panel_DEFAULT_CONTROLS.padding,
32665        className: dist_clsx({
32666          'tools-panel-item-spacing': showSpacingPresetsControl
32667        }),
32668        panelId: panelId,
32669        children: [!showSpacingPresetsControl && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.BoxControl, {
32670          __next40pxDefaultSize: true,
32671          values: paddingValues,
32672          onChange: setPaddingValues,
32673          label: (0,external_wp_i18n_namespaceObject.__)('Padding'),
32674          sides: paddingSides,
32675          units: units,
32676          allowReset: false,
32677          splitOnAxis: isAxialPadding,
32678          inputProps: {
32679            onMouseOver: onMouseOverPadding,
32680            onMouseOut: onMouseLeaveControls
32681          }
32682        }), showSpacingPresetsControl && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(SpacingSizesControl, {
32683          values: paddingValues,
32684          onChange: setPaddingValues,
32685          label: (0,external_wp_i18n_namespaceObject.__)('Padding'),
32686          sides: paddingSides,
32687          units: units,
32688          allowReset: false,
32689          onMouseOver: onMouseOverPadding,
32690          onMouseOut: onMouseLeaveControls
32691        })]
32692      }), showMarginControl && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalToolsPanelItem, {
32693        hasValue: hasMarginValue,
32694        label: (0,external_wp_i18n_namespaceObject.__)('Margin'),
32695        onDeselect: resetMarginValue,
32696        isShownByDefault: (_defaultControls$marg = defaultControls.margin) !== null && _defaultControls$marg !== void 0 ? _defaultControls$marg : dimensions_panel_DEFAULT_CONTROLS.margin,
32697        className: dist_clsx({
32698          'tools-panel-item-spacing': showSpacingPresetsControl
32699        }),
32700        panelId: panelId,
32701        children: [!showSpacingPresetsControl && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.BoxControl, {
32702          __next40pxDefaultSize: true,
32703          values: marginValues,
32704          onChange: setMarginValues,
32705          inputProps: {
32706            min: minMarginValue,
32707            onDragStart: () => {
32708              // Reset to 0 in case the value was negative.
32709              setMinMarginValue(0);
32710            },
32711            onDragEnd: () => {
32712              setMinMarginValue(minimumMargin);
32713            },
32714            onMouseOver: onMouseOverMargin,
32715            onMouseOut: onMouseLeaveControls
32716          },
32717          label: (0,external_wp_i18n_namespaceObject.__)('Margin'),
32718          sides: marginSides,
32719          units: units,
32720          allowReset: false,
32721          splitOnAxis: isAxialMargin
32722        }), showSpacingPresetsControl && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(SpacingSizesControl, {
32723          values: marginValues,
32724          onChange: setMarginValues,
32725          minimumCustomValue: -Infinity,
32726          label: (0,external_wp_i18n_namespaceObject.__)('Margin'),
32727          sides: marginSides,
32728          units: units,
32729          allowReset: false,
32730          onMouseOver: onMouseOverMargin,
32731          onMouseOut: onMouseLeaveControls
32732        })]
32733      }), showGapControl && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalToolsPanelItem, {
32734        hasValue: hasGapValue,
32735        label: (0,external_wp_i18n_namespaceObject.__)('Block spacing'),
32736        onDeselect: resetGapValue,
32737        isShownByDefault: (_defaultControls$bloc = defaultControls.blockGap) !== null && _defaultControls$bloc !== void 0 ? _defaultControls$bloc : dimensions_panel_DEFAULT_CONTROLS.blockGap,
32738        className: dist_clsx({
32739          'tools-panel-item-spacing': showSpacingPresetsControl,
32740          'single-column':
32741          // If UnitControl is used, should be single-column.
32742          !showSpacingPresetsControl && !isAxialGap
32743        }),
32744        panelId: panelId,
32745        children: [!showSpacingPresetsControl && (isAxialGap ? /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.BoxControl, {
32746          __next40pxDefaultSize: true,
32747          label: (0,external_wp_i18n_namespaceObject.__)('Block spacing'),
32748          min: 0,
32749          onChange: setGapValues,
32750          units: units,
32751          sides: gapSides,
32752          values: gapValues,
32753          allowReset: false,
32754          splitOnAxis: isAxialGap
32755        }) : /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalUnitControl, {
32756          __next40pxDefaultSize: true,
32757          label: (0,external_wp_i18n_namespaceObject.__)('Block spacing'),
32758          min: 0,
32759          onChange: setGapValue,
32760          units: units,
32761          value: gapValue
32762        })), showSpacingPresetsControl && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(SpacingSizesControl, {
32763          label: (0,external_wp_i18n_namespaceObject.__)('Block spacing'),
32764          min: 0,
32765          onChange: setGapValues,
32766          showSideInLabel: false,
32767          sides: isAxialGap ? gapSides : ['top'] // Use 'top' as the shorthand property in non-axial configurations.
32768          ,
32769          values: gapValues,
32770          allowReset: false
32771        })]
32772      }), showChildLayoutControl && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ChildLayoutControl, {
32773        value: childLayout,
32774        onChange: setChildLayout,
32775        parentLayout: settings?.parentLayout,
32776        panelId: panelId,
32777        isShownByDefault: (_defaultControls$chil = defaultControls.childLayout) !== null && _defaultControls$chil !== void 0 ? _defaultControls$chil : dimensions_panel_DEFAULT_CONTROLS.childLayout
32778      }), showMinHeightControl && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanelItem, {
32779        hasValue: hasMinHeightValue,
32780        label: (0,external_wp_i18n_namespaceObject.__)('Minimum height'),
32781        onDeselect: resetMinHeightValue,
32782        isShownByDefault: (_defaultControls$minH = defaultControls.minHeight) !== null && _defaultControls$minH !== void 0 ? _defaultControls$minH : dimensions_panel_DEFAULT_CONTROLS.minHeight,
32783        panelId: panelId,
32784        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(HeightControl, {
32785          label: (0,external_wp_i18n_namespaceObject.__)('Minimum height'),
32786          value: minHeightValue,
32787          onChange: setMinHeightValue
32788        })
32789      }), showAspectRatioControl && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(AspectRatioTool, {
32790        hasValue: hasAspectRatioValue,
32791        value: aspectRatioValue,
32792        onChange: setAspectRatioValue,
32793        panelId: panelId,
32794        isShownByDefault: (_defaultControls$aspe = defaultControls.aspectRatio) !== null && _defaultControls$aspe !== void 0 ? _defaultControls$aspe : dimensions_panel_DEFAULT_CONTROLS.aspectRatio
32795      })]
32796    });
32797  }
32798  
32799  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-popover/use-popover-scroll.js
32800  /**
32801   * WordPress dependencies
32802   */
32803  
32804  
32805  const scrollContainerCache = new WeakMap();
32806  
32807  /**
32808   * Allow scrolling "through" popovers over the canvas. This is only called for
32809   * as long as the pointer is over a popover. Do not use React events because it
32810   * will bubble through portals.
32811   *
32812   * @param {Object} contentRef
32813   */
32814  function usePopoverScroll(contentRef) {
32815    const effect = (0,external_wp_compose_namespaceObject.useRefEffect)(node => {
32816      function onWheel(event) {
32817        const {
32818          deltaX,
32819          deltaY
32820        } = event;
32821        const contentEl = contentRef.current;
32822        let scrollContainer = scrollContainerCache.get(contentEl);
32823        if (!scrollContainer) {
32824          scrollContainer = (0,external_wp_dom_namespaceObject.getScrollContainer)(contentEl);
32825          scrollContainerCache.set(contentEl, scrollContainer);
32826        }
32827        scrollContainer.scrollBy(deltaX, deltaY);
32828      }
32829      // Tell the browser that we do not call event.preventDefault
32830      // See https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener#improving_scrolling_performance_with_passive_listeners
32831      const options = {
32832        passive: true
32833      };
32834      node.addEventListener('wheel', onWheel, options);
32835      return () => {
32836        node.removeEventListener('wheel', onWheel, options);
32837      };
32838    }, [contentRef]);
32839    return contentRef ? effect : null;
32840  }
32841  /* harmony default export */ const use_popover_scroll = (usePopoverScroll);
32842  
32843  ;// ./node_modules/@wordpress/block-editor/build-module/utils/dom.js
32844  const BLOCK_SELECTOR = '.block-editor-block-list__block';
32845  const APPENDER_SELECTOR = '.block-list-appender';
32846  const BLOCK_APPENDER_CLASS = '.block-editor-button-block-appender';
32847  
32848  /**
32849   * Returns true if two elements are contained within the same block.
32850   *
32851   * @param {Element} a First element.
32852   * @param {Element} b Second element.
32853   *
32854   * @return {boolean} Whether elements are in the same block.
32855   */
32856  function isInSameBlock(a, b) {
32857    return a.closest(BLOCK_SELECTOR) === b.closest(BLOCK_SELECTOR);
32858  }
32859  
32860  /**
32861   * Returns true if an element is considered part of the block and not its inner
32862   * blocks or appender.
32863   *
32864   * @param {Element} blockElement Block container element.
32865   * @param {Element} element      Element.
32866   *
32867   * @return {boolean} Whether an element is considered part of the block and not
32868   *                   its inner blocks or appender.
32869   */
32870  function isInsideRootBlock(blockElement, element) {
32871    const parentBlock = element.closest([BLOCK_SELECTOR, APPENDER_SELECTOR, BLOCK_APPENDER_CLASS].join(','));
32872    return parentBlock === blockElement;
32873  }
32874  
32875  /**
32876   * Finds the block client ID given any DOM node inside the block.
32877   *
32878   * @param {Node?} node DOM node.
32879   *
32880   * @return {string|undefined} Client ID or undefined if the node is not part of
32881   *                            a block.
32882   */
32883  function getBlockClientId(node) {
32884    while (node && node.nodeType !== node.ELEMENT_NODE) {
32885      node = node.parentNode;
32886    }
32887    if (!node) {
32888      return;
32889    }
32890    const elementNode = /** @type {Element} */node;
32891    const blockNode = elementNode.closest(BLOCK_SELECTOR);
32892    if (!blockNode) {
32893      return;
32894    }
32895    return blockNode.id.slice('block-'.length);
32896  }
32897  
32898  /**
32899   * Calculates the union of two rectangles.
32900   *
32901   * @param {DOMRect} rect1 First rectangle.
32902   * @param {DOMRect} rect2 Second rectangle.
32903   * @return {DOMRect} Union of the two rectangles.
32904   */
32905  function rectUnion(rect1, rect2) {
32906    const left = Math.min(rect1.left, rect2.left);
32907    const right = Math.max(rect1.right, rect2.right);
32908    const bottom = Math.max(rect1.bottom, rect2.bottom);
32909    const top = Math.min(rect1.top, rect2.top);
32910    return new window.DOMRectReadOnly(left, top, right - left, bottom - top);
32911  }
32912  
32913  /**
32914   * Returns whether an element is visible.
32915   *
32916   * @param {Element} element Element.
32917   * @return {boolean} Whether the element is visible.
32918   */
32919  function isElementVisible(element) {
32920    const viewport = element.ownerDocument.defaultView;
32921    if (!viewport) {
32922      return false;
32923    }
32924  
32925    // Check for <VisuallyHidden> component.
32926    if (element.classList.contains('components-visually-hidden')) {
32927      return false;
32928    }
32929    const bounds = element.getBoundingClientRect();
32930    if (bounds.width === 0 || bounds.height === 0) {
32931      return false;
32932    }
32933  
32934    // Older browsers, e.g. Safari < 17.4 may not support the `checkVisibility` method.
32935    if (element.checkVisibility) {
32936      return element.checkVisibility?.({
32937        opacityProperty: true,
32938        contentVisibilityAuto: true,
32939        visibilityProperty: true
32940      });
32941    }
32942    const style = viewport.getComputedStyle(element);
32943    if (style.display === 'none' || style.visibility === 'hidden' || style.opacity === '0') {
32944      return false;
32945    }
32946    return true;
32947  }
32948  
32949  /**
32950   * Checks if the element is scrollable.
32951   *
32952   * @param {Element} element Element.
32953   * @return {boolean} True if the element is scrollable.
32954   */
32955  function isScrollable(element) {
32956    const style = window.getComputedStyle(element);
32957    return style.overflowX === 'auto' || style.overflowX === 'scroll' || style.overflowY === 'auto' || style.overflowY === 'scroll';
32958  }
32959  const WITH_OVERFLOW_ELEMENT_BLOCKS = ['core/navigation'];
32960  /**
32961   * Returns the bounding rectangle of an element, with special handling for blocks
32962   * that have visible overflowing children (defined in WITH_OVERFLOW_ELEMENT_BLOCKS).
32963   *
32964   * For blocks like Navigation that can have overflowing elements (e.g. submenus),
32965   * this function calculates the combined bounds of both the parent and its visible
32966   * children. The returned rect may extend beyond the viewport.
32967   * The returned rect represents the full extent of the element and its visible
32968   * children, which may extend beyond the viewport.
32969   *
32970   * @param {Element} element Element.
32971   * @return {DOMRect} Bounding client rect of the element and its visible children.
32972   */
32973  function getElementBounds(element) {
32974    const viewport = element.ownerDocument.defaultView;
32975    if (!viewport) {
32976      return new window.DOMRectReadOnly();
32977    }
32978    let bounds = element.getBoundingClientRect();
32979    const dataType = element.getAttribute('data-type');
32980  
32981    /*
32982     * For blocks with overflowing elements (like Navigation), include the bounds
32983     * of visible children that extend beyond the parent container.
32984     */
32985    if (dataType && WITH_OVERFLOW_ELEMENT_BLOCKS.includes(dataType)) {
32986      const stack = [element];
32987      let currentElement;
32988      while (currentElement = stack.pop()) {
32989        // Children won’t affect bounds unless the element is not scrollable.
32990        if (!isScrollable(currentElement)) {
32991          for (const child of currentElement.children) {
32992            if (isElementVisible(child)) {
32993              const childBounds = child.getBoundingClientRect();
32994              bounds = rectUnion(bounds, childBounds);
32995              stack.push(child);
32996            }
32997          }
32998        }
32999      }
33000    }
33001  
33002    /*
33003     * Take into account the outer horizontal limits of the container in which
33004     * an element is supposed to be "visible". For example, if an element is
33005     * positioned -10px to the left of the window x value (0), this function
33006     * discounts the negative overhang because it's not visible and therefore
33007     * not to be counted in the visibility calculations. Top and bottom values
33008     * are not accounted for to accommodate vertical scroll.
33009     */
33010    const left = Math.max(bounds.left, 0);
33011    const right = Math.min(bounds.right, viewport.innerWidth);
33012    bounds = new window.DOMRectReadOnly(left, bounds.top, right - left, bounds.height);
33013    return bounds;
33014  }
33015  
33016  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-popover/index.js
33017  /**
33018   * External dependencies
33019   */
33020  
33021  
33022  /**
33023   * WordPress dependencies
33024   */
33025  
33026  
33027  
33028  
33029  /**
33030   * Internal dependencies
33031   */
33032  
33033  
33034  
33035  
33036  const MAX_POPOVER_RECOMPUTE_COUNTER = Number.MAX_SAFE_INTEGER;
33037  function BlockPopover({
33038    clientId,
33039    bottomClientId,
33040    children,
33041    __unstablePopoverSlot,
33042    __unstableContentRef,
33043    shift = true,
33044    ...props
33045  }, ref) {
33046    const selectedElement = useBlockElement(clientId);
33047    const lastSelectedElement = useBlockElement(bottomClientId !== null && bottomClientId !== void 0 ? bottomClientId : clientId);
33048    const mergedRefs = (0,external_wp_compose_namespaceObject.useMergeRefs)([ref, use_popover_scroll(__unstableContentRef)]);
33049    const [popoverDimensionsRecomputeCounter, forceRecomputePopoverDimensions] = (0,external_wp_element_namespaceObject.useReducer)(
33050    // Module is there to make sure that the counter doesn't overflow.
33051    s => (s + 1) % MAX_POPOVER_RECOMPUTE_COUNTER, 0);
33052  
33053    // When blocks are moved up/down, they are animated to their new position by
33054    // updating the `transform` property manually (i.e. without using CSS
33055    // transitions or animations). The animation, which can also scroll the block
33056    // editor, can sometimes cause the position of the Popover to get out of sync.
33057    // A MutationObserver is therefore used to make sure that changes to the
33058    // selectedElement's attribute (i.e. `transform`) can be tracked and used to
33059    // trigger the Popover to rerender.
33060    (0,external_wp_element_namespaceObject.useLayoutEffect)(() => {
33061      if (!selectedElement) {
33062        return;
33063      }
33064      const observer = new window.MutationObserver(forceRecomputePopoverDimensions);
33065      observer.observe(selectedElement, {
33066        attributes: true
33067      });
33068      return () => {
33069        observer.disconnect();
33070      };
33071    }, [selectedElement]);
33072    const popoverAnchor = (0,external_wp_element_namespaceObject.useMemo)(() => {
33073      if (
33074      // popoverDimensionsRecomputeCounter is by definition always equal or greater
33075      // than 0. This check is only there to satisfy the correctness of the
33076      // exhaustive-deps rule for the `useMemo` hook.
33077      popoverDimensionsRecomputeCounter < 0 || !selectedElement || bottomClientId && !lastSelectedElement) {
33078        return undefined;
33079      }
33080      return {
33081        getBoundingClientRect() {
33082          return lastSelectedElement ? rectUnion(getElementBounds(selectedElement), getElementBounds(lastSelectedElement)) : getElementBounds(selectedElement);
33083        },
33084        contextElement: selectedElement
33085      };
33086    }, [popoverDimensionsRecomputeCounter, selectedElement, bottomClientId, lastSelectedElement]);
33087    if (!selectedElement || bottomClientId && !lastSelectedElement) {
33088      return null;
33089    }
33090    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Popover, {
33091      ref: mergedRefs,
33092      animate: false,
33093      focusOnMount: false,
33094      anchor: popoverAnchor
33095      // Render in the old slot if needed for backward compatibility,
33096      // otherwise render in place (not in the default popover slot).
33097      ,
33098      __unstableSlotName: __unstablePopoverSlot,
33099      inline: !__unstablePopoverSlot,
33100      placement: "top-start",
33101      resize: false,
33102      flip: false,
33103      shift: shift,
33104      ...props,
33105      className: dist_clsx('block-editor-block-popover', props.className),
33106      variant: "unstyled",
33107      children: children
33108    });
33109  }
33110  const PrivateBlockPopover = (0,external_wp_element_namespaceObject.forwardRef)(BlockPopover);
33111  const PublicBlockPopover = ({
33112    clientId,
33113    bottomClientId,
33114    children,
33115    ...props
33116  }, ref) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PrivateBlockPopover, {
33117    ...props,
33118    bottomClientId: bottomClientId,
33119    clientId: clientId,
33120    __unstableContentRef: undefined,
33121    __unstablePopoverSlot: undefined,
33122    ref: ref,
33123    children: children
33124  });
33125  
33126  /**
33127   * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/block-popover/README.md
33128   */
33129  /* harmony default export */ const block_popover = ((0,external_wp_element_namespaceObject.forwardRef)(PublicBlockPopover));
33130  
33131  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-popover/cover.js
33132  /**
33133   * WordPress dependencies
33134   */
33135  
33136  
33137  /**
33138   * Internal dependencies
33139   */
33140  
33141  
33142  
33143  function BlockPopoverCover({
33144    clientId,
33145    bottomClientId,
33146    children,
33147    shift = false,
33148    additionalStyles,
33149    ...props
33150  }, ref) {
33151    var _bottomClientId;
33152    (_bottomClientId = bottomClientId) !== null && _bottomClientId !== void 0 ? _bottomClientId : bottomClientId = clientId;
33153    const selectedElement = useBlockElement(clientId);
33154    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PrivateBlockPopover, {
33155      ref: ref,
33156      clientId: clientId,
33157      bottomClientId: bottomClientId,
33158      shift: shift,
33159      ...props,
33160      children: selectedElement && clientId === bottomClientId ? /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(CoverContainer, {
33161        selectedElement: selectedElement,
33162        additionalStyles: additionalStyles,
33163        children: children
33164      }) : children
33165    });
33166  }
33167  function CoverContainer({
33168    selectedElement,
33169    additionalStyles = {},
33170    children
33171  }) {
33172    const [width, setWidth] = (0,external_wp_element_namespaceObject.useState)(selectedElement.offsetWidth);
33173    const [height, setHeight] = (0,external_wp_element_namespaceObject.useState)(selectedElement.offsetHeight);
33174    (0,external_wp_element_namespaceObject.useEffect)(() => {
33175      const observer = new window.ResizeObserver(() => {
33176        setWidth(selectedElement.offsetWidth);
33177        setHeight(selectedElement.offsetHeight);
33178      });
33179      observer.observe(selectedElement, {
33180        box: 'border-box'
33181      });
33182      return () => observer.disconnect();
33183    }, [selectedElement]);
33184    const style = (0,external_wp_element_namespaceObject.useMemo)(() => {
33185      return {
33186        position: 'absolute',
33187        width,
33188        height,
33189        ...additionalStyles
33190      };
33191    }, [width, height, additionalStyles]);
33192    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
33193      style: style,
33194      children: children
33195    });
33196  }
33197  /* harmony default export */ const cover = ((0,external_wp_element_namespaceObject.forwardRef)(BlockPopoverCover));
33198  
33199  ;// ./node_modules/@wordpress/block-editor/build-module/hooks/spacing-visualizer.js
33200  /**
33201   * WordPress dependencies
33202   */
33203  
33204  
33205  
33206  /**
33207   * Internal dependencies
33208   */
33209  
33210  
33211  
33212  function SpacingVisualizer({
33213    clientId,
33214    value,
33215    computeStyle,
33216    forceShow
33217  }) {
33218    const blockElement = useBlockElement(clientId);
33219    const [style, updateStyle] = (0,external_wp_element_namespaceObject.useReducer)(() => computeStyle(blockElement));
33220    (0,external_wp_element_namespaceObject.useLayoutEffect)(() => {
33221      if (!blockElement) {
33222        return;
33223      }
33224      // It's not sufficient to read the computed spacing value when value.spacing changes as
33225      // useEffect may run before the browser recomputes CSS. We therefore combine
33226      // useLayoutEffect and two rAF calls to ensure that we read the spacing after the current
33227      // paint but before the next paint.
33228      // See https://github.com/WordPress/gutenberg/pull/59227.
33229      window.requestAnimationFrame(() => window.requestAnimationFrame(updateStyle));
33230    }, [blockElement, value]);
33231    const previousValueRef = (0,external_wp_element_namespaceObject.useRef)(value);
33232    const [isActive, setIsActive] = (0,external_wp_element_namespaceObject.useState)(false);
33233    (0,external_wp_element_namespaceObject.useEffect)(() => {
33234      if (external_wp_isShallowEqual_default()(value, previousValueRef.current) || forceShow) {
33235        return;
33236      }
33237      setIsActive(true);
33238      previousValueRef.current = value;
33239      const timeout = setTimeout(() => {
33240        setIsActive(false);
33241      }, 400);
33242      return () => {
33243        setIsActive(false);
33244        clearTimeout(timeout);
33245      };
33246    }, [value, forceShow]);
33247    if (!isActive && !forceShow) {
33248      return null;
33249    }
33250    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(cover, {
33251      clientId: clientId,
33252      __unstablePopoverSlot: "block-toolbar",
33253      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
33254        className: "block-editor__spacing-visualizer",
33255        style: style
33256      })
33257    });
33258  }
33259  function getComputedCSS(element, property) {
33260    return element.ownerDocument.defaultView.getComputedStyle(element).getPropertyValue(property);
33261  }
33262  function MarginVisualizer({
33263    clientId,
33264    value,
33265    forceShow
33266  }) {
33267    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(SpacingVisualizer, {
33268      clientId: clientId,
33269      value: value?.spacing?.margin,
33270      computeStyle: blockElement => {
33271        const top = getComputedCSS(blockElement, 'margin-top');
33272        const right = getComputedCSS(blockElement, 'margin-right');
33273        const bottom = getComputedCSS(blockElement, 'margin-bottom');
33274        const left = getComputedCSS(blockElement, 'margin-left');
33275        return {
33276          borderTopWidth: top,
33277          borderRightWidth: right,
33278          borderBottomWidth: bottom,
33279          borderLeftWidth: left,
33280          top: top ? `-$top}` : 0,
33281          right: right ? `-$right}` : 0,
33282          bottom: bottom ? `-$bottom}` : 0,
33283          left: left ? `-$left}` : 0
33284        };
33285      },
33286      forceShow: forceShow
33287    });
33288  }
33289  function PaddingVisualizer({
33290    clientId,
33291    value,
33292    forceShow
33293  }) {
33294    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(SpacingVisualizer, {
33295      clientId: clientId,
33296      value: value?.spacing?.padding,
33297      computeStyle: blockElement => ({
33298        borderTopWidth: getComputedCSS(blockElement, 'padding-top'),
33299        borderRightWidth: getComputedCSS(blockElement, 'padding-right'),
33300        borderBottomWidth: getComputedCSS(blockElement, 'padding-bottom'),
33301        borderLeftWidth: getComputedCSS(blockElement, 'padding-left')
33302      }),
33303      forceShow: forceShow
33304    });
33305  }
33306  
33307  ;// ./node_modules/@wordpress/block-editor/build-module/hooks/dimensions.js
33308  /**
33309   * External dependencies
33310   */
33311  
33312  
33313  /**
33314   * WordPress dependencies
33315   */
33316  
33317  
33318  
33319  
33320  
33321  /**
33322   * Internal dependencies
33323   */
33324  
33325  
33326  
33327  
33328  
33329  
33330  
33331  const DIMENSIONS_SUPPORT_KEY = 'dimensions';
33332  const SPACING_SUPPORT_KEY = 'spacing';
33333  const dimensions_ALL_SIDES = (/* unused pure expression or super */ null && (['top', 'right', 'bottom', 'left']));
33334  const dimensions_AXIAL_SIDES = (/* unused pure expression or super */ null && (['vertical', 'horizontal']));
33335  function useVisualizer() {
33336    const [property, setProperty] = (0,external_wp_element_namespaceObject.useState)(false);
33337    const {
33338      hideBlockInterface,
33339      showBlockInterface
33340    } = unlock((0,external_wp_data_namespaceObject.useDispatch)(store));
33341    (0,external_wp_element_namespaceObject.useEffect)(() => {
33342      if (!property) {
33343        showBlockInterface();
33344      } else {
33345        hideBlockInterface();
33346      }
33347    }, [property, showBlockInterface, hideBlockInterface]);
33348    return [property, setProperty];
33349  }
33350  function DimensionsInspectorControl({
33351    children,
33352    resetAllFilter
33353  }) {
33354    const attributesResetAllFilter = (0,external_wp_element_namespaceObject.useCallback)(attributes => {
33355      const existingStyle = attributes.style;
33356      const updatedStyle = resetAllFilter(existingStyle);
33357      return {
33358        ...attributes,
33359        style: updatedStyle
33360      };
33361    }, [resetAllFilter]);
33362    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls, {
33363      group: "dimensions",
33364      resetAllFilter: attributesResetAllFilter,
33365      children: children
33366    });
33367  }
33368  function dimensions_DimensionsPanel({
33369    clientId,
33370    name,
33371    setAttributes,
33372    settings
33373  }) {
33374    const isEnabled = useHasDimensionsPanel(settings);
33375    const value = (0,external_wp_data_namespaceObject.useSelect)(select => select(store).getBlockAttributes(clientId)?.style, [clientId]);
33376    const [visualizedProperty, setVisualizedProperty] = useVisualizer();
33377    const onChange = newStyle => {
33378      setAttributes({
33379        style: utils_cleanEmptyObject(newStyle)
33380      });
33381    };
33382    if (!isEnabled) {
33383      return null;
33384    }
33385    const defaultDimensionsControls = (0,external_wp_blocks_namespaceObject.getBlockSupport)(name, [DIMENSIONS_SUPPORT_KEY, '__experimentalDefaultControls']);
33386    const defaultSpacingControls = (0,external_wp_blocks_namespaceObject.getBlockSupport)(name, [SPACING_SUPPORT_KEY, '__experimentalDefaultControls']);
33387    const defaultControls = {
33388      ...defaultDimensionsControls,
33389      ...defaultSpacingControls
33390    };
33391    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
33392      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(DimensionsPanel, {
33393        as: DimensionsInspectorControl,
33394        panelId: clientId,
33395        settings: settings,
33396        value: value,
33397        onChange: onChange,
33398        defaultControls: defaultControls,
33399        onVisualize: setVisualizedProperty
33400      }), !!settings?.spacing?.padding && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PaddingVisualizer, {
33401        forceShow: visualizedProperty === 'padding',
33402        clientId: clientId,
33403        value: value
33404      }), !!settings?.spacing?.margin && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(MarginVisualizer, {
33405        forceShow: visualizedProperty === 'margin',
33406        clientId: clientId,
33407        value: value
33408      })]
33409    });
33410  }
33411  
33412  /**
33413   * Determine whether there is block support for dimensions.
33414   *
33415   * @param {string} blockName Block name.
33416   * @param {string} feature   Background image feature to check for.
33417   *
33418   * @return {boolean} Whether there is support.
33419   */
33420  function hasDimensionsSupport(blockName, feature = 'any') {
33421    if (external_wp_element_namespaceObject.Platform.OS !== 'web') {
33422      return false;
33423    }
33424    const support = (0,external_wp_blocks_namespaceObject.getBlockSupport)(blockName, DIMENSIONS_SUPPORT_KEY);
33425    if (support === true) {
33426      return true;
33427    }
33428    if (feature === 'any') {
33429      return !!(support?.aspectRatio || !!support?.minHeight);
33430    }
33431    return !!support?.[feature];
33432  }
33433  /* harmony default export */ const dimensions = ({
33434    useBlockProps: dimensions_useBlockProps,
33435    attributeKeys: ['minHeight', 'style'],
33436    hasSupport(name) {
33437      return hasDimensionsSupport(name, 'aspectRatio');
33438    }
33439  });
33440  function dimensions_useBlockProps({
33441    name,
33442    minHeight,
33443    style
33444  }) {
33445    if (!hasDimensionsSupport(name, 'aspectRatio') || shouldSkipSerialization(name, DIMENSIONS_SUPPORT_KEY, 'aspectRatio')) {
33446      return {};
33447    }
33448    const className = dist_clsx({
33449      'has-aspect-ratio': !!style?.dimensions?.aspectRatio
33450    });
33451  
33452    // Allow dimensions-based inline style overrides to override any global styles rules that
33453    // might be set for the block, and therefore affect the display of the aspect ratio.
33454    const inlineStyleOverrides = {};
33455  
33456    // Apply rules to unset incompatible styles.
33457    // Note that a set `aspectRatio` will win out if both an aspect ratio and a minHeight are set.
33458    // This is because the aspect ratio is a newer block support, so (in theory) any aspect ratio
33459    // that is set should be intentional and should override any existing minHeight. The Cover block
33460    // and dimensions controls have logic that will manually clear the aspect ratio if a minHeight
33461    // is set.
33462    if (style?.dimensions?.aspectRatio) {
33463      // To ensure the aspect ratio does not get overridden by `minHeight` unset any existing rule.
33464      inlineStyleOverrides.minHeight = 'unset';
33465    } else if (minHeight || style?.dimensions?.minHeight) {
33466      // To ensure the minHeight does not get overridden by `aspectRatio` unset any existing rule.
33467      inlineStyleOverrides.aspectRatio = 'unset';
33468    }
33469    return {
33470      className,
33471      style: inlineStyleOverrides
33472    };
33473  }
33474  
33475  /**
33476   * @deprecated
33477   */
33478  function useCustomSides() {
33479    external_wp_deprecated_default()('wp.blockEditor.__experimentalUseCustomSides', {
33480      since: '6.3',
33481      version: '6.4'
33482    });
33483  }
33484  
33485  ;// ./node_modules/@wordpress/block-editor/build-module/hooks/style.js
33486  /**
33487   * WordPress dependencies
33488   */
33489  
33490  
33491  
33492  
33493  
33494  
33495  /**
33496   * Internal dependencies
33497   */
33498  
33499  
33500  
33501  
33502  
33503  
33504  
33505  
33506  
33507  const styleSupportKeys = [...TYPOGRAPHY_SUPPORT_KEYS, BORDER_SUPPORT_KEY, COLOR_SUPPORT_KEY, DIMENSIONS_SUPPORT_KEY, BACKGROUND_SUPPORT_KEY, SPACING_SUPPORT_KEY, SHADOW_SUPPORT_KEY];
33508  const hasStyleSupport = nameOrType => styleSupportKeys.some(key => (0,external_wp_blocks_namespaceObject.hasBlockSupport)(nameOrType, key));
33509  
33510  /**
33511   * Returns the inline styles to add depending on the style object
33512   *
33513   * @param {Object} styles Styles configuration.
33514   *
33515   * @return {Object} Flattened CSS variables declaration.
33516   */
33517  function getInlineStyles(styles = {}) {
33518    const output = {};
33519    // The goal is to move everything to server side generated engine styles
33520    // This is temporary as we absorb more and more styles into the engine.
33521    (0,external_wp_styleEngine_namespaceObject.getCSSRules)(styles).forEach(rule => {
33522      output[rule.key] = rule.value;
33523    });
33524    return output;
33525  }
33526  
33527  /**
33528   * Filters registered block settings, extending attributes to include `style` attribute.
33529   *
33530   * @param {Object} settings Original block settings.
33531   *
33532   * @return {Object} Filtered block settings.
33533   */
33534  function style_addAttribute(settings) {
33535    if (!hasStyleSupport(settings)) {
33536      return settings;
33537    }
33538  
33539    // Allow blocks to specify their own attribute definition with default values if needed.
33540    if (!settings.attributes.style) {
33541      Object.assign(settings.attributes, {
33542        style: {
33543          type: 'object'
33544        }
33545      });
33546    }
33547    return settings;
33548  }
33549  
33550  /**
33551   * A dictionary of paths to flag skipping block support serialization as the key,
33552   * with values providing the style paths to be omitted from serialization.
33553   *
33554   * @constant
33555   * @type {Record<string, string[]>}
33556   */
33557  const skipSerializationPathsEdit = {
33558    [`$BORDER_SUPPORT_KEY}.__experimentalSkipSerialization`]: ['border'],
33559    [`$COLOR_SUPPORT_KEY}.__experimentalSkipSerialization`]: [COLOR_SUPPORT_KEY],
33560    [`$TYPOGRAPHY_SUPPORT_KEY}.__experimentalSkipSerialization`]: [TYPOGRAPHY_SUPPORT_KEY],
33561    [`$DIMENSIONS_SUPPORT_KEY}.__experimentalSkipSerialization`]: [DIMENSIONS_SUPPORT_KEY],
33562    [`$SPACING_SUPPORT_KEY}.__experimentalSkipSerialization`]: [SPACING_SUPPORT_KEY],
33563    [`$SHADOW_SUPPORT_KEY}.__experimentalSkipSerialization`]: [SHADOW_SUPPORT_KEY]
33564  };
33565  
33566  /**
33567   * A dictionary of paths to flag skipping block support serialization as the key,
33568   * with values providing the style paths to be omitted from serialization.
33569   *
33570   * Extends the Edit skip paths to enable skipping additional paths in just
33571   * the Save component. This allows a block support to be serialized within the
33572   * editor, while using an alternate approach, such as server-side rendering, when
33573   * the support is saved.
33574   *
33575   * @constant
33576   * @type {Record<string, string[]>}
33577   */
33578  const skipSerializationPathsSave = {
33579    ...skipSerializationPathsEdit,
33580    [`$DIMENSIONS_SUPPORT_KEY}.aspectRatio`]: [`$DIMENSIONS_SUPPORT_KEY}.aspectRatio`],
33581    // Skip serialization of aspect ratio in save mode.
33582    [`$BACKGROUND_SUPPORT_KEY}`]: [BACKGROUND_SUPPORT_KEY] // Skip serialization of background support in save mode.
33583  };
33584  const skipSerializationPathsSaveChecks = {
33585    [`$DIMENSIONS_SUPPORT_KEY}.aspectRatio`]: true,
33586    [`$BACKGROUND_SUPPORT_KEY}`]: true
33587  };
33588  
33589  /**
33590   * A dictionary used to normalize feature names between support flags, style
33591   * object properties and __experimentSkipSerialization configuration arrays.
33592   *
33593   * This allows not having to provide a migration for a support flag and possible
33594   * backwards compatibility bridges, while still achieving consistency between
33595   * the support flag and the skip serialization array.
33596   *
33597   * @constant
33598   * @type {Record<string, string>}
33599   */
33600  const renamedFeatures = {
33601    gradients: 'gradient'
33602  };
33603  
33604  /**
33605   * A utility function used to remove one or more paths from a style object.
33606   * Works in a way similar to Lodash's `omit()`. See unit tests and examples below.
33607   *
33608   * It supports a single string path:
33609   *
33610   * ```
33611   * omitStyle( { color: 'red' }, 'color' ); // {}
33612   * ```
33613   *
33614   * or an array of paths:
33615   *
33616   * ```
33617   * omitStyle( { color: 'red', background: '#fff' }, [ 'color', 'background' ] ); // {}
33618   * ```
33619   *
33620   * It also allows you to specify paths at multiple levels in a string.
33621   *
33622   * ```
33623   * omitStyle( { typography: { textDecoration: 'underline' } }, 'typography.textDecoration' ); // {}
33624   * ```
33625   *
33626   * You can remove multiple paths at the same time:
33627   *
33628   * ```
33629   * omitStyle(
33630   *         {
33631   *             typography: {
33632   *                 textDecoration: 'underline',
33633   *                 textTransform: 'uppercase',
33634   *             }
33635   *        },
33636   *        [
33637   *             'typography.textDecoration',
33638   *             'typography.textTransform',
33639   *        ]
33640   * );
33641   * // {}
33642   * ```
33643   *
33644   * You can also specify nested paths as arrays:
33645   *
33646   * ```
33647   * omitStyle(
33648   *         {
33649   *             typography: {
33650   *                 textDecoration: 'underline',
33651   *                 textTransform: 'uppercase',
33652   *             }
33653   *        },
33654   *        [
33655   *             [ 'typography', 'textDecoration' ],
33656   *             [ 'typography', 'textTransform' ],
33657   *        ]
33658   * );
33659   * // {}
33660   * ```
33661   *
33662   * With regards to nesting of styles, infinite depth is supported:
33663   *
33664   * ```
33665   * omitStyle(
33666   *         {
33667   *             border: {
33668   *                 radius: {
33669   *                     topLeft: '10px',
33670   *                     topRight: '0.5rem',
33671   *                 }
33672   *             }
33673   *        },
33674   *        [
33675   *             [ 'border', 'radius', 'topRight' ],
33676   *        ]
33677   * );
33678   * // { border: { radius: { topLeft: '10px' } } }
33679   * ```
33680   *
33681   * The third argument, `preserveReference`, defines how to treat the input style object.
33682   * It is mostly necessary to properly handle mutation when recursively handling the style object.
33683   * Defaulting to `false`, this will always create a new object, avoiding to mutate `style`.
33684   * However, when recursing, we change that value to `true` in order to work with a single copy
33685   * of the original style object.
33686   *
33687   * @see https://lodash.com/docs/4.17.15#omit
33688   *
33689   * @param {Object}       style             Styles object.
33690   * @param {Array|string} paths             Paths to remove.
33691   * @param {boolean}      preserveReference True to mutate the `style` object, false otherwise.
33692   * @return {Object}      Styles object with the specified paths removed.
33693   */
33694  function omitStyle(style, paths, preserveReference = false) {
33695    if (!style) {
33696      return style;
33697    }
33698    let newStyle = style;
33699    if (!preserveReference) {
33700      newStyle = JSON.parse(JSON.stringify(style));
33701    }
33702    if (!Array.isArray(paths)) {
33703      paths = [paths];
33704    }
33705    paths.forEach(path => {
33706      if (!Array.isArray(path)) {
33707        path = path.split('.');
33708      }
33709      if (path.length > 1) {
33710        const [firstSubpath, ...restPath] = path;
33711        omitStyle(newStyle[firstSubpath], [restPath], true);
33712      } else if (path.length === 1) {
33713        delete newStyle[path[0]];
33714      }
33715    });
33716    return newStyle;
33717  }
33718  
33719  /**
33720   * Override props assigned to save component to inject the CSS variables definition.
33721   *
33722   * @param {Object}                    props           Additional props applied to save element.
33723   * @param {Object|string}             blockNameOrType Block type.
33724   * @param {Object}                    attributes      Block attributes.
33725   * @param {?Record<string, string[]>} skipPaths       An object of keys and paths to skip serialization.
33726   *
33727   * @return {Object} Filtered props applied to save element.
33728   */
33729  function style_addSaveProps(props, blockNameOrType, attributes, skipPaths = skipSerializationPathsSave) {
33730    if (!hasStyleSupport(blockNameOrType)) {
33731      return props;
33732    }
33733    let {
33734      style
33735    } = attributes;
33736    Object.entries(skipPaths).forEach(([indicator, path]) => {
33737      const skipSerialization = skipSerializationPathsSaveChecks[indicator] || (0,external_wp_blocks_namespaceObject.getBlockSupport)(blockNameOrType, indicator);
33738      if (skipSerialization === true) {
33739        style = omitStyle(style, path);
33740      }
33741      if (Array.isArray(skipSerialization)) {
33742        skipSerialization.forEach(featureName => {
33743          const feature = renamedFeatures[featureName] || featureName;
33744          style = omitStyle(style, [[...path, feature]]);
33745        });
33746      }
33747    });
33748    props.style = {
33749      ...getInlineStyles(style),
33750      ...props.style
33751    };
33752    return props;
33753  }
33754  function BlockStyleControls({
33755    clientId,
33756    name,
33757    setAttributes,
33758    __unstableParentLayout
33759  }) {
33760    const settings = useBlockSettings(name, __unstableParentLayout);
33761    const blockEditingMode = useBlockEditingMode();
33762    const passedProps = {
33763      clientId,
33764      name,
33765      setAttributes,
33766      settings: {
33767        ...settings,
33768        typography: {
33769          ...settings.typography,
33770          // The text alignment UI for individual blocks is rendered in
33771          // the block toolbar, so disable it here.
33772          textAlign: false
33773        }
33774      }
33775    };
33776    if (blockEditingMode !== 'default') {
33777      return null;
33778    }
33779    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
33780      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ColorEdit, {
33781        ...passedProps
33782      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(background_BackgroundImagePanel, {
33783        ...passedProps
33784      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(typography_TypographyPanel, {
33785        ...passedProps
33786      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(border_BorderPanel, {
33787        ...passedProps
33788      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(dimensions_DimensionsPanel, {
33789        ...passedProps
33790      })]
33791    });
33792  }
33793  /* harmony default export */ const style = ({
33794    edit: BlockStyleControls,
33795    hasSupport: hasStyleSupport,
33796    addSaveProps: style_addSaveProps,
33797    attributeKeys: ['style'],
33798    useBlockProps: style_useBlockProps
33799  });
33800  
33801  // Defines which element types are supported, including their hover styles or
33802  // any other elements that have been included under a single element type
33803  // e.g. heading and h1-h6.
33804  const elementTypes = [{
33805    elementType: 'button'
33806  }, {
33807    elementType: 'link',
33808    pseudo: [':hover']
33809  }, {
33810    elementType: 'heading',
33811    elements: ['h1', 'h2', 'h3', 'h4', 'h5', 'h6']
33812  }];
33813  
33814  // Used for generating the instance ID
33815  const STYLE_BLOCK_PROPS_REFERENCE = {};
33816  function style_useBlockProps({
33817    name,
33818    style
33819  }) {
33820    const blockElementsContainerIdentifier = (0,external_wp_compose_namespaceObject.useInstanceId)(STYLE_BLOCK_PROPS_REFERENCE, 'wp-elements');
33821    const baseElementSelector = `.$blockElementsContainerIdentifier}`;
33822    const blockElementStyles = style?.elements;
33823    const styles = (0,external_wp_element_namespaceObject.useMemo)(() => {
33824      if (!blockElementStyles) {
33825        return;
33826      }
33827      const elementCSSRules = [];
33828      elementTypes.forEach(({
33829        elementType,
33830        pseudo,
33831        elements
33832      }) => {
33833        const skipSerialization = shouldSkipSerialization(name, COLOR_SUPPORT_KEY, elementType);
33834        if (skipSerialization) {
33835          return;
33836        }
33837        const elementStyles = blockElementStyles?.[elementType];
33838  
33839        // Process primary element type styles.
33840        if (elementStyles) {
33841          const selector = scopeSelector(baseElementSelector, external_wp_blocks_namespaceObject.__EXPERIMENTAL_ELEMENTS[elementType]);
33842          elementCSSRules.push((0,external_wp_styleEngine_namespaceObject.compileCSS)(elementStyles, {
33843            selector
33844          }));
33845  
33846          // Process any interactive states for the element type.
33847          if (pseudo) {
33848            pseudo.forEach(pseudoSelector => {
33849              if (elementStyles[pseudoSelector]) {
33850                elementCSSRules.push((0,external_wp_styleEngine_namespaceObject.compileCSS)(elementStyles[pseudoSelector], {
33851                  selector: scopeSelector(baseElementSelector, `$external_wp_blocks_namespaceObject.__EXPERIMENTAL_ELEMENTS[elementType]}$pseudoSelector}`)
33852                }));
33853              }
33854            });
33855          }
33856        }
33857  
33858        // Process related elements e.g. h1-h6 for headings
33859        if (elements) {
33860          elements.forEach(element => {
33861            if (blockElementStyles[element]) {
33862              elementCSSRules.push((0,external_wp_styleEngine_namespaceObject.compileCSS)(blockElementStyles[element], {
33863                selector: scopeSelector(baseElementSelector, external_wp_blocks_namespaceObject.__EXPERIMENTAL_ELEMENTS[element])
33864              }));
33865            }
33866          });
33867        }
33868      });
33869      return elementCSSRules.length > 0 ? elementCSSRules.join('') : undefined;
33870    }, [baseElementSelector, blockElementStyles, name]);
33871    useStyleOverride({
33872      css: styles
33873    });
33874    return style_addSaveProps({
33875      className: blockElementsContainerIdentifier
33876    }, name, {
33877      style
33878    }, skipSerializationPathsEdit);
33879  }
33880  (0,external_wp_hooks_namespaceObject.addFilter)('blocks.registerBlockType', 'core/style/addAttribute', style_addAttribute);
33881  
33882  ;// ./node_modules/@wordpress/block-editor/build-module/hooks/settings.js
33883  /**
33884   * WordPress dependencies
33885   */
33886  
33887  
33888  const hasSettingsSupport = blockType => (0,external_wp_blocks_namespaceObject.hasBlockSupport)(blockType, '__experimentalSettings', false);
33889  function settings_addAttribute(settings) {
33890    if (!hasSettingsSupport(settings)) {
33891      return settings;
33892    }
33893  
33894    // Allow blocks to specify their own attribute definition with default values if needed.
33895    if (!settings?.attributes?.settings) {
33896      settings.attributes = {
33897        ...settings.attributes,
33898        settings: {
33899          type: 'object'
33900        }
33901      };
33902    }
33903    return settings;
33904  }
33905  (0,external_wp_hooks_namespaceObject.addFilter)('blocks.registerBlockType', 'core/settings/addAttribute', settings_addAttribute);
33906  
33907  ;// ./node_modules/@wordpress/icons/build-module/library/filter.js
33908  /**
33909   * WordPress dependencies
33910   */
33911  
33912  
33913  const filter = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
33914    xmlns: "http://www.w3.org/2000/svg",
33915    viewBox: "0 0 24 24",
33916    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
33917      d: "M12 4 4 19h16L12 4zm0 3.2 5.5 10.3H12V7.2z"
33918    })
33919  });
33920  /* harmony default export */ const library_filter = (filter);
33921  
33922  ;// ./node_modules/@wordpress/block-editor/build-module/components/duotone-control/index.js
33923  /**
33924   * WordPress dependencies
33925   */
33926  
33927  
33928  
33929  
33930  
33931  
33932  function DuotoneControl({
33933    id: idProp,
33934    colorPalette,
33935    duotonePalette,
33936    disableCustomColors,
33937    disableCustomDuotone,
33938    value,
33939    onChange
33940  }) {
33941    let toolbarIcon;
33942    if (value === 'unset') {
33943      toolbarIcon = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ColorIndicator, {
33944        className: "block-editor-duotone-control__unset-indicator"
33945      });
33946    } else if (value) {
33947      toolbarIcon = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.DuotoneSwatch, {
33948        values: value
33949      });
33950    } else {
33951      toolbarIcon = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(build_module_icon, {
33952        icon: library_filter
33953      });
33954    }
33955    const actionLabel = (0,external_wp_i18n_namespaceObject.__)('Apply duotone filter');
33956    const id = (0,external_wp_compose_namespaceObject.useInstanceId)(DuotoneControl, 'duotone-control', idProp);
33957    const descriptionId = `$id}__description`;
33958    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Dropdown, {
33959      popoverProps: {
33960        className: 'block-editor-duotone-control__popover',
33961        headerTitle: (0,external_wp_i18n_namespaceObject.__)('Duotone')
33962      },
33963      renderToggle: ({
33964        isOpen,
33965        onToggle
33966      }) => {
33967        const openOnArrowDown = event => {
33968          if (!isOpen && event.keyCode === external_wp_keycodes_namespaceObject.DOWN) {
33969            event.preventDefault();
33970            onToggle();
33971          }
33972        };
33973        return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarButton, {
33974          showTooltip: true,
33975          onClick: onToggle,
33976          "aria-haspopup": "true",
33977          "aria-expanded": isOpen,
33978          onKeyDown: openOnArrowDown,
33979          label: actionLabel,
33980          icon: toolbarIcon
33981        });
33982      },
33983      renderContent: () => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.MenuGroup, {
33984        label: (0,external_wp_i18n_namespaceObject.__)('Duotone'),
33985        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("p", {
33986          children: (0,external_wp_i18n_namespaceObject.__)('Create a two-tone color effect without losing your original image.')
33987        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.DuotonePicker, {
33988          "aria-label": actionLabel,
33989          "aria-describedby": descriptionId,
33990          colorPalette: colorPalette,
33991          duotonePalette: duotonePalette,
33992          disableCustomColors: disableCustomColors,
33993          disableCustomDuotone: disableCustomDuotone,
33994          value: value,
33995          onChange: onChange
33996        })]
33997      })
33998    });
33999  }
34000  /* harmony default export */ const duotone_control = (DuotoneControl);
34001  
34002  ;// ./node_modules/@wordpress/block-editor/build-module/components/duotone/utils.js
34003  /**
34004   * External dependencies
34005   */
34006  
34007  
34008  /**
34009   * Convert a list of colors to an object of R, G, and B values.
34010   *
34011   * @param {string[]} colors Array of RBG color strings.
34012   *
34013   * @return {Object} R, G, and B values.
34014   */
34015  function getValuesFromColors(colors = []) {
34016    const values = {
34017      r: [],
34018      g: [],
34019      b: [],
34020      a: []
34021    };
34022    colors.forEach(color => {
34023      const rgbColor = w(color).toRgb();
34024      values.r.push(rgbColor.r / 255);
34025      values.g.push(rgbColor.g / 255);
34026      values.b.push(rgbColor.b / 255);
34027      values.a.push(rgbColor.a);
34028    });
34029    return values;
34030  }
34031  
34032  /**
34033   * Stylesheet for disabling a global styles duotone filter.
34034   *
34035   * @param {string} selector Selector to disable the filter for.
34036   *
34037   * @return {string} Filter none style.
34038   */
34039  function getDuotoneUnsetStylesheet(selector) {
34040    return `$selector}{filter:none}`;
34041  }
34042  
34043  /**
34044   * SVG and stylesheet needed for rendering the duotone filter.
34045   *
34046   * @param {string} selector Selector to apply the filter to.
34047   * @param {string} id       Unique id for this duotone filter.
34048   *
34049   * @return {string} Duotone filter style.
34050   */
34051  function getDuotoneStylesheet(selector, id) {
34052    return `$selector}{filter:url(#$id})}`;
34053  }
34054  
34055  /**
34056   * The SVG part of the duotone filter.
34057   *
34058   * @param {string}   id     Unique id for this duotone filter.
34059   * @param {string[]} colors Color strings from dark to light.
34060   *
34061   * @return {string} Duotone SVG.
34062   */
34063  function getDuotoneFilter(id, colors) {
34064    const values = getValuesFromColors(colors);
34065    return `
34066  <svg
34067      xmlns:xlink="http://www.w3.org/1999/xlink"
34068      viewBox="0 0 0 0"
34069      width="0"
34070      height="0"
34071      focusable="false"
34072      role="none"
34073      aria-hidden="true"
34074      style="visibility: hidden; position: absolute; left: -9999px; overflow: hidden;"
34075  >
34076      <defs>
34077          <filter id="$id}">
34078              <!--
34079                  Use sRGB instead of linearRGB so transparency looks correct.
34080                  Use perceptual brightness to convert to grayscale.
34081              -->
34082              <feColorMatrix color-interpolation-filters="sRGB" type="matrix" values=" .299 .587 .114 0 0 .299 .587 .114 0 0 .299 .587 .114 0 0 .299 .587 .114 0 0 "></feColorMatrix>
34083              <!-- Use sRGB instead of linearRGB to be consistent with how CSS gradients work. -->
34084              <feComponentTransfer color-interpolation-filters="sRGB">
34085                  <feFuncR type="table" tableValues="$values.r.join(' ')}"></feFuncR>
34086                  <feFuncG type="table" tableValues="$values.g.join(' ')}"></feFuncG>
34087                  <feFuncB type="table" tableValues="$values.b.join(' ')}"></feFuncB>
34088                  <feFuncA type="table" tableValues="$values.a.join(' ')}"></feFuncA>
34089              </feComponentTransfer>
34090              <!-- Re-mask the image with the original transparency since the feColorMatrix above loses that information. -->
34091              <feComposite in2="SourceGraphic" operator="in"></feComposite>
34092          </filter>
34093      </defs>
34094  </svg>`;
34095  }
34096  
34097  ;// ./node_modules/@wordpress/block-editor/build-module/components/global-styles/get-block-css-selector.js
34098  /**
34099   * Internal dependencies
34100   */
34101  
34102  
34103  
34104  /**
34105   * Determine the CSS selector for the block type and target provided, returning
34106   * it if available.
34107   *
34108   * @param {import('@wordpress/blocks').Block} blockType        The block's type.
34109   * @param {string|string[]}                   target           The desired selector's target e.g. `root`, delimited string, or array path.
34110   * @param {Object}                            options          Options object.
34111   * @param {boolean}                           options.fallback Whether or not to fallback to broader selector.
34112   *
34113   * @return {?string} The CSS selector or `null` if no selector available.
34114   */
34115  function getBlockCSSSelector(blockType, target = 'root', options = {}) {
34116    if (!target) {
34117      return null;
34118    }
34119    const {
34120      fallback = false
34121    } = options;
34122    const {
34123      name,
34124      selectors,
34125      supports
34126    } = blockType;
34127    const hasSelectors = selectors && Object.keys(selectors).length > 0;
34128    const path = Array.isArray(target) ? target.join('.') : target;
34129  
34130    // Root selector.
34131  
34132    // Calculated before returning as it can be used as a fallback for feature
34133    // selectors later on.
34134    let rootSelector = null;
34135    if (hasSelectors && selectors.root) {
34136      // Use the selectors API if available.
34137      rootSelector = selectors?.root;
34138    } else if (supports?.__experimentalSelector) {
34139      // Use the old experimental selector supports property if set.
34140      rootSelector = supports.__experimentalSelector;
34141    } else {
34142      // If no root selector found, generate default block class selector.
34143      rootSelector = '.wp-block-' + name.replace('core/', '').replace('/', '-');
34144    }
34145  
34146    // Return selector if it's the root target we are looking for.
34147    if (path === 'root') {
34148      return rootSelector;
34149    }
34150  
34151    // If target is not `root` or `duotone` we have a feature or subfeature
34152    // as the target. If the target is a string convert to an array.
34153    const pathArray = Array.isArray(target) ? target : target.split('.');
34154  
34155    // Feature selectors ( may fallback to root selector );
34156    if (pathArray.length === 1) {
34157      const fallbackSelector = fallback ? rootSelector : null;
34158  
34159      // Prefer the selectors API if available.
34160      if (hasSelectors) {
34161        // Get selector from either `feature.root` or shorthand path.
34162        const featureSelector = getValueFromObjectPath(selectors, `$path}.root`, null) || getValueFromObjectPath(selectors, path, null);
34163  
34164        // Return feature selector if found or any available fallback.
34165        return featureSelector || fallbackSelector;
34166      }
34167  
34168      // Try getting old experimental supports selector value.
34169      const featureSelector = getValueFromObjectPath(supports, `$path}.__experimentalSelector`, null);
34170  
34171      // If nothing to work with, provide fallback selector if available.
34172      if (!featureSelector) {
34173        return fallbackSelector;
34174      }
34175  
34176      // Scope the feature selector by the block's root selector.
34177      return scopeSelector(rootSelector, featureSelector);
34178    }
34179  
34180    // Subfeature selector.
34181    // This may fallback either to parent feature or root selector.
34182    let subfeatureSelector;
34183  
34184    // Use selectors API if available.
34185    if (hasSelectors) {
34186      subfeatureSelector = getValueFromObjectPath(selectors, path, null);
34187    }
34188  
34189    // Only return if we have a subfeature selector.
34190    if (subfeatureSelector) {
34191      return subfeatureSelector;
34192    }
34193  
34194    // To this point we don't have a subfeature selector. If a fallback has been
34195    // requested, remove subfeature from target path and return results of a
34196    // call for the parent feature's selector.
34197    if (fallback) {
34198      return getBlockCSSSelector(blockType, pathArray[0], options);
34199    }
34200  
34201    // We tried.
34202    return null;
34203  }
34204  
34205  ;// ./node_modules/@wordpress/block-editor/build-module/components/global-styles/filters-panel.js
34206  /**
34207   * External dependencies
34208   */
34209  
34210  
34211  /**
34212   * WordPress dependencies
34213   */
34214  
34215  
34216  
34217  
34218  
34219  /**
34220   * Internal dependencies
34221   */
34222  
34223  
34224  
34225  const filters_panel_EMPTY_ARRAY = [];
34226  function useMultiOriginColorPresets(settings, {
34227    presetSetting,
34228    defaultSetting
34229  }) {
34230    const disableDefault = !settings?.color?.[defaultSetting];
34231    const userPresets = settings?.color?.[presetSetting]?.custom || filters_panel_EMPTY_ARRAY;
34232    const themePresets = settings?.color?.[presetSetting]?.theme || filters_panel_EMPTY_ARRAY;
34233    const defaultPresets = settings?.color?.[presetSetting]?.default || filters_panel_EMPTY_ARRAY;
34234    return (0,external_wp_element_namespaceObject.useMemo)(() => [...userPresets, ...themePresets, ...(disableDefault ? filters_panel_EMPTY_ARRAY : defaultPresets)], [disableDefault, userPresets, themePresets, defaultPresets]);
34235  }
34236  function useHasFiltersPanel(settings) {
34237    return useHasDuotoneControl(settings);
34238  }
34239  function useHasDuotoneControl(settings) {
34240    return settings.color.customDuotone || settings.color.defaultDuotone || settings.color.duotone.length > 0;
34241  }
34242  function FiltersToolsPanel({
34243    resetAllFilter,
34244    onChange,
34245    value,
34246    panelId,
34247    children
34248  }) {
34249    const dropdownMenuProps = useToolsPanelDropdownMenuProps();
34250    const resetAll = () => {
34251      const updatedValue = resetAllFilter(value);
34252      onChange(updatedValue);
34253    };
34254    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanel, {
34255      label: (0,external_wp_i18n_namespaceObject._x)('Filters', 'Name for applying graphical effects'),
34256      resetAll: resetAll,
34257      panelId: panelId,
34258      dropdownMenuProps: dropdownMenuProps,
34259      children: children
34260    });
34261  }
34262  const filters_panel_DEFAULT_CONTROLS = {
34263    duotone: true
34264  };
34265  const filters_panel_popoverProps = {
34266    placement: 'left-start',
34267    offset: 36,
34268    shift: true,
34269    className: 'block-editor-duotone-control__popover',
34270    headerTitle: (0,external_wp_i18n_namespaceObject.__)('Duotone')
34271  };
34272  const LabeledColorIndicator = ({
34273    indicator,
34274    label
34275  }) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalHStack, {
34276    justify: "flex-start",
34277    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalZStack, {
34278      isLayered: false,
34279      offset: -8,
34280      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Flex, {
34281        expanded: false,
34282        children: indicator === 'unset' || !indicator ? /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ColorIndicator, {
34283          className: "block-editor-duotone-control__unset-indicator"
34284        }) : /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.DuotoneSwatch, {
34285          values: indicator
34286        })
34287      })
34288    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FlexItem, {
34289      title: label,
34290      children: label
34291    })]
34292  });
34293  const renderToggle = (duotone, resetDuotone) => ({
34294    onToggle,
34295    isOpen
34296  }) => {
34297    const duotoneButtonRef = (0,external_wp_element_namespaceObject.useRef)(undefined);
34298    const toggleProps = {
34299      onClick: onToggle,
34300      className: dist_clsx({
34301        'is-open': isOpen
34302      }),
34303      'aria-expanded': isOpen,
34304      ref: duotoneButtonRef
34305    };
34306    const removeButtonProps = {
34307      onClick: () => {
34308        if (isOpen) {
34309          onToggle();
34310        }
34311        resetDuotone();
34312        // Return focus to parent button.
34313        duotoneButtonRef.current?.focus();
34314      },
34315      className: 'block-editor-panel-duotone-settings__reset',
34316      label: (0,external_wp_i18n_namespaceObject.__)('Reset')
34317    };
34318    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
34319      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
34320        __next40pxDefaultSize: true,
34321        ...toggleProps,
34322        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(LabeledColorIndicator, {
34323          indicator: duotone,
34324          label: (0,external_wp_i18n_namespaceObject.__)('Duotone')
34325        })
34326      }), duotone && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
34327        size: "small",
34328        icon: library_reset,
34329        ...removeButtonProps
34330      })]
34331    });
34332  };
34333  function FiltersPanel({
34334    as: Wrapper = FiltersToolsPanel,
34335    value,
34336    onChange,
34337    inheritedValue = value,
34338    settings,
34339    panelId,
34340    defaultControls = filters_panel_DEFAULT_CONTROLS
34341  }) {
34342    const decodeValue = rawValue => getValueFromVariable({
34343      settings
34344    }, '', rawValue);
34345  
34346    // Duotone
34347    const hasDuotoneEnabled = useHasDuotoneControl(settings);
34348    const duotonePalette = useMultiOriginColorPresets(settings, {
34349      presetSetting: 'duotone',
34350      defaultSetting: 'defaultDuotone'
34351    });
34352    const colorPalette = useMultiOriginColorPresets(settings, {
34353      presetSetting: 'palette',
34354      defaultSetting: 'defaultPalette'
34355    });
34356    const duotone = decodeValue(inheritedValue?.filter?.duotone);
34357    const setDuotone = newValue => {
34358      const duotonePreset = duotonePalette.find(({
34359        colors
34360      }) => {
34361        return colors === newValue;
34362      });
34363      const duotoneValue = duotonePreset ? `var:preset|duotone|$duotonePreset.slug}` : newValue;
34364      onChange(setImmutably(value, ['filter', 'duotone'], duotoneValue));
34365    };
34366    const hasDuotone = () => !!value?.filter?.duotone;
34367    const resetDuotone = () => setDuotone(undefined);
34368    const resetAllFilter = (0,external_wp_element_namespaceObject.useCallback)(previousValue => {
34369      return {
34370        ...previousValue,
34371        filter: {
34372          ...previousValue.filter,
34373          duotone: undefined
34374        }
34375      };
34376    }, []);
34377    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Wrapper, {
34378      resetAllFilter: resetAllFilter,
34379      value: value,
34380      onChange: onChange,
34381      panelId: panelId,
34382      children: hasDuotoneEnabled && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanelItem, {
34383        label: (0,external_wp_i18n_namespaceObject.__)('Duotone'),
34384        hasValue: hasDuotone,
34385        onDeselect: resetDuotone,
34386        isShownByDefault: defaultControls.duotone,
34387        panelId: panelId,
34388        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Dropdown, {
34389          popoverProps: filters_panel_popoverProps,
34390          className: "block-editor-global-styles-filters-panel__dropdown",
34391          renderToggle: renderToggle(duotone, resetDuotone),
34392          renderContent: () => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalDropdownContentWrapper, {
34393            paddingSize: "small",
34394            children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.MenuGroup, {
34395              label: (0,external_wp_i18n_namespaceObject.__)('Duotone'),
34396              children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("p", {
34397                children: (0,external_wp_i18n_namespaceObject.__)('Create a two-tone color effect without losing your original image.')
34398              }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.DuotonePicker, {
34399                colorPalette: colorPalette,
34400                duotonePalette: duotonePalette
34401                // TODO: Re-enable both when custom colors are supported for block-level styles.
34402                ,
34403                disableCustomColors: true,
34404                disableCustomDuotone: true,
34405                value: duotone,
34406                onChange: setDuotone
34407              })]
34408            })
34409          })
34410        })
34411      })
34412    });
34413  }
34414  
34415  ;// ./node_modules/@wordpress/block-editor/build-module/hooks/duotone.js
34416  /**
34417   * External dependencies
34418   */
34419  
34420  
34421  
34422  /**
34423   * WordPress dependencies
34424   */
34425  
34426  
34427  
34428  
34429  
34430  /**
34431   * Internal dependencies
34432   */
34433  
34434  
34435  
34436  
34437  
34438  
34439  
34440  
34441  
34442  const duotone_EMPTY_ARRAY = [];
34443  
34444  // Safari does not always update the duotone filter when the duotone colors
34445  // are changed. This browser check is later used to force a re-render of the block
34446  // element to ensure the duotone filter is updated. The check is included at the
34447  // root of this file as it only needs to be run once per page load.
34448  const isSafari = window?.navigator.userAgent && window.navigator.userAgent.includes('Safari') && !window.navigator.userAgent.includes('Chrome') && !window.navigator.userAgent.includes('Chromium');
34449  k([names]);
34450  function useMultiOriginPresets({
34451    presetSetting,
34452    defaultSetting
34453  }) {
34454    const [enableDefault, userPresets, themePresets, defaultPresets] = use_settings_useSettings(defaultSetting, `$presetSetting}.custom`, `$presetSetting}.theme`, `$presetSetting}.default`);
34455    return (0,external_wp_element_namespaceObject.useMemo)(() => [...(userPresets || duotone_EMPTY_ARRAY), ...(themePresets || duotone_EMPTY_ARRAY), ...(enableDefault && defaultPresets || duotone_EMPTY_ARRAY)], [enableDefault, userPresets, themePresets, defaultPresets]);
34456  }
34457  function getColorsFromDuotonePreset(duotone, duotonePalette) {
34458    if (!duotone) {
34459      return;
34460    }
34461    const preset = duotonePalette?.find(({
34462      slug
34463    }) => {
34464      return duotone === `var:preset|duotone|$slug}`;
34465    });
34466    return preset ? preset.colors : undefined;
34467  }
34468  function getDuotonePresetFromColors(colors, duotonePalette) {
34469    if (!colors || !Array.isArray(colors)) {
34470      return;
34471    }
34472    const preset = duotonePalette?.find(duotonePreset => {
34473      return duotonePreset?.colors?.every((val, index) => val === colors[index]);
34474    });
34475    return preset ? `var:preset|duotone|$preset.slug}` : undefined;
34476  }
34477  function DuotonePanelPure({
34478    style,
34479    setAttributes,
34480    name
34481  }) {
34482    const duotoneStyle = style?.color?.duotone;
34483    const settings = useBlockSettings(name);
34484    const blockEditingMode = useBlockEditingMode();
34485    const duotonePalette = useMultiOriginPresets({
34486      presetSetting: 'color.duotone',
34487      defaultSetting: 'color.defaultDuotone'
34488    });
34489    const colorPalette = useMultiOriginPresets({
34490      presetSetting: 'color.palette',
34491      defaultSetting: 'color.defaultPalette'
34492    });
34493    const [enableCustomColors, enableCustomDuotone] = use_settings_useSettings('color.custom', 'color.customDuotone');
34494    const disableCustomColors = !enableCustomColors;
34495    const disableCustomDuotone = !enableCustomDuotone || colorPalette?.length === 0 && disableCustomColors;
34496    if (duotonePalette?.length === 0 && disableCustomDuotone) {
34497      return null;
34498    }
34499    if (blockEditingMode !== 'default') {
34500      return null;
34501    }
34502    const duotonePresetOrColors = !Array.isArray(duotoneStyle) ? getColorsFromDuotonePreset(duotoneStyle, duotonePalette) : duotoneStyle;
34503    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
34504      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls, {
34505        group: "filter",
34506        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(FiltersPanel, {
34507          value: {
34508            filter: {
34509              duotone: duotonePresetOrColors
34510            }
34511          },
34512          onChange: newDuotone => {
34513            const newStyle = {
34514              ...style,
34515              color: {
34516                ...newDuotone?.filter
34517              }
34518            };
34519            setAttributes({
34520              style: newStyle
34521            });
34522          },
34523          settings: settings
34524        })
34525      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_controls, {
34526        group: "block",
34527        __experimentalShareWithChildBlocks: true,
34528        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(duotone_control, {
34529          duotonePalette: duotonePalette,
34530          colorPalette: colorPalette,
34531          disableCustomDuotone: disableCustomDuotone,
34532          disableCustomColors: disableCustomColors,
34533          value: duotonePresetOrColors,
34534          onChange: newDuotone => {
34535            const maybePreset = getDuotonePresetFromColors(newDuotone, duotonePalette);
34536            const newStyle = {
34537              ...style,
34538              color: {
34539                ...style?.color,
34540                duotone: maybePreset !== null && maybePreset !== void 0 ? maybePreset : newDuotone // use preset or fallback to custom colors.
34541              }
34542            };
34543            setAttributes({
34544              style: newStyle
34545            });
34546          },
34547          settings: settings
34548        })
34549      })]
34550    });
34551  }
34552  /* harmony default export */ const duotone = ({
34553    shareWithChildBlocks: true,
34554    edit: DuotonePanelPure,
34555    useBlockProps: duotone_useBlockProps,
34556    attributeKeys: ['style'],
34557    hasSupport(name) {
34558      return (0,external_wp_blocks_namespaceObject.hasBlockSupport)(name, 'filter.duotone');
34559    }
34560  });
34561  
34562  /**
34563   * Filters registered block settings, extending attributes to include
34564   * the `duotone` attribute.
34565   *
34566   * @param {Object} settings Original block settings.
34567   *
34568   * @return {Object} Filtered block settings.
34569   */
34570  function addDuotoneAttributes(settings) {
34571    // Previous `color.__experimentalDuotone` support flag is migrated via
34572    // block_type_metadata_settings filter in `lib/block-supports/duotone.php`.
34573    if (!(0,external_wp_blocks_namespaceObject.hasBlockSupport)(settings, 'filter.duotone')) {
34574      return settings;
34575    }
34576  
34577    // Allow blocks to specify their own attribute definition with default
34578    // values if needed.
34579    if (!settings.attributes.style) {
34580      Object.assign(settings.attributes, {
34581        style: {
34582          type: 'object'
34583        }
34584      });
34585    }
34586    return settings;
34587  }
34588  function useDuotoneStyles({
34589    clientId,
34590    id: filterId,
34591    selector: duotoneSelector,
34592    attribute: duotoneAttr
34593  }) {
34594    const duotonePalette = useMultiOriginPresets({
34595      presetSetting: 'color.duotone',
34596      defaultSetting: 'color.defaultDuotone'
34597    });
34598  
34599    // Possible values for duotone attribute:
34600    // 1. Array of colors - e.g. ['#000000', '#ffffff'].
34601    // 2. Variable for an existing Duotone preset - e.g. 'var:preset|duotone|green-blue' or 'var(--wp--preset--duotone--green-blue)''
34602    // 3. A CSS string - e.g. 'unset' to remove globally applied duotone.
34603    const isCustom = Array.isArray(duotoneAttr);
34604    const duotonePreset = isCustom ? undefined : getColorsFromDuotonePreset(duotoneAttr, duotonePalette);
34605    const isPreset = typeof duotoneAttr === 'string' && duotonePreset;
34606    const isCSS = typeof duotoneAttr === 'string' && !isPreset;
34607  
34608    // Match the structure of WP_Duotone_Gutenberg::render_duotone_support() in PHP.
34609    let colors = null;
34610    if (isPreset) {
34611      // Array of colors.
34612      colors = duotonePreset;
34613    } else if (isCSS) {
34614      // CSS filter property string (e.g. 'unset').
34615      colors = duotoneAttr;
34616    } else if (isCustom) {
34617      // Array of colors.
34618      colors = duotoneAttr;
34619    }
34620  
34621    // Build the CSS selectors to which the filter will be applied.
34622    const selectors = duotoneSelector.split(',');
34623    const selectorsScoped = selectors.map(selectorPart => {
34624      // Assuming the selector part is a subclass selector (not a tag name)
34625      // so we can prepend the filter id class. If we want to support elements
34626      // such as `img` or namespaces, we'll need to add a case for that here.
34627      return `.$filterId}$selectorPart.trim()}`;
34628    });
34629    const selector = selectorsScoped.join(', ');
34630    const isValidFilter = Array.isArray(colors) || colors === 'unset';
34631    usePrivateStyleOverride(isValidFilter ? {
34632      css: colors !== 'unset' ? getDuotoneStylesheet(selector, filterId) : getDuotoneUnsetStylesheet(selector),
34633      __unstableType: 'presets'
34634    } : undefined);
34635    usePrivateStyleOverride(isValidFilter ? {
34636      assets: colors !== 'unset' ? getDuotoneFilter(filterId, colors) : '',
34637      __unstableType: 'svgs'
34638    } : undefined);
34639    const blockElement = useBlockElement(clientId);
34640    (0,external_wp_element_namespaceObject.useEffect)(() => {
34641      if (!isValidFilter) {
34642        return;
34643      }
34644  
34645      // Safari does not always update the duotone filter when the duotone
34646      // colors are changed. When using Safari, force the block element to be
34647      // repainted by the browser to ensure any changes are reflected
34648      // visually. This logic matches that used on the site frontend in
34649      // `block-supports/duotone.php`.
34650      if (blockElement && isSafari) {
34651        const display = blockElement.style.display;
34652        // Switch to `inline-block` to force a repaint. In the editor,
34653        // `inline-block` is used instead of `none` to ensure that scroll
34654        // position is not affected, as `none` results in the editor
34655        // scrolling to the top of the block.
34656        blockElement.style.setProperty('display', 'inline-block');
34657        // Simply accessing el.offsetHeight flushes layout and style changes
34658        // in WebKit without having to wait for setTimeout.
34659        // eslint-disable-next-line no-unused-expressions
34660        blockElement.offsetHeight;
34661        blockElement.style.setProperty('display', display);
34662      }
34663      // `colors` must be a dependency so this effect runs when the colors
34664      // change in Safari.
34665    }, [isValidFilter, blockElement, colors]);
34666  }
34667  
34668  // Used for generating the instance ID
34669  const DUOTONE_BLOCK_PROPS_REFERENCE = {};
34670  function duotone_useBlockProps({
34671    clientId,
34672    name,
34673    style
34674  }) {
34675    const id = (0,external_wp_compose_namespaceObject.useInstanceId)(DUOTONE_BLOCK_PROPS_REFERENCE);
34676    const selector = (0,external_wp_element_namespaceObject.useMemo)(() => {
34677      const blockType = (0,external_wp_blocks_namespaceObject.getBlockType)(name);
34678      if (blockType) {
34679        // Backwards compatibility for `supports.color.__experimentalDuotone`
34680        // is provided via the `block_type_metadata_settings` filter. If
34681        // `supports.filter.duotone` has not been set and the
34682        // experimental property has been, the experimental property
34683        // value is copied into `supports.filter.duotone`.
34684        const duotoneSupport = (0,external_wp_blocks_namespaceObject.getBlockSupport)(blockType, 'filter.duotone', false);
34685        if (!duotoneSupport) {
34686          return null;
34687        }
34688  
34689        // If the experimental duotone support was set, that value is
34690        // to be treated as a selector and requires scoping.
34691        const experimentalDuotone = (0,external_wp_blocks_namespaceObject.getBlockSupport)(blockType, 'color.__experimentalDuotone', false);
34692        if (experimentalDuotone) {
34693          const rootSelector = getBlockCSSSelector(blockType);
34694          return typeof experimentalDuotone === 'string' ? scopeSelector(rootSelector, experimentalDuotone) : rootSelector;
34695        }
34696  
34697        // Regular filter.duotone support uses filter.duotone selectors with fallbacks.
34698        return getBlockCSSSelector(blockType, 'filter.duotone', {
34699          fallback: true
34700        });
34701      }
34702    }, [name]);
34703    const attribute = style?.color?.duotone;
34704    const filterClass = `wp-duotone-$id}`;
34705    const shouldRender = selector && attribute;
34706    useDuotoneStyles({
34707      clientId,
34708      id: filterClass,
34709      selector,
34710      attribute
34711    });
34712    return {
34713      className: shouldRender ? filterClass : ''
34714    };
34715  }
34716  (0,external_wp_hooks_namespaceObject.addFilter)('blocks.registerBlockType', 'core/editor/duotone/add-attributes', addDuotoneAttributes);
34717  
34718  ;// ./node_modules/@wordpress/block-editor/build-module/components/use-block-display-information/index.js
34719  /**
34720   * WordPress dependencies
34721   */
34722  
34723  
34724  
34725  
34726  /**
34727   * Internal dependencies
34728   */
34729  
34730  
34731  /** @typedef {import('@wordpress/blocks').WPIcon} WPIcon */
34732  
34733  /**
34734   * Contains basic block's information for display reasons.
34735   *
34736   * @typedef {Object} WPBlockDisplayInformation
34737   *
34738   * @property {boolean} isSynced    True if is a reusable block or template part
34739   * @property {string}  title       Human-readable block type label.
34740   * @property {WPIcon}  icon        Block type icon.
34741   * @property {string}  description A detailed block type description.
34742   * @property {string}  anchor      HTML anchor.
34743   * @property {name}    name        A custom, human readable name for the block.
34744   */
34745  
34746  /**
34747   * Get the display label for a block's position type.
34748   *
34749   * @param {Object} attributes Block attributes.
34750   * @return {string} The position type label.
34751   */
34752  function getPositionTypeLabel(attributes) {
34753    const positionType = attributes?.style?.position?.type;
34754    if (positionType === 'sticky') {
34755      return (0,external_wp_i18n_namespaceObject.__)('Sticky');
34756    }
34757    if (positionType === 'fixed') {
34758      return (0,external_wp_i18n_namespaceObject.__)('Fixed');
34759    }
34760    return null;
34761  }
34762  
34763  /**
34764   * Hook used to try to find a matching block variation and return
34765   * the appropriate information for display reasons. In order to
34766   * to try to find a match we need to things:
34767   * 1. Block's client id to extract it's current attributes.
34768   * 2. A block variation should have set `isActive` prop to a proper function.
34769   *
34770   * If for any reason a block variation match cannot be found,
34771   * the returned information come from the Block Type.
34772   * If no blockType is found with the provided clientId, returns null.
34773   *
34774   * @param {string} clientId Block's client id.
34775   * @return {?WPBlockDisplayInformation} Block's display information, or `null` when the block or its type not found.
34776   */
34777  
34778  function useBlockDisplayInformation(clientId) {
34779    return (0,external_wp_data_namespaceObject.useSelect)(select => {
34780      if (!clientId) {
34781        return null;
34782      }
34783      const {
34784        getBlockName,
34785        getBlockAttributes
34786      } = select(store);
34787      const {
34788        getBlockType,
34789        getActiveBlockVariation
34790      } = select(external_wp_blocks_namespaceObject.store);
34791      const blockName = getBlockName(clientId);
34792      const blockType = getBlockType(blockName);
34793      if (!blockType) {
34794        return null;
34795      }
34796      const attributes = getBlockAttributes(clientId);
34797      const match = getActiveBlockVariation(blockName, attributes);
34798      const isSynced = (0,external_wp_blocks_namespaceObject.isReusableBlock)(blockType) || (0,external_wp_blocks_namespaceObject.isTemplatePart)(blockType);
34799      const syncedTitle = isSynced ? (0,external_wp_blocks_namespaceObject.__experimentalGetBlockLabel)(blockType, attributes) : undefined;
34800      const title = syncedTitle || blockType.title;
34801      const positionLabel = getPositionTypeLabel(attributes);
34802      const blockTypeInfo = {
34803        isSynced,
34804        title,
34805        icon: blockType.icon,
34806        description: blockType.description,
34807        anchor: attributes?.anchor,
34808        positionLabel,
34809        positionType: attributes?.style?.position?.type,
34810        name: attributes?.metadata?.name
34811      };
34812      if (!match) {
34813        return blockTypeInfo;
34814      }
34815      return {
34816        isSynced,
34817        title: match.title || blockType.title,
34818        icon: match.icon || blockType.icon,
34819        description: match.description || blockType.description,
34820        anchor: attributes?.anchor,
34821        positionLabel,
34822        positionType: attributes?.style?.position?.type,
34823        name: attributes?.metadata?.name
34824      };
34825    }, [clientId]);
34826  }
34827  
34828  ;// ./node_modules/@wordpress/block-editor/build-module/hooks/position.js
34829  /**
34830   * External dependencies
34831   */
34832  
34833  
34834  /**
34835   * WordPress dependencies
34836   */
34837  
34838  
34839  
34840  
34841  
34842  
34843  
34844  /**
34845   * Internal dependencies
34846   */
34847  
34848  
34849  
34850  
34851  
34852  
34853  const POSITION_SUPPORT_KEY = 'position';
34854  const DEFAULT_OPTION = {
34855    key: 'default',
34856    value: '',
34857    name: (0,external_wp_i18n_namespaceObject.__)('Default')
34858  };
34859  const STICKY_OPTION = {
34860    key: 'sticky',
34861    value: 'sticky',
34862    name: (0,external_wp_i18n_namespaceObject._x)('Sticky', 'Name for the value of the CSS position property'),
34863    hint: (0,external_wp_i18n_namespaceObject.__)('The block will stick to the top of the window instead of scrolling.')
34864  };
34865  const FIXED_OPTION = {
34866    key: 'fixed',
34867    value: 'fixed',
34868    name: (0,external_wp_i18n_namespaceObject._x)('Fixed', 'Name for the value of the CSS position property'),
34869    hint: (0,external_wp_i18n_namespaceObject.__)('The block will not move when the page is scrolled.')
34870  };
34871  const POSITION_SIDES = ['top', 'right', 'bottom', 'left'];
34872  const VALID_POSITION_TYPES = ['sticky', 'fixed'];
34873  
34874  /**
34875   * Get calculated position CSS.
34876   *
34877   * @param {Object} props          Component props.
34878   * @param {string} props.selector Selector to use.
34879   * @param {Object} props.style    Style object.
34880   * @return {string} The generated CSS rules.
34881   */
34882  function getPositionCSS({
34883    selector,
34884    style
34885  }) {
34886    let output = '';
34887    const {
34888      type: positionType
34889    } = style?.position || {};
34890    if (!VALID_POSITION_TYPES.includes(positionType)) {
34891      return output;
34892    }
34893    output += `$selector} {`;
34894    output += `position: $positionType};`;
34895    POSITION_SIDES.forEach(side => {
34896      if (style?.position?.[side] !== undefined) {
34897        output += `$side}: $style.position[side]};`;
34898      }
34899    });
34900    if (positionType === 'sticky' || positionType === 'fixed') {
34901      // TODO: Replace hard-coded z-index value with a z-index preset approach in theme.json.
34902      output += `z-index: 10`;
34903    }
34904    output += `}`;
34905    return output;
34906  }
34907  
34908  /**
34909   * Determines if there is sticky position support.
34910   *
34911   * @param {string|Object} blockType Block name or Block Type object.
34912   *
34913   * @return {boolean} Whether there is support.
34914   */
34915  function hasStickyPositionSupport(blockType) {
34916    const support = (0,external_wp_blocks_namespaceObject.getBlockSupport)(blockType, POSITION_SUPPORT_KEY);
34917    return !!(true === support || support?.sticky);
34918  }
34919  
34920  /**
34921   * Determines if there is fixed position support.
34922   *
34923   * @param {string|Object} blockType Block name or Block Type object.
34924   *
34925   * @return {boolean} Whether there is support.
34926   */
34927  function hasFixedPositionSupport(blockType) {
34928    const support = (0,external_wp_blocks_namespaceObject.getBlockSupport)(blockType, POSITION_SUPPORT_KEY);
34929    return !!(true === support || support?.fixed);
34930  }
34931  
34932  /**
34933   * Determines if there is position support.
34934   *
34935   * @param {string|Object} blockType Block name or Block Type object.
34936   *
34937   * @return {boolean} Whether there is support.
34938   */
34939  function hasPositionSupport(blockType) {
34940    const support = (0,external_wp_blocks_namespaceObject.getBlockSupport)(blockType, POSITION_SUPPORT_KEY);
34941    return !!support;
34942  }
34943  
34944  /**
34945   * Checks if there is a current value in the position block support attributes.
34946   *
34947   * @param {Object} props Block props.
34948   * @return {boolean} Whether or not the block has a position value set.
34949   */
34950  function hasPositionValue(props) {
34951    return props.attributes.style?.position?.type !== undefined;
34952  }
34953  
34954  /**
34955   * Checks if the block is currently set to a sticky or fixed position.
34956   * This check is helpful for determining how to position block toolbars or other elements.
34957   *
34958   * @param {Object} attributes Block attributes.
34959   * @return {boolean} Whether or not the block is set to a sticky or fixed position.
34960   */
34961  function hasStickyOrFixedPositionValue(attributes) {
34962    const positionType = attributes?.style?.position?.type;
34963    return positionType === 'sticky' || positionType === 'fixed';
34964  }
34965  
34966  /**
34967   * Resets the position block support attributes. This can be used when disabling
34968   * the position support controls for a block via a `ToolsPanel`.
34969   *
34970   * @param {Object} props               Block props.
34971   * @param {Object} props.attributes    Block's attributes.
34972   * @param {Object} props.setAttributes Function to set block's attributes.
34973   */
34974  function resetPosition({
34975    attributes = {},
34976    setAttributes
34977  }) {
34978    const {
34979      style = {}
34980    } = attributes;
34981    setAttributes({
34982      style: cleanEmptyObject({
34983        ...style,
34984        position: {
34985          ...style?.position,
34986          type: undefined,
34987          top: undefined,
34988          right: undefined,
34989          bottom: undefined,
34990          left: undefined
34991        }
34992      })
34993    });
34994  }
34995  
34996  /**
34997   * Custom hook that checks if position settings have been disabled.
34998   *
34999   * @param {string} name The name of the block.
35000   *
35001   * @return {boolean} Whether padding setting is disabled.
35002   */
35003  function useIsPositionDisabled({
35004    name: blockName
35005  } = {}) {
35006    const [allowFixed, allowSticky] = use_settings_useSettings('position.fixed', 'position.sticky');
35007    const isDisabled = !allowFixed && !allowSticky;
35008    return !hasPositionSupport(blockName) || isDisabled;
35009  }
35010  
35011  /*
35012   * Position controls rendered in an inspector control panel.
35013   *
35014   * @param {Object} props
35015   *
35016   * @return {Element} Position panel.
35017   */
35018  function PositionPanelPure({
35019    style = {},
35020    clientId,
35021    name: blockName,
35022    setAttributes
35023  }) {
35024    const allowFixed = hasFixedPositionSupport(blockName);
35025    const allowSticky = hasStickyPositionSupport(blockName);
35026    const value = style?.position?.type;
35027    const {
35028      firstParentClientId
35029    } = (0,external_wp_data_namespaceObject.useSelect)(select => {
35030      const {
35031        getBlockParents
35032      } = select(store);
35033      const parents = getBlockParents(clientId);
35034      return {
35035        firstParentClientId: parents[parents.length - 1]
35036      };
35037    }, [clientId]);
35038    const blockInformation = useBlockDisplayInformation(firstParentClientId);
35039    const stickyHelpText = allowSticky && value === STICKY_OPTION.value && blockInformation ? (0,external_wp_i18n_namespaceObject.sprintf)(/* translators: %s: the name of the parent block. */
35040    (0,external_wp_i18n_namespaceObject.__)('The block will stick to the scrollable area of the parent %s block.'), blockInformation.title) : null;
35041    const options = (0,external_wp_element_namespaceObject.useMemo)(() => {
35042      const availableOptions = [DEFAULT_OPTION];
35043      // Display options if they are allowed, or if a block already has a valid value set.
35044      // This allows for a block to be switched off from a position type that is not allowed.
35045      if (allowSticky || value === STICKY_OPTION.value) {
35046        availableOptions.push(STICKY_OPTION);
35047      }
35048      if (allowFixed || value === FIXED_OPTION.value) {
35049        availableOptions.push(FIXED_OPTION);
35050      }
35051      return availableOptions;
35052    }, [allowFixed, allowSticky, value]);
35053    const onChangeType = next => {
35054      // For now, use a hard-coded `0px` value for the position.
35055      // `0px` is preferred over `0` as it can be used in `calc()` functions.
35056      // In the future, it could be useful to allow for an offset value.
35057      const placementValue = '0px';
35058      const newStyle = {
35059        ...style,
35060        position: {
35061          ...style?.position,
35062          type: next,
35063          top: next === 'sticky' || next === 'fixed' ? placementValue : undefined
35064        }
35065      };
35066      setAttributes({
35067        style: utils_cleanEmptyObject(newStyle)
35068      });
35069    };
35070    const selectedOption = value ? options.find(option => option.value === value) || DEFAULT_OPTION : DEFAULT_OPTION;
35071  
35072    // Only display position controls if there is at least one option to choose from.
35073    return external_wp_element_namespaceObject.Platform.select({
35074      web: options.length > 1 ? /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls, {
35075        group: "position",
35076        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.BaseControl, {
35077          __nextHasNoMarginBottom: true,
35078          help: stickyHelpText,
35079          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.CustomSelectControl, {
35080            __next40pxDefaultSize: true,
35081            label: (0,external_wp_i18n_namespaceObject.__)('Position'),
35082            hideLabelFromVision: true,
35083            describedBy: (0,external_wp_i18n_namespaceObject.sprintf)(
35084            // translators: %s: Currently selected position.
35085            (0,external_wp_i18n_namespaceObject.__)('Currently selected position: %s'), selectedOption.name),
35086            options: options,
35087            value: selectedOption,
35088            onChange: ({
35089              selectedItem
35090            }) => {
35091              onChangeType(selectedItem.value);
35092            },
35093            size: "__unstable-large"
35094          })
35095        })
35096      }) : null,
35097      native: null
35098    });
35099  }
35100  /* harmony default export */ const position = ({
35101    edit: function Edit(props) {
35102      const isPositionDisabled = useIsPositionDisabled(props);
35103      if (isPositionDisabled) {
35104        return null;
35105      }
35106      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PositionPanelPure, {
35107        ...props
35108      });
35109    },
35110    useBlockProps: position_useBlockProps,
35111    attributeKeys: ['style'],
35112    hasSupport(name) {
35113      return (0,external_wp_blocks_namespaceObject.hasBlockSupport)(name, POSITION_SUPPORT_KEY);
35114    }
35115  });
35116  
35117  // Used for generating the instance ID
35118  const POSITION_BLOCK_PROPS_REFERENCE = {};
35119  function position_useBlockProps({
35120    name,
35121    style
35122  }) {
35123    const hasPositionBlockSupport = (0,external_wp_blocks_namespaceObject.hasBlockSupport)(name, POSITION_SUPPORT_KEY);
35124    const isPositionDisabled = useIsPositionDisabled({
35125      name
35126    });
35127    const allowPositionStyles = hasPositionBlockSupport && !isPositionDisabled;
35128    const id = (0,external_wp_compose_namespaceObject.useInstanceId)(POSITION_BLOCK_PROPS_REFERENCE);
35129  
35130    // Higher specificity to override defaults in editor UI.
35131    const positionSelector = `.wp-container-$id}.wp-container-$id}`;
35132  
35133    // Get CSS string for the current position values.
35134    let css;
35135    if (allowPositionStyles) {
35136      css = getPositionCSS({
35137        selector: positionSelector,
35138        style
35139      }) || '';
35140    }
35141  
35142    // Attach a `wp-container-` id-based class name.
35143    const className = dist_clsx({
35144      [`wp-container-$id}`]: allowPositionStyles && !!css,
35145      // Only attach a container class if there is generated CSS to be attached.
35146      [`is-position-$style?.position?.type}`]: allowPositionStyles && !!css && !!style?.position?.type
35147    });
35148    useStyleOverride({
35149      css
35150    });
35151    return {
35152      className
35153    };
35154  }
35155  
35156  ;// ./node_modules/@wordpress/block-editor/build-module/components/global-styles/use-global-styles-output.js
35157  /**
35158   * WordPress dependencies
35159   */
35160  
35161  
35162  
35163  
35164  
35165  
35166  /**
35167   * Internal dependencies
35168   */
35169  
35170  
35171  
35172  
35173  
35174  
35175  
35176  
35177  
35178  
35179  
35180  
35181  
35182  // Elements that rely on class names in their selectors.
35183  const ELEMENT_CLASS_NAMES = {
35184    button: 'wp-element-button',
35185    caption: 'wp-element-caption'
35186  };
35187  
35188  // List of block support features that can have their related styles
35189  // generated under their own feature level selector rather than the block's.
35190  const BLOCK_SUPPORT_FEATURE_LEVEL_SELECTORS = {
35191    __experimentalBorder: 'border',
35192    color: 'color',
35193    spacing: 'spacing',
35194    typography: 'typography'
35195  };
35196  const {
35197    kebabCase: use_global_styles_output_kebabCase
35198  } = unlock(external_wp_components_namespaceObject.privateApis);
35199  
35200  /**
35201   * Transform given preset tree into a set of style declarations.
35202   *
35203   * @param {Object} blockPresets
35204   * @param {Object} mergedSettings Merged theme.json settings.
35205   *
35206   * @return {Array<Object>} An array of style declarations.
35207   */
35208  function getPresetsDeclarations(blockPresets = {}, mergedSettings) {
35209    return PRESET_METADATA.reduce((declarations, {
35210      path,
35211      valueKey,
35212      valueFunc,
35213      cssVarInfix
35214    }) => {
35215      const presetByOrigin = getValueFromObjectPath(blockPresets, path, []);
35216      ['default', 'theme', 'custom'].forEach(origin => {
35217        if (presetByOrigin[origin]) {
35218          presetByOrigin[origin].forEach(value => {
35219            if (valueKey && !valueFunc) {
35220              declarations.push(`--wp--preset--$cssVarInfix}--$use_global_styles_output_kebabCase(value.slug)}: $value[valueKey]}`);
35221            } else if (valueFunc && typeof valueFunc === 'function') {
35222              declarations.push(`--wp--preset--$cssVarInfix}--$use_global_styles_output_kebabCase(value.slug)}: $valueFunc(value, mergedSettings)}`);
35223            }
35224          });
35225        }
35226      });
35227      return declarations;
35228    }, []);
35229  }
35230  
35231  /**
35232   * Transform given preset tree into a set of preset class declarations.
35233   *
35234   * @param {?string} blockSelector
35235   * @param {Object}  blockPresets
35236   * @return {string} CSS declarations for the preset classes.
35237   */
35238  function getPresetsClasses(blockSelector = '*', blockPresets = {}) {
35239    return PRESET_METADATA.reduce((declarations, {
35240      path,
35241      cssVarInfix,
35242      classes
35243    }) => {
35244      if (!classes) {
35245        return declarations;
35246      }
35247      const presetByOrigin = getValueFromObjectPath(blockPresets, path, []);
35248      ['default', 'theme', 'custom'].forEach(origin => {
35249        if (presetByOrigin[origin]) {
35250          presetByOrigin[origin].forEach(({
35251            slug
35252          }) => {
35253            classes.forEach(({
35254              classSuffix,
35255              propertyName
35256            }) => {
35257              const classSelectorToUse = `.has-$use_global_styles_output_kebabCase(slug)}-$classSuffix}`;
35258              const selectorToUse = blockSelector.split(',') // Selector can be "h1, h2, h3"
35259              .map(selector => `$selector}$classSelectorToUse}`).join(',');
35260              const value = `var(--wp--preset--$cssVarInfix}--$use_global_styles_output_kebabCase(slug)})`;
35261              declarations += `$selectorToUse}{$propertyName}: $value} !important;}`;
35262            });
35263          });
35264        }
35265      });
35266      return declarations;
35267    }, '');
35268  }
35269  function getPresetsSvgFilters(blockPresets = {}) {
35270    return PRESET_METADATA.filter(
35271    // Duotone are the only type of filters for now.
35272    metadata => metadata.path.at(-1) === 'duotone').flatMap(metadata => {
35273      const presetByOrigin = getValueFromObjectPath(blockPresets, metadata.path, {});
35274      return ['default', 'theme'].filter(origin => presetByOrigin[origin]).flatMap(origin => presetByOrigin[origin].map(preset => getDuotoneFilter(`wp-duotone-$preset.slug}`, preset.colors))).join('');
35275    });
35276  }
35277  function flattenTree(input = {}, prefix, token) {
35278    let result = [];
35279    Object.keys(input).forEach(key => {
35280      const newKey = prefix + use_global_styles_output_kebabCase(key.replace('/', '-'));
35281      const newLeaf = input[key];
35282      if (newLeaf instanceof Object) {
35283        const newPrefix = newKey + token;
35284        result = [...result, ...flattenTree(newLeaf, newPrefix, token)];
35285      } else {
35286        result.push(`$newKey}: $newLeaf}`);
35287      }
35288    });
35289    return result;
35290  }
35291  
35292  /**
35293   * Gets variation selector string from feature selector.
35294   *
35295   * @param {string} featureSelector        The feature selector.
35296   *
35297   * @param {string} styleVariationSelector The style variation selector.
35298   * @return {string} Combined selector string.
35299   */
35300  function concatFeatureVariationSelectorString(featureSelector, styleVariationSelector) {
35301    const featureSelectors = featureSelector.split(',');
35302    const combinedSelectors = [];
35303    featureSelectors.forEach(selector => {
35304      combinedSelectors.push(`$styleVariationSelector.trim()}$selector.trim()}`);
35305    });
35306    return combinedSelectors.join(', ');
35307  }
35308  
35309  /**
35310   * Generate style declarations for a block's custom feature and subfeature
35311   * selectors.
35312   *
35313   * NOTE: The passed `styles` object will be mutated by this function.
35314   *
35315   * @param {Object} selectors Custom selectors object for a block.
35316   * @param {Object} styles    A block's styles object.
35317   *
35318   * @return {Object} Style declarations.
35319   */
35320  const getFeatureDeclarations = (selectors, styles) => {
35321    const declarations = {};
35322    Object.entries(selectors).forEach(([feature, selector]) => {
35323      // We're only processing features/subfeatures that have styles.
35324      if (feature === 'root' || !styles?.[feature]) {
35325        return;
35326      }
35327      const isShorthand = typeof selector === 'string';
35328  
35329      // If we have a selector object instead of shorthand process it.
35330      if (!isShorthand) {
35331        Object.entries(selector).forEach(([subfeature, subfeatureSelector]) => {
35332          // Don't process root feature selector yet or any
35333          // subfeature that doesn't have a style.
35334          if (subfeature === 'root' || !styles?.[feature][subfeature]) {
35335            return;
35336          }
35337  
35338          // Create a temporary styles object and build
35339          // declarations for subfeature.
35340          const subfeatureStyles = {
35341            [feature]: {
35342              [subfeature]: styles[feature][subfeature]
35343            }
35344          };
35345          const newDeclarations = getStylesDeclarations(subfeatureStyles);
35346  
35347          // Merge new declarations in with any others that
35348          // share the same selector.
35349          declarations[subfeatureSelector] = [...(declarations[subfeatureSelector] || []), ...newDeclarations];
35350  
35351          // Remove the subfeature's style now it will be
35352          // included under its own selector not the block's.
35353          delete styles[feature][subfeature];
35354        });
35355      }
35356  
35357      // Now subfeatures have been processed and removed, we can
35358      // process root, or shorthand, feature selectors.
35359      if (isShorthand || selector.root) {
35360        const featureSelector = isShorthand ? selector : selector.root;
35361  
35362        // Create temporary style object and build declarations for feature.
35363        const featureStyles = {
35364          [feature]: styles[feature]
35365        };
35366        const newDeclarations = getStylesDeclarations(featureStyles);
35367  
35368        // Merge new declarations with any others that share the selector.
35369        declarations[featureSelector] = [...(declarations[featureSelector] || []), ...newDeclarations];
35370  
35371        // Remove the feature from the block's styles now as it will be
35372        // included under its own selector not the block's.
35373        delete styles[feature];
35374      }
35375    });
35376    return declarations;
35377  };
35378  
35379  /**
35380   * Transform given style tree into a set of style declarations.
35381   *
35382   * @param {Object}  blockStyles         Block styles.
35383   *
35384   * @param {string}  selector            The selector these declarations should attach to.
35385   *
35386   * @param {boolean} useRootPaddingAlign Whether to use CSS custom properties in root selector.
35387   *
35388   * @param {Object}  tree                A theme.json tree containing layout definitions.
35389   *
35390   * @param {boolean} disableRootPadding  Whether to force disable the root padding styles.
35391   * @return {Array} An array of style declarations.
35392   */
35393  function getStylesDeclarations(blockStyles = {}, selector = '', useRootPaddingAlign, tree = {}, disableRootPadding = false) {
35394    const isRoot = ROOT_BLOCK_SELECTOR === selector;
35395    const output = Object.entries(external_wp_blocks_namespaceObject.__EXPERIMENTAL_STYLE_PROPERTY).reduce((declarations, [key, {
35396      value,
35397      properties,
35398      useEngine,
35399      rootOnly
35400    }]) => {
35401      if (rootOnly && !isRoot) {
35402        return declarations;
35403      }
35404      const pathToValue = value;
35405      if (pathToValue[0] === 'elements' || useEngine) {
35406        return declarations;
35407      }
35408      const styleValue = getValueFromObjectPath(blockStyles, pathToValue);
35409  
35410      // Root-level padding styles don't currently support strings with CSS shorthand values.
35411      // This may change: https://github.com/WordPress/gutenberg/issues/40132.
35412      if (key === '--wp--style--root--padding' && (typeof styleValue === 'string' || !useRootPaddingAlign)) {
35413        return declarations;
35414      }
35415      if (properties && typeof styleValue !== 'string') {
35416        Object.entries(properties).forEach(entry => {
35417          const [name, prop] = entry;
35418          if (!getValueFromObjectPath(styleValue, [prop], false)) {
35419            // Do not create a declaration
35420            // for sub-properties that don't have any value.
35421            return;
35422          }
35423          const cssProperty = name.startsWith('--') ? name : use_global_styles_output_kebabCase(name);
35424          declarations.push(`$cssProperty}: ${(0,external_wp_styleEngine_namespaceObject.getCSSValueFromRawStyle)(getValueFromObjectPath(styleValue, [prop]))}`);
35425        });
35426      } else if (getValueFromObjectPath(blockStyles, pathToValue, false)) {
35427        const cssProperty = key.startsWith('--') ? key : use_global_styles_output_kebabCase(key);
35428        declarations.push(`$cssProperty}: ${(0,external_wp_styleEngine_namespaceObject.getCSSValueFromRawStyle)(getValueFromObjectPath(blockStyles, pathToValue))}`);
35429      }
35430      return declarations;
35431    }, []);
35432  
35433    /*
35434     * Preprocess background image values.
35435     *
35436     * Note: As we absorb more and more styles into the engine, we could simplify this function.
35437     * A refactor is for the style engine to handle ref resolution (and possibly defaults)
35438     * via a public util used internally and externally. Theme.json tree and defaults could be passed
35439     * as options.
35440     */
35441    if (!!blockStyles.background) {
35442      /*
35443       * Resolve dynamic values before they are compiled by the style engine,
35444       * which doesn't (yet) resolve dynamic values.
35445       */
35446      if (blockStyles.background?.backgroundImage) {
35447        blockStyles.background.backgroundImage = getResolvedValue(blockStyles.background.backgroundImage, tree);
35448      }
35449  
35450      /*
35451       * Set default values for block background styles.
35452       * Top-level styles are an exception as they are applied to the body.
35453       */
35454      if (!isRoot && !!blockStyles.background?.backgroundImage?.id) {
35455        blockStyles = {
35456          ...blockStyles,
35457          background: {
35458            ...blockStyles.background,
35459            ...setBackgroundStyleDefaults(blockStyles.background)
35460          }
35461        };
35462      }
35463    }
35464    const extraRules = (0,external_wp_styleEngine_namespaceObject.getCSSRules)(blockStyles);
35465    extraRules.forEach(rule => {
35466      // Don't output padding properties if padding variables are set or if we're not editing a full template.
35467      if (isRoot && (useRootPaddingAlign || disableRootPadding) && rule.key.startsWith('padding')) {
35468        return;
35469      }
35470      const cssProperty = rule.key.startsWith('--') ? rule.key : use_global_styles_output_kebabCase(rule.key);
35471      let ruleValue = getResolvedValue(rule.value, tree, null);
35472  
35473      // Calculate fluid typography rules where available.
35474      if (cssProperty === 'font-size') {
35475        /*
35476         * getTypographyFontSizeValue() will check
35477         * if fluid typography has been activated and also
35478         * whether the incoming value can be converted to a fluid value.
35479         * Values that already have a "clamp()" function will not pass the test,
35480         * and therefore the original $value will be returned.
35481         */
35482        ruleValue = getTypographyFontSizeValue({
35483          size: ruleValue
35484        }, tree?.settings);
35485      }
35486  
35487      // For aspect ratio to work, other dimensions rules (and Cover block defaults) must be unset.
35488      // This ensures that a fixed height does not override the aspect ratio.
35489      if (cssProperty === 'aspect-ratio') {
35490        output.push('min-height: unset');
35491      }
35492      output.push(`$cssProperty}: $ruleValue}`);
35493    });
35494    return output;
35495  }
35496  
35497  /**
35498   * Get generated CSS for layout styles by looking up layout definitions provided
35499   * in theme.json, and outputting common layout styles, and specific blockGap values.
35500   *
35501   * @param {Object}  props
35502   * @param {Object}  props.layoutDefinitions     Layout definitions, keyed by layout type.
35503   * @param {Object}  props.style                 A style object containing spacing values.
35504   * @param {string}  props.selector              Selector used to group together layout styling rules.
35505   * @param {boolean} props.hasBlockGapSupport    Whether or not the theme opts-in to blockGap support.
35506   * @param {boolean} props.hasFallbackGapSupport Whether or not the theme allows fallback gap styles.
35507   * @param {?string} props.fallbackGapValue      An optional fallback gap value if no real gap value is available.
35508   * @return {string} Generated CSS rules for the layout styles.
35509   */
35510  function getLayoutStyles({
35511    layoutDefinitions = LAYOUT_DEFINITIONS,
35512    style,
35513    selector,
35514    hasBlockGapSupport,
35515    hasFallbackGapSupport,
35516    fallbackGapValue
35517  }) {
35518    let ruleset = '';
35519    let gapValue = hasBlockGapSupport ? getGapCSSValue(style?.spacing?.blockGap) : '';
35520  
35521    // Ensure a fallback gap value for the root layout definitions,
35522    // and use a fallback value if one is provided for the current block.
35523    if (hasFallbackGapSupport) {
35524      if (selector === ROOT_BLOCK_SELECTOR) {
35525        gapValue = !gapValue ? '0.5em' : gapValue;
35526      } else if (!hasBlockGapSupport && fallbackGapValue) {
35527        gapValue = fallbackGapValue;
35528      }
35529    }
35530    if (gapValue && layoutDefinitions) {
35531      Object.values(layoutDefinitions).forEach(({
35532        className,
35533        name,
35534        spacingStyles
35535      }) => {
35536        // Allow outputting fallback gap styles for flex layout type when block gap support isn't available.
35537        if (!hasBlockGapSupport && 'flex' !== name && 'grid' !== name) {
35538          return;
35539        }
35540        if (spacingStyles?.length) {
35541          spacingStyles.forEach(spacingStyle => {
35542            const declarations = [];
35543            if (spacingStyle.rules) {
35544              Object.entries(spacingStyle.rules).forEach(([cssProperty, cssValue]) => {
35545                declarations.push(`$cssProperty}: $cssValue ? cssValue : gapValue}`);
35546              });
35547            }
35548            if (declarations.length) {
35549              let combinedSelector = '';
35550              if (!hasBlockGapSupport) {
35551                // For fallback gap styles, use lower specificity, to ensure styles do not unintentionally override theme styles.
35552                combinedSelector = selector === ROOT_BLOCK_SELECTOR ? `:where(.$className}$spacingStyle?.selector || ''})` : `:where($selector}.$className}$spacingStyle?.selector || ''})`;
35553              } else {
35554                combinedSelector = selector === ROOT_BLOCK_SELECTOR ? `:root :where(.$className})$spacingStyle?.selector || ''}` : `:root :where($selector}-$className})$spacingStyle?.selector || ''}`;
35555              }
35556              ruleset += `$combinedSelector} { $declarations.join('; ')}; }`;
35557            }
35558          });
35559        }
35560      });
35561      // For backwards compatibility, ensure the legacy block gap CSS variable is still available.
35562      if (selector === ROOT_BLOCK_SELECTOR && hasBlockGapSupport) {
35563        ruleset += `$ROOT_CSS_PROPERTIES_SELECTOR} { --wp--style--block-gap: $gapValue}; }`;
35564      }
35565    }
35566  
35567    // Output base styles
35568    if (selector === ROOT_BLOCK_SELECTOR && layoutDefinitions) {
35569      const validDisplayModes = ['block', 'flex', 'grid'];
35570      Object.values(layoutDefinitions).forEach(({
35571        className,
35572        displayMode,
35573        baseStyles
35574      }) => {
35575        if (displayMode && validDisplayModes.includes(displayMode)) {
35576          ruleset += `$selector} .$className} { display:$displayMode}; }`;
35577        }
35578        if (baseStyles?.length) {
35579          baseStyles.forEach(baseStyle => {
35580            const declarations = [];
35581            if (baseStyle.rules) {
35582              Object.entries(baseStyle.rules).forEach(([cssProperty, cssValue]) => {
35583                declarations.push(`$cssProperty}: $cssValue}`);
35584              });
35585            }
35586            if (declarations.length) {
35587              const combinedSelector = `.$className}$baseStyle?.selector || ''}`;
35588              ruleset += `$combinedSelector} { $declarations.join('; ')}; }`;
35589            }
35590          });
35591        }
35592      });
35593    }
35594    return ruleset;
35595  }
35596  const STYLE_KEYS = ['border', 'color', 'dimensions', 'spacing', 'typography', 'filter', 'outline', 'shadow', 'background'];
35597  function pickStyleKeys(treeToPickFrom) {
35598    if (!treeToPickFrom) {
35599      return {};
35600    }
35601    const entries = Object.entries(treeToPickFrom);
35602    const pickedEntries = entries.filter(([key]) => STYLE_KEYS.includes(key));
35603    // clone the style objects so that `getFeatureDeclarations` can remove consumed keys from it
35604    const clonedEntries = pickedEntries.map(([key, style]) => [key, JSON.parse(JSON.stringify(style))]);
35605    return Object.fromEntries(clonedEntries);
35606  }
35607  const getNodesWithStyles = (tree, blockSelectors) => {
35608    var _tree$styles$blocks;
35609    const nodes = [];
35610    if (!tree?.styles) {
35611      return nodes;
35612    }
35613  
35614    // Top-level.
35615    const styles = pickStyleKeys(tree.styles);
35616    if (styles) {
35617      nodes.push({
35618        styles,
35619        selector: ROOT_BLOCK_SELECTOR,
35620        // Root selector (body) styles should not be wrapped in `:root where()` to keep
35621        // specificity at (0,0,1) and maintain backwards compatibility.
35622        skipSelectorWrapper: true
35623      });
35624    }
35625    Object.entries(external_wp_blocks_namespaceObject.__EXPERIMENTAL_ELEMENTS).forEach(([name, selector]) => {
35626      if (tree.styles?.elements?.[name]) {
35627        nodes.push({
35628          styles: tree.styles?.elements?.[name],
35629          selector,
35630          // Top level elements that don't use a class name should not receive the
35631          // `:root :where()` wrapper to maintain backwards compatibility.
35632          skipSelectorWrapper: !ELEMENT_CLASS_NAMES[name]
35633        });
35634      }
35635    });
35636  
35637    // Iterate over blocks: they can have styles & elements.
35638    Object.entries((_tree$styles$blocks = tree.styles?.blocks) !== null && _tree$styles$blocks !== void 0 ? _tree$styles$blocks : {}).forEach(([blockName, node]) => {
35639      var _node$elements;
35640      const blockStyles = pickStyleKeys(node);
35641      if (node?.variations) {
35642        const variations = {};
35643        Object.entries(node.variations).forEach(([variationName, variation]) => {
35644          var _variation$elements, _variation$blocks;
35645          variations[variationName] = pickStyleKeys(variation);
35646          if (variation?.css) {
35647            variations[variationName].css = variation.css;
35648          }
35649          const variationSelector = blockSelectors[blockName]?.styleVariationSelectors?.[variationName];
35650  
35651          // Process the variation's inner element styles.
35652          // This comes before the inner block styles so the
35653          // element styles within the block type styles take
35654          // precedence over these.
35655          Object.entries((_variation$elements = variation?.elements) !== null && _variation$elements !== void 0 ? _variation$elements : {}).forEach(([element, elementStyles]) => {
35656            if (elementStyles && external_wp_blocks_namespaceObject.__EXPERIMENTAL_ELEMENTS[element]) {
35657              nodes.push({
35658                styles: elementStyles,
35659                selector: scopeSelector(variationSelector, external_wp_blocks_namespaceObject.__EXPERIMENTAL_ELEMENTS[element])
35660              });
35661            }
35662          });
35663  
35664          // Process the variations inner block type styles.
35665          Object.entries((_variation$blocks = variation?.blocks) !== null && _variation$blocks !== void 0 ? _variation$blocks : {}).forEach(([variationBlockName, variationBlockStyles]) => {
35666            var _variationBlockStyles;
35667            const variationBlockSelector = scopeSelector(variationSelector, blockSelectors[variationBlockName]?.selector);
35668            const variationDuotoneSelector = scopeSelector(variationSelector, blockSelectors[variationBlockName]?.duotoneSelector);
35669            const variationFeatureSelectors = scopeFeatureSelectors(variationSelector, blockSelectors[variationBlockName]?.featureSelectors);
35670            const variationBlockStyleNodes = pickStyleKeys(variationBlockStyles);
35671            if (variationBlockStyles?.css) {
35672              variationBlockStyleNodes.css = variationBlockStyles.css;
35673            }
35674            nodes.push({
35675              selector: variationBlockSelector,
35676              duotoneSelector: variationDuotoneSelector,
35677              featureSelectors: variationFeatureSelectors,
35678              fallbackGapValue: blockSelectors[variationBlockName]?.fallbackGapValue,
35679              hasLayoutSupport: blockSelectors[variationBlockName]?.hasLayoutSupport,
35680              styles: variationBlockStyleNodes
35681            });
35682  
35683            // Process element styles for the inner blocks
35684            // of the variation.
35685            Object.entries((_variationBlockStyles = variationBlockStyles.elements) !== null && _variationBlockStyles !== void 0 ? _variationBlockStyles : {}).forEach(([variationBlockElement, variationBlockElementStyles]) => {
35686              if (variationBlockElementStyles && external_wp_blocks_namespaceObject.__EXPERIMENTAL_ELEMENTS[variationBlockElement]) {
35687                nodes.push({
35688                  styles: variationBlockElementStyles,
35689                  selector: scopeSelector(variationBlockSelector, external_wp_blocks_namespaceObject.__EXPERIMENTAL_ELEMENTS[variationBlockElement])
35690                });
35691              }
35692            });
35693          });
35694        });
35695        blockStyles.variations = variations;
35696      }
35697      if (blockSelectors?.[blockName]?.selector) {
35698        nodes.push({
35699          duotoneSelector: blockSelectors[blockName].duotoneSelector,
35700          fallbackGapValue: blockSelectors[blockName].fallbackGapValue,
35701          hasLayoutSupport: blockSelectors[blockName].hasLayoutSupport,
35702          selector: blockSelectors[blockName].selector,
35703          styles: blockStyles,
35704          featureSelectors: blockSelectors[blockName].featureSelectors,
35705          styleVariationSelectors: blockSelectors[blockName].styleVariationSelectors
35706        });
35707      }
35708      Object.entries((_node$elements = node?.elements) !== null && _node$elements !== void 0 ? _node$elements : {}).forEach(([elementName, value]) => {
35709        if (value && blockSelectors?.[blockName] && external_wp_blocks_namespaceObject.__EXPERIMENTAL_ELEMENTS[elementName]) {
35710          nodes.push({
35711            styles: value,
35712            selector: blockSelectors[blockName]?.selector.split(',').map(sel => {
35713              const elementSelectors = external_wp_blocks_namespaceObject.__EXPERIMENTAL_ELEMENTS[elementName].split(',');
35714              return elementSelectors.map(elementSelector => sel + ' ' + elementSelector);
35715            }).join(',')
35716          });
35717        }
35718      });
35719    });
35720    return nodes;
35721  };
35722  const getNodesWithSettings = (tree, blockSelectors) => {
35723    var _tree$settings$blocks;
35724    const nodes = [];
35725    if (!tree?.settings) {
35726      return nodes;
35727    }
35728    const pickPresets = treeToPickFrom => {
35729      let presets = {};
35730      PRESET_METADATA.forEach(({
35731        path
35732      }) => {
35733        const value = getValueFromObjectPath(treeToPickFrom, path, false);
35734        if (value !== false) {
35735          presets = setImmutably(presets, path, value);
35736        }
35737      });
35738      return presets;
35739    };
35740  
35741    // Top-level.
35742    const presets = pickPresets(tree.settings);
35743    const custom = tree.settings?.custom;
35744    if (Object.keys(presets).length > 0 || custom) {
35745      nodes.push({
35746        presets,
35747        custom,
35748        selector: ROOT_CSS_PROPERTIES_SELECTOR
35749      });
35750    }
35751  
35752    // Blocks.
35753    Object.entries((_tree$settings$blocks = tree.settings?.blocks) !== null && _tree$settings$blocks !== void 0 ? _tree$settings$blocks : {}).forEach(([blockName, node]) => {
35754      const blockPresets = pickPresets(node);
35755      const blockCustom = node.custom;
35756      if (Object.keys(blockPresets).length > 0 || blockCustom) {
35757        nodes.push({
35758          presets: blockPresets,
35759          custom: blockCustom,
35760          selector: blockSelectors[blockName]?.selector
35761        });
35762      }
35763    });
35764    return nodes;
35765  };
35766  const toCustomProperties = (tree, blockSelectors) => {
35767    const settings = getNodesWithSettings(tree, blockSelectors);
35768    let ruleset = '';
35769    settings.forEach(({
35770      presets,
35771      custom,
35772      selector
35773    }) => {
35774      const declarations = getPresetsDeclarations(presets, tree?.settings);
35775      const customProps = flattenTree(custom, '--wp--custom--', '--');
35776      if (customProps.length > 0) {
35777        declarations.push(...customProps);
35778      }
35779      if (declarations.length > 0) {
35780        ruleset += `$selector}{$declarations.join(';')};}`;
35781      }
35782    });
35783    return ruleset;
35784  };
35785  const toStyles = (tree, blockSelectors, hasBlockGapSupport, hasFallbackGapSupport, disableLayoutStyles = false, disableRootPadding = false, styleOptions = undefined) => {
35786    // These allow opting out of certain sets of styles.
35787    const options = {
35788      blockGap: true,
35789      blockStyles: true,
35790      layoutStyles: true,
35791      marginReset: true,
35792      presets: true,
35793      rootPadding: true,
35794      variationStyles: false,
35795      ...styleOptions
35796    };
35797    const nodesWithStyles = getNodesWithStyles(tree, blockSelectors);
35798    const nodesWithSettings = getNodesWithSettings(tree, blockSelectors);
35799    const useRootPaddingAlign = tree?.settings?.useRootPaddingAwareAlignments;
35800    const {
35801      contentSize,
35802      wideSize
35803    } = tree?.settings?.layout || {};
35804    const hasBodyStyles = options.marginReset || options.rootPadding || options.layoutStyles;
35805    let ruleset = '';
35806    if (options.presets && (contentSize || wideSize)) {
35807      ruleset += `$ROOT_CSS_PROPERTIES_SELECTOR} {`;
35808      ruleset = contentSize ? ruleset + ` --wp--style--global--content-size: $contentSize};` : ruleset;
35809      ruleset = wideSize ? ruleset + ` --wp--style--global--wide-size: $wideSize};` : ruleset;
35810      ruleset += '}';
35811    }
35812    if (hasBodyStyles) {
35813      /*
35814       * Reset default browser margin on the body element.
35815       * This is set on the body selector **before** generating the ruleset
35816       * from the `theme.json`. This is to ensure that if the `theme.json` declares
35817       * `margin` in its `spacing` declaration for the `body` element then these
35818       * user-generated values take precedence in the CSS cascade.
35819       * @link https://github.com/WordPress/gutenberg/issues/36147.
35820       */
35821      ruleset += ':where(body) {margin: 0;';
35822  
35823      // Root padding styles should be output for full templates, patterns and template parts.
35824      if (options.rootPadding && useRootPaddingAlign) {
35825        /*
35826         * These rules reproduce the ones from https://github.com/WordPress/gutenberg/blob/79103f124925d1f457f627e154f52a56228ed5ad/lib/class-wp-theme-json-gutenberg.php#L2508
35827         * almost exactly, but for the selectors that target block wrappers in the front end. This code only runs in the editor, so it doesn't need those selectors.
35828         */
35829        ruleset += `padding-right: 0; padding-left: 0; padding-top: var(--wp--style--root--padding-top); padding-bottom: var(--wp--style--root--padding-bottom) }
35830                  .has-global-padding { padding-right: var(--wp--style--root--padding-right); padding-left: var(--wp--style--root--padding-left); }
35831                  .has-global-padding > .alignfull { margin-right: calc(var(--wp--style--root--padding-right) * -1); margin-left: calc(var(--wp--style--root--padding-left) * -1); }
35832                  .has-global-padding :where(:not(.alignfull.is-layout-flow) > .has-global-padding:not(.wp-block-block, .alignfull)) { padding-right: 0; padding-left: 0; }
35833                  .has-global-padding :where(:not(.alignfull.is-layout-flow) > .has-global-padding:not(.wp-block-block, .alignfull)) > .alignfull { margin-left: 0; margin-right: 0;
35834                  `;
35835      }
35836      ruleset += '}';
35837    }
35838    if (options.blockStyles) {
35839      nodesWithStyles.forEach(({
35840        selector,
35841        duotoneSelector,
35842        styles,
35843        fallbackGapValue,
35844        hasLayoutSupport,
35845        featureSelectors,
35846        styleVariationSelectors,
35847        skipSelectorWrapper
35848      }) => {
35849        // Process styles for block support features with custom feature level
35850        // CSS selectors set.
35851        if (featureSelectors) {
35852          const featureDeclarations = getFeatureDeclarations(featureSelectors, styles);
35853          Object.entries(featureDeclarations).forEach(([cssSelector, declarations]) => {
35854            if (declarations.length) {
35855              const rules = declarations.join(';');
35856              ruleset += `:root :where($cssSelector}){$rules};}`;
35857            }
35858          });
35859        }
35860  
35861        // Process duotone styles.
35862        if (duotoneSelector) {
35863          const duotoneStyles = {};
35864          if (styles?.filter) {
35865            duotoneStyles.filter = styles.filter;
35866            delete styles.filter;
35867          }
35868          const duotoneDeclarations = getStylesDeclarations(duotoneStyles);
35869          if (duotoneDeclarations.length) {
35870            ruleset += `$duotoneSelector}{$duotoneDeclarations.join(';')};}`;
35871          }
35872        }
35873  
35874        // Process blockGap and layout styles.
35875        if (!disableLayoutStyles && (ROOT_BLOCK_SELECTOR === selector || hasLayoutSupport)) {
35876          ruleset += getLayoutStyles({
35877            style: styles,
35878            selector,
35879            hasBlockGapSupport,
35880            hasFallbackGapSupport,
35881            fallbackGapValue
35882          });
35883        }
35884  
35885        // Process the remaining block styles (they use either normal block class or __experimentalSelector).
35886        const styleDeclarations = getStylesDeclarations(styles, selector, useRootPaddingAlign, tree, disableRootPadding);
35887        if (styleDeclarations?.length) {
35888          const generalSelector = skipSelectorWrapper ? selector : `:root :where($selector})`;
35889          ruleset += `$generalSelector}{$styleDeclarations.join(';')};}`;
35890        }
35891        if (styles?.css) {
35892          ruleset += processCSSNesting(styles.css, `:root :where($selector})`);
35893        }
35894        if (options.variationStyles && styleVariationSelectors) {
35895          Object.entries(styleVariationSelectors).forEach(([styleVariationName, styleVariationSelector]) => {
35896            const styleVariations = styles?.variations?.[styleVariationName];
35897            if (styleVariations) {
35898              // If the block uses any custom selectors for block support, add those first.
35899              if (featureSelectors) {
35900                const featureDeclarations = getFeatureDeclarations(featureSelectors, styleVariations);
35901                Object.entries(featureDeclarations).forEach(([baseSelector, declarations]) => {
35902                  if (declarations.length) {
35903                    const cssSelector = concatFeatureVariationSelectorString(baseSelector, styleVariationSelector);
35904                    const rules = declarations.join(';');
35905                    ruleset += `:root :where($cssSelector}){$rules};}`;
35906                  }
35907                });
35908              }
35909  
35910              // Otherwise add regular selectors.
35911              const styleVariationDeclarations = getStylesDeclarations(styleVariations, styleVariationSelector, useRootPaddingAlign, tree);
35912              if (styleVariationDeclarations.length) {
35913                ruleset += `:root :where($styleVariationSelector}){$styleVariationDeclarations.join(';')};}`;
35914              }
35915              if (styleVariations?.css) {
35916                ruleset += processCSSNesting(styleVariations.css, `:root :where($styleVariationSelector})`);
35917              }
35918            }
35919          });
35920        }
35921  
35922        // Check for pseudo selector in `styles` and handle separately.
35923        const pseudoSelectorStyles = Object.entries(styles).filter(([key]) => key.startsWith(':'));
35924        if (pseudoSelectorStyles?.length) {
35925          pseudoSelectorStyles.forEach(([pseudoKey, pseudoStyle]) => {
35926            const pseudoDeclarations = getStylesDeclarations(pseudoStyle);
35927            if (!pseudoDeclarations?.length) {
35928              return;
35929            }
35930  
35931            // `selector` may be provided in a form
35932            // where block level selectors have sub element
35933            // selectors appended to them as a comma separated
35934            // string.
35935            // e.g. `h1 a,h2 a,h3 a,h4 a,h5 a,h6 a`;
35936            // Split and append pseudo selector to create
35937            // the proper rules to target the elements.
35938            const _selector = selector.split(',').map(sel => sel + pseudoKey).join(',');
35939  
35940            // As pseudo classes such as :hover, :focus etc. have class-level
35941            // specificity, they must use the `:root :where()` wrapper. This.
35942            // caps the specificity at `0-1-0` to allow proper nesting of variations
35943            // and block type element styles.
35944            const pseudoRule = `:root :where($_selector}){$pseudoDeclarations.join(';')};}`;
35945            ruleset += pseudoRule;
35946          });
35947        }
35948      });
35949    }
35950    if (options.layoutStyles) {
35951      /* Add alignment / layout styles */
35952      ruleset = ruleset + '.wp-site-blocks > .alignleft { float: left; margin-right: 2em; }';
35953      ruleset = ruleset + '.wp-site-blocks > .alignright { float: right; margin-left: 2em; }';
35954      ruleset = ruleset + '.wp-site-blocks > .aligncenter { justify-content: center; margin-left: auto; margin-right: auto; }';
35955    }
35956    if (options.blockGap && hasBlockGapSupport) {
35957      // Use fallback of `0.5em` just in case, however if there is blockGap support, there should nearly always be a real value.
35958      const gapValue = getGapCSSValue(tree?.styles?.spacing?.blockGap) || '0.5em';
35959      ruleset = ruleset + `:root :where(.wp-site-blocks) > * { margin-block-start: $gapValue}; margin-block-end: 0; }`;
35960      ruleset = ruleset + ':root :where(.wp-site-blocks) > :first-child { margin-block-start: 0; }';
35961      ruleset = ruleset + ':root :where(.wp-site-blocks) > :last-child { margin-block-end: 0; }';
35962    }
35963    if (options.presets) {
35964      nodesWithSettings.forEach(({
35965        selector,
35966        presets
35967      }) => {
35968        if (ROOT_BLOCK_SELECTOR === selector || ROOT_CSS_PROPERTIES_SELECTOR === selector) {
35969          // Do not add extra specificity for top-level classes.
35970          selector = '';
35971        }
35972        const classes = getPresetsClasses(selector, presets);
35973        if (classes.length > 0) {
35974          ruleset += classes;
35975        }
35976      });
35977    }
35978    return ruleset;
35979  };
35980  function toSvgFilters(tree, blockSelectors) {
35981    const nodesWithSettings = getNodesWithSettings(tree, blockSelectors);
35982    return nodesWithSettings.flatMap(({
35983      presets
35984    }) => {
35985      return getPresetsSvgFilters(presets);
35986    });
35987  }
35988  const getSelectorsConfig = (blockType, rootSelector) => {
35989    if (blockType?.selectors && Object.keys(blockType.selectors).length > 0) {
35990      return blockType.selectors;
35991    }
35992    const config = {
35993      root: rootSelector
35994    };
35995    Object.entries(BLOCK_SUPPORT_FEATURE_LEVEL_SELECTORS).forEach(([featureKey, featureName]) => {
35996      const featureSelector = getBlockCSSSelector(blockType, featureKey);
35997      if (featureSelector) {
35998        config[featureName] = featureSelector;
35999      }
36000    });
36001    return config;
36002  };
36003  const getBlockSelectors = (blockTypes, getBlockStyles, variationInstanceId) => {
36004    const result = {};
36005    blockTypes.forEach(blockType => {
36006      const name = blockType.name;
36007      const selector = getBlockCSSSelector(blockType);
36008      let duotoneSelector = getBlockCSSSelector(blockType, 'filter.duotone');
36009  
36010      // Keep backwards compatibility for support.color.__experimentalDuotone.
36011      if (!duotoneSelector) {
36012        const rootSelector = getBlockCSSSelector(blockType);
36013        const duotoneSupport = (0,external_wp_blocks_namespaceObject.getBlockSupport)(blockType, 'color.__experimentalDuotone', false);
36014        duotoneSelector = duotoneSupport && scopeSelector(rootSelector, duotoneSupport);
36015      }
36016      const hasLayoutSupport = !!blockType?.supports?.layout || !!blockType?.supports?.__experimentalLayout;
36017      const fallbackGapValue = blockType?.supports?.spacing?.blockGap?.__experimentalDefault;
36018      const blockStyleVariations = getBlockStyles(name);
36019      const styleVariationSelectors = {};
36020      blockStyleVariations?.forEach(variation => {
36021        const variationSuffix = variationInstanceId ? `-$variationInstanceId}` : '';
36022        const variationName = `$variation.name}$variationSuffix}`;
36023        const styleVariationSelector = getBlockStyleVariationSelector(variationName, selector);
36024        styleVariationSelectors[variationName] = styleVariationSelector;
36025      });
36026  
36027      // For each block support feature add any custom selectors.
36028      const featureSelectors = getSelectorsConfig(blockType, selector);
36029      result[name] = {
36030        duotoneSelector,
36031        fallbackGapValue,
36032        featureSelectors: Object.keys(featureSelectors).length ? featureSelectors : undefined,
36033        hasLayoutSupport,
36034        name,
36035        selector,
36036        styleVariationSelectors: blockStyleVariations?.length ? styleVariationSelectors : undefined
36037      };
36038    });
36039    return result;
36040  };
36041  
36042  /**
36043   * If there is a separator block whose color is defined in theme.json via background,
36044   * update the separator color to the same value by using border color.
36045   *
36046   * @param {Object} config Theme.json configuration file object.
36047   * @return {Object} configTheme.json configuration file object updated.
36048   */
36049  function updateConfigWithSeparator(config) {
36050    const needsSeparatorStyleUpdate = config.styles?.blocks?.['core/separator'] && config.styles?.blocks?.['core/separator'].color?.background && !config.styles?.blocks?.['core/separator'].color?.text && !config.styles?.blocks?.['core/separator'].border?.color;
36051    if (needsSeparatorStyleUpdate) {
36052      return {
36053        ...config,
36054        styles: {
36055          ...config.styles,
36056          blocks: {
36057            ...config.styles.blocks,
36058            'core/separator': {
36059              ...config.styles.blocks['core/separator'],
36060              color: {
36061                ...config.styles.blocks['core/separator'].color,
36062                text: config.styles?.blocks['core/separator'].color.background
36063              }
36064            }
36065          }
36066        }
36067      };
36068    }
36069    return config;
36070  }
36071  function processCSSNesting(css, blockSelector) {
36072    let processedCSS = '';
36073    if (!css || css.trim() === '') {
36074      return processedCSS;
36075    }
36076  
36077    // Split CSS nested rules.
36078    const parts = css.split('&');
36079    parts.forEach(part => {
36080      if (!part || part.trim() === '') {
36081        return;
36082      }
36083      const isRootCss = !part.includes('{');
36084      if (isRootCss) {
36085        // If the part doesn't contain braces, it applies to the root level.
36086        processedCSS += `:root :where($blockSelector}){$part.trim()}}`;
36087      } else {
36088        // If the part contains braces, it's a nested CSS rule.
36089        const splitPart = part.replace('}', '').split('{');
36090        if (splitPart.length !== 2) {
36091          return;
36092        }
36093        const [nestedSelector, cssValue] = splitPart;
36094  
36095        // Handle pseudo elements such as ::before, ::after, etc. Regex will also
36096        // capture any leading combinator such as >, +, or ~, as well as spaces.
36097        // This allows pseudo elements as descendants e.g. `.parent ::before`.
36098        const matches = nestedSelector.match(/([>+~\s]*::[a-zA-Z-]+)/);
36099        const pseudoPart = matches ? matches[1] : '';
36100        const withoutPseudoElement = matches ? nestedSelector.replace(pseudoPart, '').trim() : nestedSelector.trim();
36101        let combinedSelector;
36102        if (withoutPseudoElement === '') {
36103          // Only contained a pseudo element to use the block selector to form
36104          // the final `:root :where()` selector.
36105          combinedSelector = blockSelector;
36106        } else {
36107          // If the nested selector is a descendant of the block scope it with the
36108          // block selector. Otherwise append it to the block selector.
36109          combinedSelector = nestedSelector.startsWith(' ') ? scopeSelector(blockSelector, withoutPseudoElement) : appendToSelector(blockSelector, withoutPseudoElement);
36110        }
36111  
36112        // Build final rule, re-adding any pseudo element outside the `:where()`
36113        // to maintain valid CSS selector.
36114        processedCSS += `:root :where($combinedSelector})$pseudoPart}{$cssValue.trim()}}`;
36115      }
36116    });
36117    return processedCSS;
36118  }
36119  
36120  /**
36121   * Returns the global styles output using a global styles configuration.
36122   * If wishing to generate global styles and settings based on the
36123   * global styles config loaded in the editor context, use `useGlobalStylesOutput()`.
36124   * The use case for a custom config is to generate bespoke styles
36125   * and settings for previews, or other out-of-editor experiences.
36126   *
36127   * @param {Object}  mergedConfig       Global styles configuration.
36128   * @param {boolean} disableRootPadding Disable root padding styles.
36129   *
36130   * @return {Array} Array of stylesheets and settings.
36131   */
36132  function useGlobalStylesOutputWithConfig(mergedConfig = {}, disableRootPadding) {
36133    const [blockGap] = useGlobalSetting('spacing.blockGap');
36134    const hasBlockGapSupport = blockGap !== null;
36135    const hasFallbackGapSupport = !hasBlockGapSupport; // This setting isn't useful yet: it exists as a placeholder for a future explicit fallback styles support.
36136    const disableLayoutStyles = (0,external_wp_data_namespaceObject.useSelect)(select => {
36137      const {
36138        getSettings
36139      } = select(store);
36140      return !!getSettings().disableLayoutStyles;
36141    });
36142    const {
36143      getBlockStyles
36144    } = (0,external_wp_data_namespaceObject.useSelect)(external_wp_blocks_namespaceObject.store);
36145    return (0,external_wp_element_namespaceObject.useMemo)(() => {
36146      var _updatedConfig$styles;
36147      if (!mergedConfig?.styles || !mergedConfig?.settings) {
36148        return [];
36149      }
36150      const updatedConfig = updateConfigWithSeparator(mergedConfig);
36151      const blockSelectors = getBlockSelectors((0,external_wp_blocks_namespaceObject.getBlockTypes)(), getBlockStyles);
36152      const customProperties = toCustomProperties(updatedConfig, blockSelectors);
36153      const globalStyles = toStyles(updatedConfig, blockSelectors, hasBlockGapSupport, hasFallbackGapSupport, disableLayoutStyles, disableRootPadding);
36154      const svgs = toSvgFilters(updatedConfig, blockSelectors);
36155      const styles = [{
36156        css: customProperties,
36157        isGlobalStyles: true
36158      }, {
36159        css: globalStyles,
36160        isGlobalStyles: true
36161      },
36162      // Load custom CSS in own stylesheet so that any invalid CSS entered in the input won't break all the global styles in the editor.
36163      {
36164        css: (_updatedConfig$styles = updatedConfig.styles.css) !== null && _updatedConfig$styles !== void 0 ? _updatedConfig$styles : '',
36165        isGlobalStyles: true
36166      }, {
36167        assets: svgs,
36168        __unstableType: 'svg',
36169        isGlobalStyles: true
36170      }];
36171  
36172      // Loop through the blocks to check if there are custom CSS values.
36173      // If there are, get the block selector and push the selector together with
36174      // the CSS value to the 'stylesheets' array.
36175      (0,external_wp_blocks_namespaceObject.getBlockTypes)().forEach(blockType => {
36176        if (updatedConfig.styles.blocks[blockType.name]?.css) {
36177          const selector = blockSelectors[blockType.name].selector;
36178          styles.push({
36179            css: processCSSNesting(updatedConfig.styles.blocks[blockType.name]?.css, selector),
36180            isGlobalStyles: true
36181          });
36182        }
36183      });
36184      return [styles, updatedConfig.settings];
36185    }, [hasBlockGapSupport, hasFallbackGapSupport, mergedConfig, disableLayoutStyles, disableRootPadding, getBlockStyles]);
36186  }
36187  
36188  /**
36189   * Returns the global styles output based on the current state of global styles config loaded in the editor context.
36190   *
36191   * @param {boolean} disableRootPadding Disable root padding styles.
36192   *
36193   * @return {Array} Array of stylesheets and settings.
36194   */
36195  function useGlobalStylesOutput(disableRootPadding = false) {
36196    const {
36197      merged: mergedConfig
36198    } = (0,external_wp_element_namespaceObject.useContext)(GlobalStylesContext);
36199    return useGlobalStylesOutputWithConfig(mergedConfig, disableRootPadding);
36200  }
36201  
36202  ;// ./node_modules/@wordpress/block-editor/build-module/hooks/block-style-variation.js
36203  /**
36204   * WordPress dependencies
36205   */
36206  
36207  
36208  
36209  
36210  /**
36211   * Internal dependencies
36212   */
36213  
36214  
36215  
36216  
36217  
36218  
36219  
36220  const VARIATION_PREFIX = 'is-style-';
36221  function getVariationMatches(className) {
36222    if (!className) {
36223      return [];
36224    }
36225    return className.split(/\s+/).reduce((matches, name) => {
36226      if (name.startsWith(VARIATION_PREFIX)) {
36227        const match = name.slice(VARIATION_PREFIX.length);
36228        if (match !== 'default') {
36229          matches.push(match);
36230        }
36231      }
36232      return matches;
36233    }, []);
36234  }
36235  
36236  /**
36237   * Get the first block style variation that has been registered from the class string.
36238   *
36239   * @param {string} className        CSS class string for a block.
36240   * @param {Array}  registeredStyles Currently registered block styles.
36241   *
36242   * @return {string|null} The name of the first registered variation.
36243   */
36244  function getVariationNameFromClass(className, registeredStyles = []) {
36245    // The global flag affects how capturing groups work in JS. So the regex
36246    // below will only return full CSS classes not just the variation name.
36247    const matches = getVariationMatches(className);
36248    if (!matches) {
36249      return null;
36250    }
36251    for (const variation of matches) {
36252      if (registeredStyles.some(style => style.name === variation)) {
36253        return variation;
36254      }
36255    }
36256    return null;
36257  }
36258  
36259  // A helper component to apply a style override using the useStyleOverride hook.
36260  function OverrideStyles({
36261    override
36262  }) {
36263    usePrivateStyleOverride(override);
36264  }
36265  
36266  /**
36267   * This component is used to generate new block style variation overrides
36268   * based on an incoming theme config. If a matching style is found in the config,
36269   * a new override is created and returned. The overrides can be used in conjunction with
36270   * useStyleOverride to apply the new styles to the editor. Its use is
36271   * subject to change.
36272   *
36273   * @param {Object} props        Props.
36274   * @param {Object} props.config A global styles object, containing settings and styles.
36275   * @return {JSX.Element|undefined} An array of new block variation overrides.
36276   */
36277  function __unstableBlockStyleVariationOverridesWithConfig({
36278    config
36279  }) {
36280    const {
36281      getBlockStyles,
36282      overrides
36283    } = (0,external_wp_data_namespaceObject.useSelect)(select => ({
36284      getBlockStyles: select(external_wp_blocks_namespaceObject.store).getBlockStyles,
36285      overrides: unlock(select(store)).getStyleOverrides()
36286    }), []);
36287    const {
36288      getBlockName
36289    } = (0,external_wp_data_namespaceObject.useSelect)(store);
36290    const overridesWithConfig = (0,external_wp_element_namespaceObject.useMemo)(() => {
36291      if (!overrides?.length) {
36292        return;
36293      }
36294      const newOverrides = [];
36295      const overriddenClientIds = [];
36296      for (const [, override] of overrides) {
36297        if (override?.variation && override?.clientId &&
36298        /*
36299         * Because this component overwrites existing style overrides,
36300         * filter out any overrides that are already present in the store.
36301         */
36302        !overriddenClientIds.includes(override.clientId)) {
36303          const blockName = getBlockName(override.clientId);
36304          const configStyles = config?.styles?.blocks?.[blockName]?.variations?.[override.variation];
36305          if (configStyles) {
36306            const variationConfig = {
36307              settings: config?.settings,
36308              // The variation style data is all that is needed to generate
36309              // the styles for the current application to a block. The variation
36310              // name is updated to match the instance specific class name.
36311              styles: {
36312                blocks: {
36313                  [blockName]: {
36314                    variations: {
36315                      [`$override.variation}-$override.clientId}`]: configStyles
36316                    }
36317                  }
36318                }
36319              }
36320            };
36321            const blockSelectors = getBlockSelectors((0,external_wp_blocks_namespaceObject.getBlockTypes)(), getBlockStyles, override.clientId);
36322            const hasBlockGapSupport = false;
36323            const hasFallbackGapSupport = true;
36324            const disableLayoutStyles = true;
36325            const disableRootPadding = true;
36326            const variationStyles = toStyles(variationConfig, blockSelectors, hasBlockGapSupport, hasFallbackGapSupport, disableLayoutStyles, disableRootPadding, {
36327              blockGap: false,
36328              blockStyles: true,
36329              layoutStyles: false,
36330              marginReset: false,
36331              presets: false,
36332              rootPadding: false,
36333              variationStyles: true
36334            });
36335            newOverrides.push({
36336              id: `$override.variation}-$override.clientId}`,
36337              css: variationStyles,
36338              __unstableType: 'variation',
36339              variation: override.variation,
36340              // The clientId will be stored with the override and used to ensure
36341              // the order of overrides matches the order of blocks so that the
36342              // correct CSS cascade is maintained.
36343              clientId: override.clientId
36344            });
36345            overriddenClientIds.push(override.clientId);
36346          }
36347        }
36348      }
36349      return newOverrides;
36350    }, [config, overrides, getBlockStyles, getBlockName]);
36351    if (!overridesWithConfig || !overridesWithConfig.length) {
36352      return;
36353    }
36354    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_ReactJSXRuntime_namespaceObject.Fragment, {
36355      children: overridesWithConfig.map(override => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(OverrideStyles, {
36356        override: override
36357      }, override.id))
36358    });
36359  }
36360  
36361  /**
36362   * Retrieves any variation styles data and resolves any referenced values.
36363   *
36364   * @param {Object}    globalStyles A complete global styles object, containing settings and styles.
36365   * @param {string}    name         The name of the desired block type.
36366   * @param {variation} variation    The of the block style variation to retrieve data for.
36367   *
36368   * @return {Object|undefined} The global styles data for the specified variation.
36369   */
36370  function getVariationStylesWithRefValues(globalStyles, name, variation) {
36371    if (!globalStyles?.styles?.blocks?.[name]?.variations?.[variation]) {
36372      return;
36373    }
36374  
36375    // Helper to recursively look for `ref` values to resolve.
36376    const replaceRefs = variationStyles => {
36377      Object.keys(variationStyles).forEach(key => {
36378        const value = variationStyles[key];
36379  
36380        // Only process objects.
36381        if (typeof value === 'object' && value !== null) {
36382          // Process `ref` value if present.
36383          if (value.ref !== undefined) {
36384            if (typeof value.ref !== 'string' || value.ref.trim() === '') {
36385              // Remove invalid ref.
36386              delete variationStyles[key];
36387            } else {
36388              // Resolve `ref` value.
36389              const refValue = getValueFromObjectPath(globalStyles, value.ref);
36390              if (refValue) {
36391                variationStyles[key] = refValue;
36392              } else {
36393                delete variationStyles[key];
36394              }
36395            }
36396          } else {
36397            // Recursively resolve `ref` values in nested objects.
36398            replaceRefs(value);
36399  
36400            // After recursion, if value is empty due to explicitly
36401            // `undefined` ref value, remove it.
36402            if (Object.keys(value).length === 0) {
36403              delete variationStyles[key];
36404            }
36405          }
36406        }
36407      });
36408    };
36409  
36410    // Deep clone variation node to avoid mutating it within global styles and losing refs.
36411    const styles = JSON.parse(JSON.stringify(globalStyles.styles.blocks[name].variations[variation]));
36412    replaceRefs(styles);
36413    return styles;
36414  }
36415  function useBlockStyleVariation(name, variation, clientId) {
36416    // Prefer global styles data in GlobalStylesContext, which are available
36417    // if in the site editor. Otherwise fall back to whatever is in the
36418    // editor settings and available in the post editor.
36419    const {
36420      merged: mergedConfig
36421    } = (0,external_wp_element_namespaceObject.useContext)(GlobalStylesContext);
36422    const {
36423      globalSettings,
36424      globalStyles
36425    } = (0,external_wp_data_namespaceObject.useSelect)(select => {
36426      const settings = select(store).getSettings();
36427      return {
36428        globalSettings: settings.__experimentalFeatures,
36429        globalStyles: settings[globalStylesDataKey]
36430      };
36431    }, []);
36432    return (0,external_wp_element_namespaceObject.useMemo)(() => {
36433      var _mergedConfig$setting, _mergedConfig$styles, _mergedConfig$setting2;
36434      const variationStyles = getVariationStylesWithRefValues({
36435        settings: (_mergedConfig$setting = mergedConfig?.settings) !== null && _mergedConfig$setting !== void 0 ? _mergedConfig$setting : globalSettings,
36436        styles: (_mergedConfig$styles = mergedConfig?.styles) !== null && _mergedConfig$styles !== void 0 ? _mergedConfig$styles : globalStyles
36437      }, name, variation);
36438      return {
36439        settings: (_mergedConfig$setting2 = mergedConfig?.settings) !== null && _mergedConfig$setting2 !== void 0 ? _mergedConfig$setting2 : globalSettings,
36440        // The variation style data is all that is needed to generate
36441        // the styles for the current application to a block. The variation
36442        // name is updated to match the instance specific class name.
36443        styles: {
36444          blocks: {
36445            [name]: {
36446              variations: {
36447                [`$variation}-$clientId}`]: variationStyles
36448              }
36449            }
36450          }
36451        }
36452      };
36453    }, [mergedConfig, globalSettings, globalStyles, variation, clientId, name]);
36454  }
36455  
36456  // Rather than leveraging `useInstanceId` here, the `clientId` is used.
36457  // This is so that the variation style override's ID is predictable
36458  // when the order of applied style variations changes.
36459  function block_style_variation_useBlockProps({
36460    name,
36461    className,
36462    clientId
36463  }) {
36464    const {
36465      getBlockStyles
36466    } = (0,external_wp_data_namespaceObject.useSelect)(external_wp_blocks_namespaceObject.store);
36467    const registeredStyles = getBlockStyles(name);
36468    const variation = getVariationNameFromClass(className, registeredStyles);
36469    const variationClass = `$VARIATION_PREFIX}$variation}-$clientId}`;
36470    const {
36471      settings,
36472      styles
36473    } = useBlockStyleVariation(name, variation, clientId);
36474    const variationStyles = (0,external_wp_element_namespaceObject.useMemo)(() => {
36475      if (!variation) {
36476        return;
36477      }
36478      const variationConfig = {
36479        settings,
36480        styles
36481      };
36482      const blockSelectors = getBlockSelectors((0,external_wp_blocks_namespaceObject.getBlockTypes)(), getBlockStyles, clientId);
36483      const hasBlockGapSupport = false;
36484      const hasFallbackGapSupport = true;
36485      const disableLayoutStyles = true;
36486      const disableRootPadding = true;
36487      return toStyles(variationConfig, blockSelectors, hasBlockGapSupport, hasFallbackGapSupport, disableLayoutStyles, disableRootPadding, {
36488        blockGap: false,
36489        blockStyles: true,
36490        layoutStyles: false,
36491        marginReset: false,
36492        presets: false,
36493        rootPadding: false,
36494        variationStyles: true
36495      });
36496    }, [variation, settings, styles, getBlockStyles, clientId]);
36497    usePrivateStyleOverride({
36498      id: `variation-$clientId}`,
36499      css: variationStyles,
36500      __unstableType: 'variation',
36501      variation,
36502      // The clientId will be stored with the override and used to ensure
36503      // the order of overrides matches the order of blocks so that the
36504      // correct CSS cascade is maintained.
36505      clientId
36506    });
36507    return variation ? {
36508      className: variationClass
36509    } : {};
36510  }
36511  /* harmony default export */ const block_style_variation = ({
36512    hasSupport: () => true,
36513    attributeKeys: ['className'],
36514    isMatch: ({
36515      className
36516    }) => getVariationMatches(className).length > 0,
36517    useBlockProps: block_style_variation_useBlockProps
36518  });
36519  
36520  ;// ./node_modules/@wordpress/block-editor/build-module/hooks/layout.js
36521  /**
36522   * External dependencies
36523   */
36524  
36525  
36526  /**
36527   * WordPress dependencies
36528   */
36529  
36530  
36531  
36532  
36533  
36534  
36535  
36536  /**
36537   * Internal dependencies
36538   */
36539  
36540  
36541  
36542  
36543  
36544  
36545  
36546  
36547  
36548  const layoutBlockSupportKey = 'layout';
36549  const {
36550    kebabCase: layout_kebabCase
36551  } = unlock(external_wp_components_namespaceObject.privateApis);
36552  function hasLayoutBlockSupport(blockName) {
36553    return (0,external_wp_blocks_namespaceObject.hasBlockSupport)(blockName, 'layout') || (0,external_wp_blocks_namespaceObject.hasBlockSupport)(blockName, '__experimentalLayout');
36554  }
36555  
36556  /**
36557   * Generates the utility classnames for the given block's layout attributes.
36558   *
36559   * @param { Object } blockAttributes Block attributes.
36560   * @param { string } blockName       Block name.
36561   *
36562   * @return { Array } Array of CSS classname strings.
36563   */
36564  function useLayoutClasses(blockAttributes = {}, blockName = '') {
36565    const {
36566      layout
36567    } = blockAttributes;
36568    const {
36569      default: defaultBlockLayout
36570    } = (0,external_wp_blocks_namespaceObject.getBlockSupport)(blockName, layoutBlockSupportKey) || {};
36571    const usedLayout = layout?.inherit || layout?.contentSize || layout?.wideSize ? {
36572      ...layout,
36573      type: 'constrained'
36574    } : layout || defaultBlockLayout || {};
36575    const layoutClassnames = [];
36576    if (LAYOUT_DEFINITIONS[usedLayout?.type || 'default']?.className) {
36577      const baseClassName = LAYOUT_DEFINITIONS[usedLayout?.type || 'default']?.className;
36578      const splitBlockName = blockName.split('/');
36579      const fullBlockName = splitBlockName[0] === 'core' ? splitBlockName.pop() : splitBlockName.join('-');
36580      const compoundClassName = `wp-block-$fullBlockName}-$baseClassName}`;
36581      layoutClassnames.push(baseClassName, compoundClassName);
36582    }
36583    const hasGlobalPadding = (0,external_wp_data_namespaceObject.useSelect)(select => {
36584      return (usedLayout?.inherit || usedLayout?.contentSize || usedLayout?.type === 'constrained') && select(store).getSettings().__experimentalFeatures?.useRootPaddingAwareAlignments;
36585    }, [usedLayout?.contentSize, usedLayout?.inherit, usedLayout?.type]);
36586    if (hasGlobalPadding) {
36587      layoutClassnames.push('has-global-padding');
36588    }
36589    if (usedLayout?.orientation) {
36590      layoutClassnames.push(`is-$layout_kebabCase(usedLayout.orientation)}`);
36591    }
36592    if (usedLayout?.justifyContent) {
36593      layoutClassnames.push(`is-content-justification-$layout_kebabCase(usedLayout.justifyContent)}`);
36594    }
36595    if (usedLayout?.flexWrap && usedLayout.flexWrap === 'nowrap') {
36596      layoutClassnames.push('is-nowrap');
36597    }
36598    return layoutClassnames;
36599  }
36600  
36601  /**
36602   * Generates a CSS rule with the given block's layout styles.
36603   *
36604   * @param { Object } blockAttributes Block attributes.
36605   * @param { string } blockName       Block name.
36606   * @param { string } selector        A selector to use in generating the CSS rule.
36607   *
36608   * @return { string } CSS rule.
36609   */
36610  function useLayoutStyles(blockAttributes = {}, blockName, selector) {
36611    const {
36612      layout = {},
36613      style = {}
36614    } = blockAttributes;
36615    // Update type for blocks using legacy layouts.
36616    const usedLayout = layout?.inherit || layout?.contentSize || layout?.wideSize ? {
36617      ...layout,
36618      type: 'constrained'
36619    } : layout || {};
36620    const fullLayoutType = getLayoutType(usedLayout?.type || 'default');
36621    const [blockGapSupport] = use_settings_useSettings('spacing.blockGap');
36622    const hasBlockGapSupport = blockGapSupport !== null;
36623    return fullLayoutType?.getLayoutStyle?.({
36624      blockName,
36625      selector,
36626      layout,
36627      style,
36628      hasBlockGapSupport
36629    });
36630  }
36631  function LayoutPanelPure({
36632    layout,
36633    setAttributes,
36634    name: blockName,
36635    clientId
36636  }) {
36637    const settings = useBlockSettings(blockName);
36638    // Block settings come from theme.json under settings.[blockName].
36639    const {
36640      layout: layoutSettings
36641    } = settings;
36642    const {
36643      themeSupportsLayout
36644    } = (0,external_wp_data_namespaceObject.useSelect)(select => {
36645      const {
36646        getSettings
36647      } = select(store);
36648      return {
36649        themeSupportsLayout: getSettings().supportsLayout
36650      };
36651    }, []);
36652    const blockEditingMode = useBlockEditingMode();
36653    if (blockEditingMode !== 'default') {
36654      return null;
36655    }
36656  
36657    // Layout block support comes from the block's block.json.
36658    const layoutBlockSupport = (0,external_wp_blocks_namespaceObject.getBlockSupport)(blockName, layoutBlockSupportKey, {});
36659    const blockSupportAndThemeSettings = {
36660      ...layoutSettings,
36661      ...layoutBlockSupport
36662    };
36663    const {
36664      allowSwitching,
36665      allowEditing = true,
36666      allowInheriting = true,
36667      default: defaultBlockLayout
36668    } = blockSupportAndThemeSettings;
36669    if (!allowEditing) {
36670      return null;
36671    }
36672  
36673    /*
36674     * Try to find the layout type from either the
36675     * block's layout settings or any saved layout config.
36676     */
36677    const blockSupportAndLayout = {
36678      ...layoutBlockSupport,
36679      ...layout
36680    };
36681    const {
36682      type,
36683      default: {
36684        type: defaultType = 'default'
36685      } = {}
36686    } = blockSupportAndLayout;
36687    const blockLayoutType = type || defaultType;
36688  
36689    // Only show the inherit toggle if it's supported,
36690    // and either the default / flow or the constrained layout type is in use, as the toggle switches from one to the other.
36691    const showInheritToggle = !!(allowInheriting && (!blockLayoutType || blockLayoutType === 'default' || blockLayoutType === 'constrained' || blockSupportAndLayout.inherit));
36692    const usedLayout = layout || defaultBlockLayout || {};
36693    const {
36694      inherit = false,
36695      contentSize = null
36696    } = usedLayout;
36697    /**
36698     * `themeSupportsLayout` is only relevant to the `default/flow` or
36699     * `constrained` layouts and it should not be taken into account when other
36700     * `layout` types are used.
36701     */
36702    if ((blockLayoutType === 'default' || blockLayoutType === 'constrained') && !themeSupportsLayout) {
36703      return null;
36704    }
36705    const layoutType = getLayoutType(blockLayoutType);
36706    const constrainedType = getLayoutType('constrained');
36707    const displayControlsForLegacyLayouts = !usedLayout.type && (contentSize || inherit);
36708    const hasContentSizeOrLegacySettings = !!inherit || !!contentSize;
36709    const onChangeType = newType => setAttributes({
36710      layout: {
36711        type: newType
36712      }
36713    });
36714    const onChangeLayout = newLayout => setAttributes({
36715      layout: newLayout
36716    });
36717    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
36718      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls, {
36719        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.PanelBody, {
36720          title: (0,external_wp_i18n_namespaceObject.__)('Layout'),
36721          children: [showInheritToggle && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_ReactJSXRuntime_namespaceObject.Fragment, {
36722            children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToggleControl, {
36723              __nextHasNoMarginBottom: true,
36724              label: (0,external_wp_i18n_namespaceObject.__)('Inner blocks use content width'),
36725              checked: layoutType?.name === 'constrained' || hasContentSizeOrLegacySettings,
36726              onChange: () => setAttributes({
36727                layout: {
36728                  type: layoutType?.name === 'constrained' || hasContentSizeOrLegacySettings ? 'default' : 'constrained'
36729                }
36730              }),
36731              help: layoutType?.name === 'constrained' || hasContentSizeOrLegacySettings ? (0,external_wp_i18n_namespaceObject.__)('Nested blocks use content width with options for full and wide widths.') : (0,external_wp_i18n_namespaceObject.__)('Nested blocks will fill the width of this container.')
36732            })
36733          }), !inherit && allowSwitching && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(LayoutTypeSwitcher, {
36734            type: blockLayoutType,
36735            onChange: onChangeType
36736          }), layoutType && layoutType.name !== 'default' && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(layoutType.inspectorControls, {
36737            layout: usedLayout,
36738            onChange: onChangeLayout,
36739            layoutBlockSupport: blockSupportAndThemeSettings,
36740            name: blockName,
36741            clientId: clientId
36742          }), constrainedType && displayControlsForLegacyLayouts && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(constrainedType.inspectorControls, {
36743            layout: usedLayout,
36744            onChange: onChangeLayout,
36745            layoutBlockSupport: blockSupportAndThemeSettings,
36746            name: blockName,
36747            clientId: clientId
36748          })]
36749        })
36750      }), !inherit && layoutType && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(layoutType.toolBarControls, {
36751        layout: usedLayout,
36752        onChange: onChangeLayout,
36753        layoutBlockSupport: layoutBlockSupport,
36754        name: blockName,
36755        clientId: clientId
36756      })]
36757    });
36758  }
36759  /* harmony default export */ const layout = ({
36760    shareWithChildBlocks: true,
36761    edit: LayoutPanelPure,
36762    attributeKeys: ['layout'],
36763    hasSupport(name) {
36764      return hasLayoutBlockSupport(name);
36765    }
36766  });
36767  function LayoutTypeSwitcher({
36768    type,
36769    onChange
36770  }) {
36771    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControl, {
36772      __next40pxDefaultSize: true,
36773      isBlock: true,
36774      label: (0,external_wp_i18n_namespaceObject.__)('Layout type'),
36775      __nextHasNoMarginBottom: true,
36776      hideLabelFromVision: true,
36777      isAdaptiveWidth: true,
36778      value: type,
36779      onChange: onChange,
36780      children: getLayoutTypes().map(({
36781        name,
36782        label
36783      }) => {
36784        return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControlOption, {
36785          value: name,
36786          label: label
36787        }, name);
36788      })
36789    });
36790  }
36791  
36792  /**
36793   * Filters registered block settings, extending attributes to include `layout`.
36794   *
36795   * @param {Object} settings Original block settings.
36796   *
36797   * @return {Object} Filtered block settings.
36798   */
36799  function layout_addAttribute(settings) {
36800    var _settings$attributes$;
36801    if ('type' in ((_settings$attributes$ = settings.attributes?.layout) !== null && _settings$attributes$ !== void 0 ? _settings$attributes$ : {})) {
36802      return settings;
36803    }
36804    if (hasLayoutBlockSupport(settings)) {
36805      settings.attributes = {
36806        ...settings.attributes,
36807        layout: {
36808          type: 'object'
36809        }
36810      };
36811    }
36812    return settings;
36813  }
36814  function BlockWithLayoutStyles({
36815    block: BlockListBlock,
36816    props,
36817    blockGapSupport,
36818    layoutClasses
36819  }) {
36820    const {
36821      name,
36822      attributes
36823    } = props;
36824    const id = (0,external_wp_compose_namespaceObject.useInstanceId)(BlockListBlock);
36825    const {
36826      layout
36827    } = attributes;
36828    const {
36829      default: defaultBlockLayout
36830    } = (0,external_wp_blocks_namespaceObject.getBlockSupport)(name, layoutBlockSupportKey) || {};
36831    const usedLayout = layout?.inherit || layout?.contentSize || layout?.wideSize ? {
36832      ...layout,
36833      type: 'constrained'
36834    } : layout || defaultBlockLayout || {};
36835    const selectorPrefix = `wp-container-$layout_kebabCase(name)}-is-layout-`;
36836    // Higher specificity to override defaults from theme.json.
36837    const selector = `.$selectorPrefix}$id}`;
36838    const hasBlockGapSupport = blockGapSupport !== null;
36839  
36840    // Get CSS string for the current layout type.
36841    // The CSS and `style` element is only output if it is not empty.
36842    const fullLayoutType = getLayoutType(usedLayout?.type || 'default');
36843    const css = fullLayoutType?.getLayoutStyle?.({
36844      blockName: name,
36845      selector,
36846      layout: usedLayout,
36847      style: attributes?.style,
36848      hasBlockGapSupport
36849    });
36850  
36851    // Attach a `wp-container-` id-based class name as well as a layout class name such as `is-layout-flex`.
36852    const layoutClassNames = dist_clsx({
36853      [`$selectorPrefix}$id}`]: !!css // Only attach a container class if there is generated CSS to be attached.
36854    }, layoutClasses);
36855    useStyleOverride({
36856      css
36857    });
36858    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockListBlock, {
36859      ...props,
36860      __unstableLayoutClassNames: layoutClassNames
36861    });
36862  }
36863  
36864  /**
36865   * Override the default block element to add the layout styles.
36866   *
36867   * @param {Function} BlockListBlock Original component.
36868   *
36869   * @return {Function} Wrapped component.
36870   */
36871  const withLayoutStyles = (0,external_wp_compose_namespaceObject.createHigherOrderComponent)(BlockListBlock => props => {
36872    const {
36873      clientId,
36874      name,
36875      attributes
36876    } = props;
36877    const blockSupportsLayout = hasLayoutBlockSupport(name);
36878    const layoutClasses = useLayoutClasses(attributes, name);
36879    const extraProps = (0,external_wp_data_namespaceObject.useSelect)(select => {
36880      // The callback returns early to avoid block editor subscription.
36881      if (!blockSupportsLayout) {
36882        return;
36883      }
36884      const {
36885        getSettings,
36886        getBlockSettings
36887      } = unlock(select(store));
36888      const {
36889        disableLayoutStyles
36890      } = getSettings();
36891      if (disableLayoutStyles) {
36892        return;
36893      }
36894      const [blockGapSupport] = getBlockSettings(clientId, 'spacing.blockGap');
36895      return {
36896        blockGapSupport
36897      };
36898    }, [blockSupportsLayout, clientId]);
36899    if (!extraProps) {
36900      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockListBlock, {
36901        ...props,
36902        __unstableLayoutClassNames: blockSupportsLayout ? layoutClasses : undefined
36903      });
36904    }
36905    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockWithLayoutStyles, {
36906      block: BlockListBlock,
36907      props: props,
36908      layoutClasses: layoutClasses,
36909      ...extraProps
36910    });
36911  }, 'withLayoutStyles');
36912  (0,external_wp_hooks_namespaceObject.addFilter)('blocks.registerBlockType', 'core/layout/addAttribute', layout_addAttribute);
36913  (0,external_wp_hooks_namespaceObject.addFilter)('editor.BlockListBlock', 'core/editor/layout/with-layout-styles', withLayoutStyles);
36914  
36915  ;// ./node_modules/@wordpress/block-editor/build-module/components/grid/utils.js
36916  function range(start, length) {
36917    return Array.from({
36918      length
36919    }, (_, i) => start + i);
36920  }
36921  class GridRect {
36922    constructor({
36923      columnStart,
36924      rowStart,
36925      columnEnd,
36926      rowEnd,
36927      columnSpan,
36928      rowSpan
36929    } = {}) {
36930      this.columnStart = columnStart !== null && columnStart !== void 0 ? columnStart : 1;
36931      this.rowStart = rowStart !== null && rowStart !== void 0 ? rowStart : 1;
36932      if (columnSpan !== undefined) {
36933        this.columnEnd = this.columnStart + columnSpan - 1;
36934      } else {
36935        this.columnEnd = columnEnd !== null && columnEnd !== void 0 ? columnEnd : this.columnStart;
36936      }
36937      if (rowSpan !== undefined) {
36938        this.rowEnd = this.rowStart + rowSpan - 1;
36939      } else {
36940        this.rowEnd = rowEnd !== null && rowEnd !== void 0 ? rowEnd : this.rowStart;
36941      }
36942    }
36943    get columnSpan() {
36944      return this.columnEnd - this.columnStart + 1;
36945    }
36946    get rowSpan() {
36947      return this.rowEnd - this.rowStart + 1;
36948    }
36949    contains(column, row) {
36950      return column >= this.columnStart && column <= this.columnEnd && row >= this.rowStart && row <= this.rowEnd;
36951    }
36952    containsRect(rect) {
36953      return this.contains(rect.columnStart, rect.rowStart) && this.contains(rect.columnEnd, rect.rowEnd);
36954    }
36955    intersectsRect(rect) {
36956      return this.columnStart <= rect.columnEnd && this.columnEnd >= rect.columnStart && this.rowStart <= rect.rowEnd && this.rowEnd >= rect.rowStart;
36957    }
36958  }
36959  function utils_getComputedCSS(element, property) {
36960    return element.ownerDocument.defaultView.getComputedStyle(element).getPropertyValue(property);
36961  }
36962  
36963  /**
36964   * Given a grid-template-columns or grid-template-rows CSS property value, gets the start and end
36965   * position in pixels of each grid track.
36966   *
36967   * https://css-tricks.com/snippets/css/complete-guide-grid/#aa-grid-track
36968   *
36969   * @param {string} template The grid-template-columns or grid-template-rows CSS property value.
36970   *                          Only supports fixed sizes in pixels.
36971   * @param {number} gap      The gap between grid tracks in pixels.
36972   *
36973   * @return {Array<{start: number, end: number}>} An array of objects with the start and end
36974   *                                               position in pixels of each grid track.
36975   */
36976  function getGridTracks(template, gap) {
36977    const tracks = [];
36978    for (const size of template.split(' ')) {
36979      const previousTrack = tracks[tracks.length - 1];
36980      const start = previousTrack ? previousTrack.end + gap : 0;
36981      const end = start + parseFloat(size);
36982      tracks.push({
36983        start,
36984        end
36985      });
36986    }
36987    return tracks;
36988  }
36989  
36990  /**
36991   * Given an array of grid tracks and a position in pixels, gets the index of the closest track to
36992   * that position.
36993   *
36994   * https://css-tricks.com/snippets/css/complete-guide-grid/#aa-grid-track
36995   *
36996   * @param {Array<{start: number, end: number}>} tracks   An array of objects with the start and end
36997   *                                                       position in pixels of each grid track.
36998   * @param {number}                              position The position in pixels.
36999   * @param {string}                              edge     The edge of the track to compare the
37000   *                                                       position to. Either 'start' or 'end'.
37001   *
37002   * @return {number} The index of the closest track to the position. 0-based, unlike CSS grid which
37003   *                  is 1-based.
37004   */
37005  function getClosestTrack(tracks, position, edge = 'start') {
37006    return tracks.reduce((closest, track, index) => Math.abs(track[edge] - position) < Math.abs(tracks[closest][edge] - position) ? index : closest, 0);
37007  }
37008  function getGridRect(gridElement, rect) {
37009    const columnGap = parseFloat(utils_getComputedCSS(gridElement, 'column-gap'));
37010    const rowGap = parseFloat(utils_getComputedCSS(gridElement, 'row-gap'));
37011    const gridColumnTracks = getGridTracks(utils_getComputedCSS(gridElement, 'grid-template-columns'), columnGap);
37012    const gridRowTracks = getGridTracks(utils_getComputedCSS(gridElement, 'grid-template-rows'), rowGap);
37013    const columnStart = getClosestTrack(gridColumnTracks, rect.left) + 1;
37014    const rowStart = getClosestTrack(gridRowTracks, rect.top) + 1;
37015    const columnEnd = getClosestTrack(gridColumnTracks, rect.right, 'end') + 1;
37016    const rowEnd = getClosestTrack(gridRowTracks, rect.bottom, 'end') + 1;
37017    return new GridRect({
37018      columnStart,
37019      columnEnd,
37020      rowStart,
37021      rowEnd
37022    });
37023  }
37024  function getGridItemRect(gridItemElement) {
37025    return getGridRect(gridItemElement.parentElement, new window.DOMRect(gridItemElement.offsetLeft, gridItemElement.offsetTop, gridItemElement.offsetWidth, gridItemElement.offsetHeight));
37026  }
37027  function getGridInfo(gridElement) {
37028    const gridTemplateColumns = utils_getComputedCSS(gridElement, 'grid-template-columns');
37029    const gridTemplateRows = utils_getComputedCSS(gridElement, 'grid-template-rows');
37030    const borderTopWidth = utils_getComputedCSS(gridElement, 'border-top-width');
37031    const borderRightWidth = utils_getComputedCSS(gridElement, 'border-right-width');
37032    const borderBottomWidth = utils_getComputedCSS(gridElement, 'border-bottom-width');
37033    const borderLeftWidth = utils_getComputedCSS(gridElement, 'border-left-width');
37034    const paddingTop = utils_getComputedCSS(gridElement, 'padding-top');
37035    const paddingRight = utils_getComputedCSS(gridElement, 'padding-right');
37036    const paddingBottom = utils_getComputedCSS(gridElement, 'padding-bottom');
37037    const paddingLeft = utils_getComputedCSS(gridElement, 'padding-left');
37038    const numColumns = gridTemplateColumns.split(' ').length;
37039    const numRows = gridTemplateRows.split(' ').length;
37040    const numItems = numColumns * numRows;
37041    return {
37042      numColumns,
37043      numRows,
37044      numItems,
37045      currentColor: utils_getComputedCSS(gridElement, 'color'),
37046      style: {
37047        gridTemplateColumns,
37048        gridTemplateRows,
37049        gap: utils_getComputedCSS(gridElement, 'gap'),
37050        inset: `
37051                  calc($paddingTop} + $borderTopWidth})
37052                  calc($paddingRight} + $borderRightWidth})
37053                  calc($paddingBottom} + $borderBottomWidth})
37054                  calc($paddingLeft} + $borderLeftWidth})
37055              `
37056      }
37057    };
37058  }
37059  
37060  ;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/tips.js
37061  /**
37062   * WordPress dependencies
37063   */
37064  
37065  
37066  
37067  
37068  const globalTips = [(0,external_wp_element_namespaceObject.createInterpolateElement)((0,external_wp_i18n_namespaceObject.__)('While writing, you can press <kbd>/</kbd> to quickly insert new blocks.'), {
37069    kbd: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("kbd", {})
37070  }), (0,external_wp_element_namespaceObject.createInterpolateElement)((0,external_wp_i18n_namespaceObject.__)('Indent a list by pressing <kbd>space</kbd> at the beginning of a line.'), {
37071    kbd: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("kbd", {})
37072  }), (0,external_wp_element_namespaceObject.createInterpolateElement)((0,external_wp_i18n_namespaceObject.__)('Outdent a list by pressing <kbd>backspace</kbd> at the beginning of a line.'), {
37073    kbd: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("kbd", {})
37074  }), (0,external_wp_i18n_namespaceObject.__)('Drag files into the editor to automatically insert media blocks.'), (0,external_wp_i18n_namespaceObject.__)("Change a block's type by pressing the block icon on the toolbar.")];
37075  function Tips() {
37076    const [randomIndex] = (0,external_wp_element_namespaceObject.useState)(
37077    // Disable Reason: I'm not generating an HTML id.
37078    // eslint-disable-next-line no-restricted-syntax
37079    Math.floor(Math.random() * globalTips.length));
37080    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Tip, {
37081      children: globalTips[randomIndex]
37082    });
37083  }
37084  /* harmony default export */ const tips = (Tips);
37085  
37086  ;// ./node_modules/@wordpress/icons/build-module/library/chevron-right.js
37087  /**
37088   * WordPress dependencies
37089   */
37090  
37091  
37092  const chevronRight = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
37093    xmlns: "http://www.w3.org/2000/svg",
37094    viewBox: "0 0 24 24",
37095    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
37096      d: "M10.6 6L9.4 7l4.6 5-4.6 5 1.2 1 5.4-6z"
37097    })
37098  });
37099  /* harmony default export */ const chevron_right = (chevronRight);
37100  
37101  ;// ./node_modules/@wordpress/icons/build-module/library/chevron-left.js
37102  /**
37103   * WordPress dependencies
37104   */
37105  
37106  
37107  const chevronLeft = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
37108    xmlns: "http://www.w3.org/2000/svg",
37109    viewBox: "0 0 24 24",
37110    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
37111      d: "M14.6 7l-1.2-1L8 12l5.4 6 1.2-1-4.6-5z"
37112    })
37113  });
37114  /* harmony default export */ const chevron_left = (chevronLeft);
37115  
37116  ;// ./node_modules/@wordpress/icons/build-module/library/block-default.js
37117  /**
37118   * WordPress dependencies
37119   */
37120  
37121  
37122  const blockDefault = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
37123    xmlns: "http://www.w3.org/2000/svg",
37124    viewBox: "0 0 24 24",
37125    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
37126      d: "M19 8h-1V6h-5v2h-2V6H6v2H5c-1.1 0-2 .9-2 2v8c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2v-8c0-1.1-.9-2-2-2zm.5 10c0 .3-.2.5-.5.5H5c-.3 0-.5-.2-.5-.5v-8c0-.3.2-.5.5-.5h14c.3 0 .5.2.5.5v8z"
37127    })
37128  });
37129  /* harmony default export */ const block_default = (blockDefault);
37130  
37131  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-icon/index.js
37132  /**
37133   * External dependencies
37134   */
37135  
37136  
37137  /**
37138   * WordPress dependencies
37139   */
37140  
37141  
37142  
37143  
37144  function BlockIcon({
37145    icon,
37146    showColors = false,
37147    className,
37148    context
37149  }) {
37150    if (icon?.src === 'block-default') {
37151      icon = {
37152        src: block_default
37153      };
37154    }
37155    const renderedIcon = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Icon, {
37156      icon: icon && icon.src ? icon.src : icon,
37157      context: context
37158    });
37159    const style = showColors ? {
37160      backgroundColor: icon && icon.background,
37161      color: icon && icon.foreground
37162    } : {};
37163    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("span", {
37164      style: style,
37165      className: dist_clsx('block-editor-block-icon', className, {
37166        'has-colors': showColors
37167      }),
37168      children: renderedIcon
37169    });
37170  }
37171  
37172  /**
37173   * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/block-icon/README.md
37174   */
37175  /* harmony default export */ const block_icon = ((0,external_wp_element_namespaceObject.memo)(BlockIcon));
37176  
37177  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-card/index.js
37178  /**
37179   * External dependencies
37180   */
37181  
37182  
37183  /**
37184   * WordPress dependencies
37185   */
37186  
37187  
37188  
37189  
37190  
37191  
37192  /**
37193   * Internal dependencies
37194   */
37195  
37196  
37197  
37198  
37199  const {
37200    Badge
37201  } = unlock(external_wp_components_namespaceObject.privateApis);
37202  
37203  /**
37204   * A card component that displays block information including title, icon, and description.
37205   * Can be used to show block metadata and navigation controls for parent blocks.
37206   *
37207   * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/block-card/README.md
37208   *
37209   * @example
37210   * ```jsx
37211   * function Example() {
37212   *   return (
37213   *     <BlockCard
37214   *       title="My Block"
37215   *       icon="smiley"
37216   *       description="A simple block example"
37217   *       name="Custom Block"
37218   *     />
37219   *   );
37220   * }
37221   * ```
37222   *
37223   * @param {Object}        props             Component props.
37224   * @param {string}        props.title       The title of the block.
37225   * @param {string|Object} props.icon        The icon of the block. This can be any of [WordPress' Dashicons](https://developer.wordpress.org/resource/dashicons/), or a custom `svg` element.
37226   * @param {string}        props.description The description of the block.
37227   * @param {Object}        [props.blockType] Deprecated: Object containing block type data.
37228   * @param {string}        [props.className] Additional classes to apply to the card.
37229   * @param {string}        [props.name]      Custom block name to display before the title.
37230   * @return {Element}                        Block card component.
37231   */
37232  function BlockCard({
37233    title,
37234    icon,
37235    description,
37236    blockType,
37237    className,
37238    name
37239  }) {
37240    if (blockType) {
37241      external_wp_deprecated_default()('`blockType` property in `BlockCard component`', {
37242        since: '5.7',
37243        alternative: '`title, icon and description` properties'
37244      });
37245      ({
37246        title,
37247        icon,
37248        description
37249      } = blockType);
37250    }
37251    const {
37252      parentNavBlockClientId
37253    } = (0,external_wp_data_namespaceObject.useSelect)(select => {
37254      const {
37255        getSelectedBlockClientId,
37256        getBlockParentsByBlockName
37257      } = select(store);
37258      const _selectedBlockClientId = getSelectedBlockClientId();
37259      return {
37260        parentNavBlockClientId: getBlockParentsByBlockName(_selectedBlockClientId, 'core/navigation', true)[0]
37261      };
37262    }, []);
37263    const {
37264      selectBlock
37265    } = (0,external_wp_data_namespaceObject.useDispatch)(store);
37266    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
37267      className: dist_clsx('block-editor-block-card', className),
37268      children: [parentNavBlockClientId &&
37269      /*#__PURE__*/
37270      // This is only used by the Navigation block for now. It's not ideal having Navigation block specific code here.
37271      (0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
37272        onClick: () => selectBlock(parentNavBlockClientId),
37273        label: (0,external_wp_i18n_namespaceObject.__)('Go to parent Navigation block'),
37274        style:
37275        // TODO: This style override is also used in ToolsPanelHeader.
37276        // It should be supported out-of-the-box by Button.
37277        {
37278          minWidth: 24,
37279          padding: 0
37280        },
37281        icon: (0,external_wp_i18n_namespaceObject.isRTL)() ? chevron_right : chevron_left,
37282        size: "small"
37283      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_icon, {
37284        icon: icon,
37285        showColors: true
37286      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalVStack, {
37287        spacing: 1,
37288        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("h2", {
37289          className: "block-editor-block-card__title",
37290          children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("span", {
37291            className: "block-editor-block-card__name",
37292            children: !!name?.length ? name : title
37293          }), !!name?.length && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Badge, {
37294            children: title
37295          })]
37296        }), description && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalText, {
37297          className: "block-editor-block-card__description",
37298          children: description
37299        })]
37300      })]
37301    });
37302  }
37303  /* harmony default export */ const block_card = (BlockCard);
37304  
37305  ;// ./node_modules/@wordpress/upload-media/build-module/store/types.js
37306  let Type = /*#__PURE__*/function (Type) {
37307    Type["Unknown"] = "REDUX_UNKNOWN";
37308    Type["Add"] = "ADD_ITEM";
37309    Type["Prepare"] = "PREPARE_ITEM";
37310    Type["Cancel"] = "CANCEL_ITEM";
37311    Type["Remove"] = "REMOVE_ITEM";
37312    Type["PauseItem"] = "PAUSE_ITEM";
37313    Type["ResumeItem"] = "RESUME_ITEM";
37314    Type["PauseQueue"] = "PAUSE_QUEUE";
37315    Type["ResumeQueue"] = "RESUME_QUEUE";
37316    Type["OperationStart"] = "OPERATION_START";
37317    Type["OperationFinish"] = "OPERATION_FINISH";
37318    Type["AddOperations"] = "ADD_OPERATIONS";
37319    Type["CacheBlobUrl"] = "CACHE_BLOB_URL";
37320    Type["RevokeBlobUrls"] = "REVOKE_BLOB_URLS";
37321    Type["UpdateSettings"] = "UPDATE_SETTINGS";
37322    return Type;
37323  }({});
37324  
37325  // Must match the Attachment type from the media-utils package.
37326  
37327  let ItemStatus = /*#__PURE__*/function (ItemStatus) {
37328    ItemStatus["Processing"] = "PROCESSING";
37329    ItemStatus["Paused"] = "PAUSED";
37330    return ItemStatus;
37331  }({});
37332  let OperationType = /*#__PURE__*/function (OperationType) {
37333    OperationType["Prepare"] = "PREPARE";
37334    OperationType["Upload"] = "UPLOAD";
37335    return OperationType;
37336  }({});
37337  
37338  ;// ./node_modules/@wordpress/upload-media/build-module/store/reducer.js
37339  /**
37340   * Internal dependencies
37341   */
37342  
37343  const reducer_noop = () => {};
37344  const DEFAULT_STATE = {
37345    queue: [],
37346    queueStatus: 'active',
37347    blobUrls: {},
37348    settings: {
37349      mediaUpload: reducer_noop
37350    }
37351  };
37352  function reducer_reducer(state = DEFAULT_STATE, action = {
37353    type: Type.Unknown
37354  }) {
37355    switch (action.type) {
37356      case Type.PauseQueue:
37357        {
37358          return {
37359            ...state,
37360            queueStatus: 'paused'
37361          };
37362        }
37363      case Type.ResumeQueue:
37364        {
37365          return {
37366            ...state,
37367            queueStatus: 'active'
37368          };
37369        }
37370      case Type.Add:
37371        return {
37372          ...state,
37373          queue: [...state.queue, action.item]
37374        };
37375      case Type.Cancel:
37376        return {
37377          ...state,
37378          queue: state.queue.map(item => item.id === action.id ? {
37379            ...item,
37380            error: action.error
37381          } : item)
37382        };
37383      case Type.Remove:
37384        return {
37385          ...state,
37386          queue: state.queue.filter(item => item.id !== action.id)
37387        };
37388      case Type.OperationStart:
37389        {
37390          return {
37391            ...state,
37392            queue: state.queue.map(item => item.id === action.id ? {
37393              ...item,
37394              currentOperation: action.operation
37395            } : item)
37396          };
37397        }
37398      case Type.AddOperations:
37399        return {
37400          ...state,
37401          queue: state.queue.map(item => {
37402            if (item.id !== action.id) {
37403              return item;
37404            }
37405            return {
37406              ...item,
37407              operations: [...(item.operations || []), ...action.operations]
37408            };
37409          })
37410        };
37411      case Type.OperationFinish:
37412        return {
37413          ...state,
37414          queue: state.queue.map(item => {
37415            if (item.id !== action.id) {
37416              return item;
37417            }
37418            const operations = item.operations ? item.operations.slice(1) : [];
37419  
37420            // Prevent an empty object if there's no attachment data.
37421            const attachment = item.attachment || action.item.attachment ? {
37422              ...item.attachment,
37423              ...action.item.attachment
37424            } : undefined;
37425            return {
37426              ...item,
37427              currentOperation: undefined,
37428              operations,
37429              ...action.item,
37430              attachment,
37431              additionalData: {
37432                ...item.additionalData,
37433                ...action.item.additionalData
37434              }
37435            };
37436          })
37437        };
37438      case Type.CacheBlobUrl:
37439        {
37440          const blobUrls = state.blobUrls[action.id] || [];
37441          return {
37442            ...state,
37443            blobUrls: {
37444              ...state.blobUrls,
37445              [action.id]: [...blobUrls, action.blobUrl]
37446            }
37447          };
37448        }
37449      case Type.RevokeBlobUrls:
37450        {
37451          const newBlobUrls = {
37452            ...state.blobUrls
37453          };
37454          delete newBlobUrls[action.id];
37455          return {
37456            ...state,
37457            blobUrls: newBlobUrls
37458          };
37459        }
37460      case Type.UpdateSettings:
37461        {
37462          return {
37463            ...state,
37464            settings: {
37465              ...state.settings,
37466              ...action.settings
37467            }
37468          };
37469        }
37470    }
37471    return state;
37472  }
37473  /* harmony default export */ const store_reducer = (reducer_reducer);
37474  
37475  ;// ./node_modules/@wordpress/upload-media/build-module/store/selectors.js
37476  /**
37477   * Internal dependencies
37478   */
37479  
37480  /**
37481   * Returns all items currently being uploaded.
37482   *
37483   * @param state Upload state.
37484   *
37485   * @return Queue items.
37486   */
37487  function getItems(state) {
37488    return state.queue;
37489  }
37490  
37491  /**
37492   * Determines whether any upload is currently in progress.
37493   *
37494   * @param state Upload state.
37495   *
37496   * @return Whether any upload is currently in progress.
37497   */
37498  function isUploading(state) {
37499    return state.queue.length >= 1;
37500  }
37501  
37502  /**
37503   * Determines whether an upload is currently in progress given an attachment URL.
37504   *
37505   * @param state Upload state.
37506   * @param url   Attachment URL.
37507   *
37508   * @return Whether upload is currently in progress for the given attachment.
37509   */
37510  function isUploadingByUrl(state, url) {
37511    return state.queue.some(item => item.attachment?.url === url || item.sourceUrl === url);
37512  }
37513  
37514  /**
37515   * Determines whether an upload is currently in progress given an attachment ID.
37516   *
37517   * @param state        Upload state.
37518   * @param attachmentId Attachment ID.
37519   *
37520   * @return Whether upload is currently in progress for the given attachment.
37521   */
37522  function isUploadingById(state, attachmentId) {
37523    return state.queue.some(item => item.attachment?.id === attachmentId || item.sourceAttachmentId === attachmentId);
37524  }
37525  
37526  /**
37527   * Returns the media upload settings.
37528   *
37529   * @param state Upload state.
37530   *
37531   * @return Settings
37532   */
37533  function selectors_getSettings(state) {
37534    return state.settings;
37535  }
37536  
37537  ;// ./node_modules/@wordpress/upload-media/build-module/store/private-selectors.js
37538  /**
37539   * Internal dependencies
37540   */
37541  
37542  
37543  /**
37544   * Returns all items currently being uploaded.
37545   *
37546   * @param state Upload state.
37547   *
37548   * @return Queue items.
37549   */
37550  function getAllItems(state) {
37551    return state.queue;
37552  }
37553  
37554  /**
37555   * Returns a specific item given its unique ID.
37556   *
37557   * @param state Upload state.
37558   * @param id    Item ID.
37559   *
37560   * @return Queue item.
37561   */
37562  function getItem(state, id) {
37563    return state.queue.find(item => item.id === id);
37564  }
37565  
37566  /**
37567   * Determines whether a batch has been successfully uploaded, given its unique ID.
37568   *
37569   * @param state   Upload state.
37570   * @param batchId Batch ID.
37571   *
37572   * @return Whether a batch has been uploaded.
37573   */
37574  function isBatchUploaded(state, batchId) {
37575    const batchItems = state.queue.filter(item => batchId === item.batchId);
37576    return batchItems.length === 0;
37577  }
37578  
37579  /**
37580   * Determines whether an upload is currently in progress given a post or attachment ID.
37581   *
37582   * @param state              Upload state.
37583   * @param postOrAttachmentId Post ID or attachment ID.
37584   *
37585   * @return Whether upload is currently in progress for the given post or attachment.
37586   */
37587  function isUploadingToPost(state, postOrAttachmentId) {
37588    return state.queue.some(item => item.currentOperation === OperationType.Upload && item.additionalData.post === postOrAttachmentId);
37589  }
37590  
37591  /**
37592   * Returns the next paused upload for a given post or attachment ID.
37593   *
37594   * @param state              Upload state.
37595   * @param postOrAttachmentId Post ID or attachment ID.
37596   *
37597   * @return Paused item.
37598   */
37599  function getPausedUploadForPost(state, postOrAttachmentId) {
37600    return state.queue.find(item => item.status === ItemStatus.Paused && item.additionalData.post === postOrAttachmentId);
37601  }
37602  
37603  /**
37604   * Determines whether uploading is currently paused.
37605   *
37606   * @param state Upload state.
37607   *
37608   * @return Whether uploading is currently paused.
37609   */
37610  function isPaused(state) {
37611    return state.queueStatus === 'paused';
37612  }
37613  
37614  /**
37615   * Returns all cached blob URLs for a given item ID.
37616   *
37617   * @param state Upload state.
37618   * @param id    Item ID
37619   *
37620   * @return List of blob URLs.
37621   */
37622  function getBlobUrls(state, id) {
37623    return state.blobUrls[id] || [];
37624  }
37625  
37626  ;// ./node_modules/@wordpress/upload-media/node_modules/uuid/dist/esm-browser/native.js
37627  const randomUUID = typeof crypto !== 'undefined' && crypto.randomUUID && crypto.randomUUID.bind(crypto);
37628  /* harmony default export */ const esm_browser_native = ({
37629    randomUUID
37630  });
37631  ;// ./node_modules/@wordpress/upload-media/node_modules/uuid/dist/esm-browser/rng.js
37632  // Unique ID creation requires a high quality random # generator. In the browser we therefore
37633  // require the crypto API and do not support built-in fallback to lower quality random number
37634  // generators (like Math.random()).
37635  let getRandomValues;
37636  const rnds8 = new Uint8Array(16);
37637  function rng() {
37638    // lazy load so that environments that need to polyfill have a chance to do so
37639    if (!getRandomValues) {
37640      // getRandomValues needs to be invoked in a context where "this" is a Crypto implementation.
37641      getRandomValues = typeof crypto !== 'undefined' && crypto.getRandomValues && crypto.getRandomValues.bind(crypto);
37642  
37643      if (!getRandomValues) {
37644        throw new Error('crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported');
37645      }
37646    }
37647  
37648    return getRandomValues(rnds8);
37649  }
37650  ;// ./node_modules/@wordpress/upload-media/node_modules/uuid/dist/esm-browser/stringify.js
37651  
37652  /**
37653   * Convert array of 16 byte values to UUID string format of the form:
37654   * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
37655   */
37656  
37657  const byteToHex = [];
37658  
37659  for (let i = 0; i < 256; ++i) {
37660    byteToHex.push((i + 0x100).toString(16).slice(1));
37661  }
37662  
37663  function unsafeStringify(arr, offset = 0) {
37664    // Note: Be careful editing this code!  It's been tuned for performance
37665    // and works in ways you may not expect. See https://github.com/uuidjs/uuid/pull/434
37666    return byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + '-' + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + '-' + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + '-' + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + '-' + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]];
37667  }
37668  
37669  function stringify(arr, offset = 0) {
37670    const uuid = unsafeStringify(arr, offset); // Consistency check for valid UUID.  If this throws, it's likely due to one
37671    // of the following:
37672    // - One or more input array values don't map to a hex octet (leading to
37673    // "undefined" in the uuid)
37674    // - Invalid input values for the RFC `version` or `variant` fields
37675  
37676    if (!validate(uuid)) {
37677      throw TypeError('Stringified UUID is invalid');
37678    }
37679  
37680    return uuid;
37681  }
37682  
37683  /* harmony default export */ const esm_browser_stringify = ((/* unused pure expression or super */ null && (stringify)));
37684  ;// ./node_modules/@wordpress/upload-media/node_modules/uuid/dist/esm-browser/v4.js
37685  
37686  
37687  
37688  
37689  function v4(options, buf, offset) {
37690    if (esm_browser_native.randomUUID && !buf && !options) {
37691      return esm_browser_native.randomUUID();
37692    }
37693  
37694    options = options || {};
37695    const rnds = options.random || (options.rng || rng)(); // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`
37696  
37697    rnds[6] = rnds[6] & 0x0f | 0x40;
37698    rnds[8] = rnds[8] & 0x3f | 0x80; // Copy bytes to buffer, if provided
37699  
37700    if (buf) {
37701      offset = offset || 0;
37702  
37703      for (let i = 0; i < 16; ++i) {
37704        buf[offset + i] = rnds[i];
37705      }
37706  
37707      return buf;
37708    }
37709  
37710    return unsafeStringify(rnds);
37711  }
37712  
37713  /* harmony default export */ const esm_browser_v4 = (v4);
37714  ;// ./node_modules/@wordpress/upload-media/build-module/upload-error.js
37715  /**
37716   * MediaError class.
37717   *
37718   * Small wrapper around the `Error` class
37719   * to hold an error code and a reference to a file object.
37720   */
37721  class UploadError extends Error {
37722    constructor({
37723      code,
37724      message,
37725      file,
37726      cause
37727    }) {
37728      super(message, {
37729        cause
37730      });
37731      Object.setPrototypeOf(this, new.target.prototype);
37732      this.code = code;
37733      this.file = file;
37734    }
37735  }
37736  
37737  ;// ./node_modules/@wordpress/upload-media/build-module/validate-mime-type.js
37738  /**
37739   * WordPress dependencies
37740   */
37741  
37742  
37743  /**
37744   * Internal dependencies
37745   */
37746  
37747  
37748  /**
37749   * Verifies if the caller (e.g. a block) supports this mime type.
37750   *
37751   * @param file         File object.
37752   * @param allowedTypes List of allowed mime types.
37753   */
37754  function validateMimeType(file, allowedTypes) {
37755    if (!allowedTypes) {
37756      return;
37757    }
37758  
37759    // Allowed type specified by consumer.
37760    const isAllowedType = allowedTypes.some(allowedType => {
37761      // If a complete mimetype is specified verify if it matches exactly the mime type of the file.
37762      if (allowedType.includes('/')) {
37763        return allowedType === file.type;
37764      }
37765      // Otherwise a general mime type is used, and we should verify if the file mimetype starts with it.
37766      return file.type.startsWith(`$allowedType}/`);
37767    });
37768    if (file.type && !isAllowedType) {
37769      throw new UploadError({
37770        code: 'MIME_TYPE_NOT_SUPPORTED',
37771        message: (0,external_wp_i18n_namespaceObject.sprintf)(
37772        // translators: %s: file name.
37773        (0,external_wp_i18n_namespaceObject.__)('%s: Sorry, this file type is not supported here.'), file.name),
37774        file
37775      });
37776    }
37777  }
37778  
37779  ;// ./node_modules/@wordpress/upload-media/build-module/get-mime-types-array.js
37780  /**
37781   * Browsers may use unexpected mime types, and they differ from browser to browser.
37782   * This function computes a flexible array of mime types from the mime type structured provided by the server.
37783   * Converts { jpg|jpeg|jpe: "image/jpeg" } into [ "image/jpeg", "image/jpg", "image/jpeg", "image/jpe" ]
37784   *
37785   * @param {?Object} wpMimeTypesObject Mime type object received from the server.
37786   *                                    Extensions are keys separated by '|' and values are mime types associated with an extension.
37787   *
37788   * @return An array of mime types or null
37789   */
37790  function getMimeTypesArray(wpMimeTypesObject) {
37791    if (!wpMimeTypesObject) {
37792      return null;
37793    }
37794    return Object.entries(wpMimeTypesObject).flatMap(([extensionsString, mime]) => {
37795      const [type] = mime.split('/');
37796      const extensions = extensionsString.split('|');
37797      return [mime, ...extensions.map(extension => `$type}/$extension}`)];
37798    });
37799  }
37800  
37801  ;// ./node_modules/@wordpress/upload-media/build-module/validate-mime-type-for-user.js
37802  /**
37803   * WordPress dependencies
37804   */
37805  
37806  
37807  /**
37808   * Internal dependencies
37809   */
37810  
37811  
37812  
37813  /**
37814   * Verifies if the user is allowed to upload this mime type.
37815   *
37816   * @param file               File object.
37817   * @param wpAllowedMimeTypes List of allowed mime types and file extensions.
37818   */
37819  function validateMimeTypeForUser(file, wpAllowedMimeTypes) {
37820    // Allowed types for the current WP_User.
37821    const allowedMimeTypesForUser = getMimeTypesArray(wpAllowedMimeTypes);
37822    if (!allowedMimeTypesForUser) {
37823      return;
37824    }
37825    const isAllowedMimeTypeForUser = allowedMimeTypesForUser.includes(file.type);
37826    if (file.type && !isAllowedMimeTypeForUser) {
37827      throw new UploadError({
37828        code: 'MIME_TYPE_NOT_ALLOWED_FOR_USER',
37829        message: (0,external_wp_i18n_namespaceObject.sprintf)(
37830        // translators: %s: file name.
37831        (0,external_wp_i18n_namespaceObject.__)('%s: Sorry, you are not allowed to upload this file type.'), file.name),
37832        file
37833      });
37834    }
37835  }
37836  
37837  ;// ./node_modules/@wordpress/upload-media/build-module/validate-file-size.js
37838  /**
37839   * WordPress dependencies
37840   */
37841  
37842  
37843  /**
37844   * Internal dependencies
37845   */
37846  
37847  
37848  /**
37849   * Verifies whether the file is within the file upload size limits for the site.
37850   *
37851   * @param file              File object.
37852   * @param maxUploadFileSize Maximum upload size in bytes allowed for the site.
37853   */
37854  function validateFileSize(file, maxUploadFileSize) {
37855    // Don't allow empty files to be uploaded.
37856    if (file.size <= 0) {
37857      throw new UploadError({
37858        code: 'EMPTY_FILE',
37859        message: (0,external_wp_i18n_namespaceObject.sprintf)(
37860        // translators: %s: file name.
37861        (0,external_wp_i18n_namespaceObject.__)('%s: This file is empty.'), file.name),
37862        file
37863      });
37864    }
37865    if (maxUploadFileSize && file.size > maxUploadFileSize) {
37866      throw new UploadError({
37867        code: 'SIZE_ABOVE_LIMIT',
37868        message: (0,external_wp_i18n_namespaceObject.sprintf)(
37869        // translators: %s: file name.
37870        (0,external_wp_i18n_namespaceObject.__)('%s: This file exceeds the maximum upload size for this site.'), file.name),
37871        file
37872      });
37873    }
37874  }
37875  
37876  ;// ./node_modules/@wordpress/upload-media/build-module/store/actions.js
37877  /**
37878   * External dependencies
37879   */
37880  
37881  
37882  /**
37883   * WordPress dependencies
37884   */
37885  
37886  /**
37887   * Internal dependencies
37888   */
37889  
37890  
37891  
37892  
37893  
37894  /**
37895   * Adds a new item to the upload queue.
37896   *
37897   * @param $0
37898   * @param $0.files            Files
37899   * @param [$0.onChange]       Function called each time a file or a temporary representation of the file is available.
37900   * @param [$0.onSuccess]      Function called after the file is uploaded.
37901   * @param [$0.onBatchSuccess] Function called after a batch of files is uploaded.
37902   * @param [$0.onError]        Function called when an error happens.
37903   * @param [$0.additionalData] Additional data to include in the request.
37904   * @param [$0.allowedTypes]   Array with the types of media that can be uploaded, if unset all types are allowed.
37905   */
37906  function addItems({
37907    files,
37908    onChange,
37909    onSuccess,
37910    onError,
37911    onBatchSuccess,
37912    additionalData,
37913    allowedTypes
37914  }) {
37915    return async ({
37916      select,
37917      dispatch
37918    }) => {
37919      const batchId = esm_browser_v4();
37920      for (const file of files) {
37921        /*
37922         Check if the caller (e.g. a block) supports this mime type.
37923         Special case for file types such as HEIC which will be converted before upload anyway.
37924         Another check will be done before upload.
37925        */
37926        try {
37927          validateMimeType(file, allowedTypes);
37928          validateMimeTypeForUser(file, select.getSettings().allowedMimeTypes);
37929        } catch (error) {
37930          onError?.(error);
37931          continue;
37932        }
37933        try {
37934          validateFileSize(file, select.getSettings().maxUploadFileSize);
37935        } catch (error) {
37936          onError?.(error);
37937          continue;
37938        }
37939        dispatch.addItem({
37940          file,
37941          batchId,
37942          onChange,
37943          onSuccess,
37944          onBatchSuccess,
37945          onError,
37946          additionalData
37947        });
37948      }
37949    };
37950  }
37951  
37952  /**
37953   * Cancels an item in the queue based on an error.
37954   *
37955   * @param id     Item ID.
37956   * @param error  Error instance.
37957   * @param silent Whether to cancel the item silently,
37958   *               without invoking its `onError` callback.
37959   */
37960  function cancelItem(id, error, silent = false) {
37961    return async ({
37962      select,
37963      dispatch
37964    }) => {
37965      const item = select.getItem(id);
37966      if (!item) {
37967        /*
37968         * Do nothing if item has already been removed.
37969         * This can happen if an upload is cancelled manually
37970         * while transcoding with vips is still in progress.
37971         * Then, cancelItem() is once invoked manually and once
37972         * by the error handler in optimizeImageItem().
37973         */
37974        return;
37975      }
37976      item.abortController?.abort();
37977      if (!silent) {
37978        const {
37979          onError
37980        } = item;
37981        onError?.(error !== null && error !== void 0 ? error : new Error('Upload cancelled'));
37982        if (!onError && error) {
37983          // TODO: Find better way to surface errors with sideloads etc.
37984          // eslint-disable-next-line no-console -- Deliberately log errors here.
37985          console.error('Upload cancelled', error);
37986        }
37987      }
37988      dispatch({
37989        type: Type.Cancel,
37990        id,
37991        error
37992      });
37993      dispatch.removeItem(id);
37994      dispatch.revokeBlobUrls(id);
37995  
37996      // All items of this batch were cancelled or finished.
37997      if (item.batchId && select.isBatchUploaded(item.batchId)) {
37998        item.onBatchSuccess?.();
37999      }
38000    };
38001  }
38002  
38003  ;// ./node_modules/@wordpress/upload-media/build-module/utils.js
38004  /**
38005   * WordPress dependencies
38006   */
38007  
38008  
38009  
38010  /**
38011   * Converts a Blob to a File with a default name like "image.png".
38012   *
38013   * If it is already a File object, it is returned unchanged.
38014   *
38015   * @param fileOrBlob Blob object.
38016   * @return File object.
38017   */
38018  function convertBlobToFile(fileOrBlob) {
38019    if (fileOrBlob instanceof File) {
38020      return fileOrBlob;
38021    }
38022  
38023    // Extension is only an approximation.
38024    // The server will override it if incorrect.
38025    const ext = fileOrBlob.type.split('/')[1];
38026    const mediaType = 'application/pdf' === fileOrBlob.type ? 'document' : fileOrBlob.type.split('/')[0];
38027    return new File([fileOrBlob], `$mediaType}.$ext}`, {
38028      type: fileOrBlob.type
38029    });
38030  }
38031  
38032  /**
38033   * Renames a given file and returns a new file.
38034   *
38035   * Copies over the last modified time.
38036   *
38037   * @param file File object.
38038   * @param name File name.
38039   * @return Renamed file object.
38040   */
38041  function renameFile(file, name) {
38042    return new File([file], name, {
38043      type: file.type,
38044      lastModified: file.lastModified
38045    });
38046  }
38047  
38048  /**
38049   * Clones a given file object.
38050   *
38051   * @param file File object.
38052   * @return New file object.
38053   */
38054  function cloneFile(file) {
38055    return renameFile(file, file.name);
38056  }
38057  
38058  /**
38059   * Returns the file extension from a given file name or URL.
38060   *
38061   * @param file File URL.
38062   * @return File extension or null if it does not have one.
38063   */
38064  function getFileExtension(file) {
38065    return file.includes('.') ? file.split('.').pop() || null : null;
38066  }
38067  
38068  /**
38069   * Returns file basename without extension.
38070   *
38071   * For example, turns "my-awesome-file.jpeg" into "my-awesome-file".
38072   *
38073   * @param name File name.
38074   * @return File basename.
38075   */
38076  function getFileBasename(name) {
38077    return name.includes('.') ? name.split('.').slice(0, -1).join('.') : name;
38078  }
38079  
38080  /**
38081   * Returns the file name including extension from a URL.
38082   *
38083   * @param url File URL.
38084   * @return File name.
38085   */
38086  function getFileNameFromUrl(url) {
38087    return getFilename(url) || _x('unnamed', 'file name');
38088  }
38089  
38090  ;// ./node_modules/@wordpress/upload-media/build-module/stub-file.js
38091  class StubFile extends File {
38092    constructor(fileName = 'stub-file') {
38093      super([], fileName);
38094    }
38095  }
38096  
38097  ;// ./node_modules/@wordpress/upload-media/build-module/store/private-actions.js
38098  /**
38099   * External dependencies
38100   */
38101  
38102  
38103  /**
38104   * WordPress dependencies
38105   */
38106  
38107  /**
38108   * Internal dependencies
38109   */
38110  
38111  
38112  
38113  /**
38114   * Adds a new item to the upload queue.
38115   *
38116   * @param $0
38117   * @param $0.file                 File
38118   * @param [$0.batchId]            Batch ID.
38119   * @param [$0.onChange]           Function called each time a file or a temporary representation of the file is available.
38120   * @param [$0.onSuccess]          Function called after the file is uploaded.
38121   * @param [$0.onBatchSuccess]     Function called after a batch of files is uploaded.
38122   * @param [$0.onError]            Function called when an error happens.
38123   * @param [$0.additionalData]     Additional data to include in the request.
38124   * @param [$0.sourceUrl]          Source URL. Used when importing a file from a URL or optimizing an existing file.
38125   * @param [$0.sourceAttachmentId] Source attachment ID. Used when optimizing an existing file for example.
38126   * @param [$0.abortController]    Abort controller for upload cancellation.
38127   * @param [$0.operations]         List of operations to perform. Defaults to automatically determined list, based on the file.
38128   */
38129  function addItem({
38130    file: fileOrBlob,
38131    batchId,
38132    onChange,
38133    onSuccess,
38134    onBatchSuccess,
38135    onError,
38136    additionalData = {},
38137    sourceUrl,
38138    sourceAttachmentId,
38139    abortController,
38140    operations
38141  }) {
38142    return async ({
38143      dispatch
38144    }) => {
38145      const itemId = esm_browser_v4();
38146  
38147      // Hardening in case a Blob is passed instead of a File.
38148      // See https://github.com/WordPress/gutenberg/pull/65693 for an example.
38149      const file = convertBlobToFile(fileOrBlob);
38150      let blobUrl;
38151  
38152      // StubFile could be coming from addItemFromUrl().
38153      if (!(file instanceof StubFile)) {
38154        blobUrl = (0,external_wp_blob_namespaceObject.createBlobURL)(file);
38155        dispatch({
38156          type: Type.CacheBlobUrl,
38157          id: itemId,
38158          blobUrl
38159        });
38160      }
38161      dispatch({
38162        type: Type.Add,
38163        item: {
38164          id: itemId,
38165          batchId,
38166          status: ItemStatus.Processing,
38167          sourceFile: cloneFile(file),
38168          file,
38169          attachment: {
38170            url: blobUrl
38171          },
38172          additionalData: {
38173            convert_format: false,
38174            ...additionalData
38175          },
38176          onChange,
38177          onSuccess,
38178          onBatchSuccess,
38179          onError,
38180          sourceUrl,
38181          sourceAttachmentId,
38182          abortController: abortController || new AbortController(),
38183          operations: Array.isArray(operations) ? operations : [OperationType.Prepare]
38184        }
38185      });
38186      dispatch.processItem(itemId);
38187    };
38188  }
38189  
38190  /**
38191   * Processes a single item in the queue.
38192   *
38193   * Runs the next operation in line and invokes any callbacks.
38194   *
38195   * @param id Item ID.
38196   */
38197  function processItem(id) {
38198    return async ({
38199      select,
38200      dispatch
38201    }) => {
38202      if (select.isPaused()) {
38203        return;
38204      }
38205      const item = select.getItem(id);
38206      const {
38207        attachment,
38208        onChange,
38209        onSuccess,
38210        onBatchSuccess,
38211        batchId
38212      } = item;
38213      const operation = Array.isArray(item.operations?.[0]) ? item.operations[0][0] : item.operations?.[0];
38214      if (attachment) {
38215        onChange?.([attachment]);
38216      }
38217  
38218      /*
38219       If there are no more operations, the item can be removed from the queue,
38220       but only if there are no thumbnails still being side-loaded,
38221       or if itself is a side-loaded item.
38222      */
38223  
38224      if (!operation) {
38225        if (attachment) {
38226          onSuccess?.([attachment]);
38227        }
38228  
38229        // dispatch.removeItem( id );
38230        dispatch.revokeBlobUrls(id);
38231        if (batchId && select.isBatchUploaded(batchId)) {
38232          onBatchSuccess?.();
38233        }
38234  
38235        /*
38236         At this point we are dealing with a parent whose children haven't fully uploaded yet.
38237         Do nothing and let the removal happen once the last side-loaded item finishes.
38238         */
38239  
38240        return;
38241      }
38242      if (!operation) {
38243        // This shouldn't really happen.
38244        return;
38245      }
38246      dispatch({
38247        type: Type.OperationStart,
38248        id,
38249        operation
38250      });
38251      switch (operation) {
38252        case OperationType.Prepare:
38253          dispatch.prepareItem(item.id);
38254          break;
38255        case OperationType.Upload:
38256          dispatch.uploadItem(id);
38257          break;
38258      }
38259    };
38260  }
38261  
38262  /**
38263   * Returns an action object that pauses all processing in the queue.
38264   *
38265   * Useful for testing purposes.
38266   *
38267   * @return Action object.
38268   */
38269  function pauseQueue() {
38270    return {
38271      type: Type.PauseQueue
38272    };
38273  }
38274  
38275  /**
38276   * Resumes all processing in the queue.
38277   *
38278   * Dispatches an action object for resuming the queue itself,
38279   * and triggers processing for each remaining item in the queue individually.
38280   */
38281  function resumeQueue() {
38282    return async ({
38283      select,
38284      dispatch
38285    }) => {
38286      dispatch({
38287        type: Type.ResumeQueue
38288      });
38289      for (const item of select.getAllItems()) {
38290        dispatch.processItem(item.id);
38291      }
38292    };
38293  }
38294  
38295  /**
38296   * Removes a specific item from the queue.
38297   *
38298   * @param id Item ID.
38299   */
38300  function removeItem(id) {
38301    return async ({
38302      select,
38303      dispatch
38304    }) => {
38305      const item = select.getItem(id);
38306      if (!item) {
38307        return;
38308      }
38309      dispatch({
38310        type: Type.Remove,
38311        id
38312      });
38313    };
38314  }
38315  
38316  /**
38317   * Finishes an operation for a given item ID and immediately triggers processing the next one.
38318   *
38319   * @param id      Item ID.
38320   * @param updates Updated item data.
38321   */
38322  function finishOperation(id, updates) {
38323    return async ({
38324      dispatch
38325    }) => {
38326      dispatch({
38327        type: Type.OperationFinish,
38328        id,
38329        item: updates
38330      });
38331      dispatch.processItem(id);
38332    };
38333  }
38334  
38335  /**
38336   * Prepares an item for initial processing.
38337   *
38338   * Determines the list of operations to perform for a given image,
38339   * depending on its media type.
38340   *
38341   * For example, HEIF images first need to be converted, resized,
38342   * compressed, and then uploaded.
38343   *
38344   * Or videos need to be compressed, and then need poster generation
38345   * before upload.
38346   *
38347   * @param id Item ID.
38348   */
38349  function prepareItem(id) {
38350    return async ({
38351      dispatch
38352    }) => {
38353      const operations = [OperationType.Upload];
38354      dispatch({
38355        type: Type.AddOperations,
38356        id,
38357        operations
38358      });
38359      dispatch.finishOperation(id, {});
38360    };
38361  }
38362  
38363  /**
38364   * Uploads an item to the server.
38365   *
38366   * @param id Item ID.
38367   */
38368  function uploadItem(id) {
38369    return async ({
38370      select,
38371      dispatch
38372    }) => {
38373      const item = select.getItem(id);
38374      select.getSettings().mediaUpload({
38375        filesList: [item.file],
38376        additionalData: item.additionalData,
38377        signal: item.abortController?.signal,
38378        onFileChange: ([attachment]) => {
38379          if (!(0,external_wp_blob_namespaceObject.isBlobURL)(attachment.url)) {
38380            dispatch.finishOperation(id, {
38381              attachment
38382            });
38383          }
38384        },
38385        onSuccess: ([attachment]) => {
38386          dispatch.finishOperation(id, {
38387            attachment
38388          });
38389        },
38390        onError: error => {
38391          dispatch.cancelItem(id, error);
38392        }
38393      });
38394    };
38395  }
38396  
38397  /**
38398   * Revokes all blob URLs for a given item, freeing up memory.
38399   *
38400   * @param id Item ID.
38401   */
38402  function revokeBlobUrls(id) {
38403    return async ({
38404      select,
38405      dispatch
38406    }) => {
38407      const blobUrls = select.getBlobUrls(id);
38408      for (const blobUrl of blobUrls) {
38409        (0,external_wp_blob_namespaceObject.revokeBlobURL)(blobUrl);
38410      }
38411      dispatch({
38412        type: Type.RevokeBlobUrls,
38413        id
38414      });
38415    };
38416  }
38417  
38418  /**
38419   * Returns an action object that pauses all processing in the queue.
38420   *
38421   * Useful for testing purposes.
38422   *
38423   * @param settings
38424   * @return Action object.
38425   */
38426  function private_actions_updateSettings(settings) {
38427    return {
38428      type: Type.UpdateSettings,
38429      settings
38430    };
38431  }
38432  
38433  ;// ./node_modules/@wordpress/upload-media/build-module/lock-unlock.js
38434  /**
38435   * WordPress dependencies
38436   */
38437  
38438  const {
38439    lock: lock_unlock_lock,
38440    unlock: lock_unlock_unlock
38441  } = (0,external_wp_privateApis_namespaceObject.__dangerousOptInToUnstableAPIsOnlyForCoreModules)('I acknowledge private features are not for use in themes or plugins and doing so will break in the next version of WordPress.', '@wordpress/upload-media');
38442  
38443  ;// ./node_modules/@wordpress/upload-media/build-module/store/constants.js
38444  const constants_STORE_NAME = 'core/upload-media';
38445  
38446  ;// ./node_modules/@wordpress/upload-media/build-module/store/index.js
38447  /**
38448   * WordPress dependencies
38449   */
38450  
38451  
38452  /**
38453   * Internal dependencies
38454   */
38455  
38456  
38457  
38458  
38459  
38460  
38461  
38462  
38463  /**
38464   * Media upload data store configuration.
38465   *
38466   * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/data/README.md#registerStore
38467   */
38468  const store_storeConfig = {
38469    reducer: store_reducer,
38470    selectors: store_selectors_namespaceObject,
38471    actions: store_actions_namespaceObject
38472  };
38473  
38474  /**
38475   * Store definition for the media upload namespace.
38476   *
38477   * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/data/README.md#createReduxStore
38478   */
38479  const store_store = (0,external_wp_data_namespaceObject.createReduxStore)(constants_STORE_NAME, {
38480    reducer: store_reducer,
38481    selectors: store_selectors_namespaceObject,
38482    actions: store_actions_namespaceObject
38483  });
38484  (0,external_wp_data_namespaceObject.register)(store_store);
38485  // @ts-ignore
38486  lock_unlock_unlock(store_store).registerPrivateActions(store_private_actions_namespaceObject);
38487  // @ts-ignore
38488  lock_unlock_unlock(store_store).registerPrivateSelectors(store_private_selectors_namespaceObject);
38489  
38490  ;// ./node_modules/@wordpress/upload-media/build-module/components/provider/with-registry-provider.js
38491  /**
38492   * WordPress dependencies
38493   */
38494  
38495  
38496  
38497  
38498  /**
38499   * Internal dependencies
38500   */
38501  
38502  
38503  
38504  function getSubRegistry(subRegistries, registry, useSubRegistry) {
38505    if (!useSubRegistry) {
38506      return registry;
38507    }
38508    let subRegistry = subRegistries.get(registry);
38509    if (!subRegistry) {
38510      subRegistry = (0,external_wp_data_namespaceObject.createRegistry)({}, registry);
38511      subRegistry.registerStore(constants_STORE_NAME, store_storeConfig);
38512      subRegistries.set(registry, subRegistry);
38513    }
38514    return subRegistry;
38515  }
38516  const withRegistryProvider = (0,external_wp_compose_namespaceObject.createHigherOrderComponent)(WrappedComponent => ({
38517    useSubRegistry = true,
38518    ...props
38519  }) => {
38520    const registry = (0,external_wp_data_namespaceObject.useRegistry)();
38521    const [subRegistries] = (0,external_wp_element_namespaceObject.useState)(() => new WeakMap());
38522    const subRegistry = getSubRegistry(subRegistries, registry, useSubRegistry);
38523    if (subRegistry === registry) {
38524      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(WrappedComponent, {
38525        registry: registry,
38526        ...props
38527      });
38528    }
38529    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_data_namespaceObject.RegistryProvider, {
38530      value: subRegistry,
38531      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(WrappedComponent, {
38532        registry: subRegistry,
38533        ...props
38534      })
38535    });
38536  }, 'withRegistryProvider');
38537  /* harmony default export */ const with_registry_provider = (withRegistryProvider);
38538  
38539  ;// ./node_modules/@wordpress/upload-media/build-module/components/provider/index.js
38540  /**
38541   * WordPress dependencies
38542   */
38543  
38544  
38545  
38546  /**
38547   * Internal dependencies
38548   */
38549  
38550  
38551  
38552  
38553  const MediaUploadProvider = with_registry_provider(props => {
38554    const {
38555      children,
38556      settings
38557    } = props;
38558    const {
38559      updateSettings
38560    } = lock_unlock_unlock((0,external_wp_data_namespaceObject.useDispatch)(store_store));
38561    (0,external_wp_element_namespaceObject.useEffect)(() => {
38562      updateSettings(settings);
38563    }, [settings, updateSettings]);
38564    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_ReactJSXRuntime_namespaceObject.Fragment, {
38565      children: children
38566    });
38567  });
38568  /* harmony default export */ const provider = (MediaUploadProvider);
38569  
38570  ;// ./node_modules/@wordpress/block-editor/build-module/components/provider/with-registry-provider.js
38571  /**
38572   * WordPress dependencies
38573   */
38574  
38575  
38576  
38577  
38578  /**
38579   * Internal dependencies
38580   */
38581  
38582  
38583  
38584  function with_registry_provider_getSubRegistry(subRegistries, registry, useSubRegistry) {
38585    if (!useSubRegistry) {
38586      return registry;
38587    }
38588    let subRegistry = subRegistries.get(registry);
38589    if (!subRegistry) {
38590      subRegistry = (0,external_wp_data_namespaceObject.createRegistry)({}, registry);
38591      subRegistry.registerStore(STORE_NAME, storeConfig);
38592      subRegistries.set(registry, subRegistry);
38593    }
38594    return subRegistry;
38595  }
38596  const with_registry_provider_withRegistryProvider = (0,external_wp_compose_namespaceObject.createHigherOrderComponent)(WrappedComponent => ({
38597    useSubRegistry = true,
38598    ...props
38599  }) => {
38600    const registry = (0,external_wp_data_namespaceObject.useRegistry)();
38601    const [subRegistries] = (0,external_wp_element_namespaceObject.useState)(() => new WeakMap());
38602    const subRegistry = with_registry_provider_getSubRegistry(subRegistries, registry, useSubRegistry);
38603    if (subRegistry === registry) {
38604      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(WrappedComponent, {
38605        registry: registry,
38606        ...props
38607      });
38608    }
38609    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_data_namespaceObject.RegistryProvider, {
38610      value: subRegistry,
38611      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(WrappedComponent, {
38612        registry: subRegistry,
38613        ...props
38614      })
38615    });
38616  }, 'withRegistryProvider');
38617  /* harmony default export */ const provider_with_registry_provider = (with_registry_provider_withRegistryProvider);
38618  
38619  ;// ./node_modules/@wordpress/block-editor/build-module/components/provider/use-block-sync.js
38620  /**
38621   * WordPress dependencies
38622   */
38623  
38624  
38625  
38626  
38627  /**
38628   * Internal dependencies
38629   */
38630  
38631  const use_block_sync_noop = () => {};
38632  
38633  /**
38634   * A function to call when the block value has been updated in the block-editor
38635   * store.
38636   *
38637   * @callback onBlockUpdate
38638   * @param {Object[]} blocks  The updated blocks.
38639   * @param {Object}   options The updated block options, such as selectionStart
38640   *                           and selectionEnd.
38641   */
38642  
38643  /**
38644   * useBlockSync is a side effect which handles bidirectional sync between the
38645   * block-editor store and a controlling data source which provides blocks. This
38646   * is most commonly used by the BlockEditorProvider to synchronize the contents
38647   * of the block-editor store with the root entity, like a post.
38648   *
38649   * Another example would be the template part block, which provides blocks from
38650   * a separate entity data source than a root entity. This hook syncs edits to
38651   * the template part in the block editor back to the entity and vice-versa.
38652   *
38653   * Here are some of its basic functions:
38654   * - Initializes the block-editor store for the given clientID to the blocks
38655   *   given via props.
38656   * - Adds incoming changes (like undo) to the block-editor store.
38657   * - Adds outgoing changes (like editing content) to the controlling entity,
38658   *   determining if a change should be considered persistent or not.
38659   * - Handles edge cases and race conditions which occur in those operations.
38660   * - Ignores changes which happen to other entities (like nested inner block
38661   *   controllers.
38662   * - Passes selection state from the block-editor store to the controlling entity.
38663   *
38664   * @param {Object}        props           Props for the block sync hook
38665   * @param {string}        props.clientId  The client ID of the inner block controller.
38666   *                                        If none is passed, then it is assumed to be a
38667   *                                        root controller rather than an inner block
38668   *                                        controller.
38669   * @param {Object[]}      props.value     The control value for the blocks. This value
38670   *                                        is used to initialize the block-editor store
38671   *                                        and for resetting the blocks to incoming
38672   *                                        changes like undo.
38673   * @param {Object}        props.selection The selection state responsible to restore the selection on undo/redo.
38674   * @param {onBlockUpdate} props.onChange  Function to call when a persistent
38675   *                                        change has been made in the block-editor blocks
38676   *                                        for the given clientId. For example, after
38677   *                                        this function is called, an entity is marked
38678   *                                        dirty because it has changes to save.
38679   * @param {onBlockUpdate} props.onInput   Function to call when a non-persistent
38680   *                                        change has been made in the block-editor blocks
38681   *                                        for the given clientId. When this is called,
38682   *                                        controlling sources do not become dirty.
38683   */
38684  function useBlockSync({
38685    clientId = null,
38686    value: controlledBlocks,
38687    selection: controlledSelection,
38688    onChange = use_block_sync_noop,
38689    onInput = use_block_sync_noop
38690  }) {
38691    const registry = (0,external_wp_data_namespaceObject.useRegistry)();
38692    const {
38693      resetBlocks,
38694      resetSelection,
38695      replaceInnerBlocks,
38696      setHasControlledInnerBlocks,
38697      __unstableMarkNextChangeAsNotPersistent
38698    } = registry.dispatch(store);
38699    const {
38700      getBlockName,
38701      getBlocks,
38702      getSelectionStart,
38703      getSelectionEnd
38704    } = registry.select(store);
38705    const isControlled = (0,external_wp_data_namespaceObject.useSelect)(select => {
38706      return !clientId || select(store).areInnerBlocksControlled(clientId);
38707    }, [clientId]);
38708    const pendingChangesRef = (0,external_wp_element_namespaceObject.useRef)({
38709      incoming: null,
38710      outgoing: []
38711    });
38712    const subscribedRef = (0,external_wp_element_namespaceObject.useRef)(false);
38713    const setControlledBlocks = () => {
38714      if (!controlledBlocks) {
38715        return;
38716      }
38717  
38718      // We don't need to persist this change because we only replace
38719      // controlled inner blocks when the change was caused by an entity,
38720      // and so it would already be persisted.
38721      __unstableMarkNextChangeAsNotPersistent();
38722      if (clientId) {
38723        // It is important to batch here because otherwise,
38724        // as soon as `setHasControlledInnerBlocks` is called
38725        // the effect to restore might be triggered
38726        // before the actual blocks get set properly in state.
38727        registry.batch(() => {
38728          setHasControlledInnerBlocks(clientId, true);
38729          const storeBlocks = controlledBlocks.map(block => (0,external_wp_blocks_namespaceObject.cloneBlock)(block));
38730          if (subscribedRef.current) {
38731            pendingChangesRef.current.incoming = storeBlocks;
38732          }
38733          __unstableMarkNextChangeAsNotPersistent();
38734          replaceInnerBlocks(clientId, storeBlocks);
38735        });
38736      } else {
38737        if (subscribedRef.current) {
38738          pendingChangesRef.current.incoming = controlledBlocks;
38739        }
38740        resetBlocks(controlledBlocks);
38741      }
38742    };
38743  
38744    // Clean up the changes made by setControlledBlocks() when the component
38745    // containing useBlockSync() unmounts.
38746    const unsetControlledBlocks = () => {
38747      __unstableMarkNextChangeAsNotPersistent();
38748      if (clientId) {
38749        setHasControlledInnerBlocks(clientId, false);
38750        __unstableMarkNextChangeAsNotPersistent();
38751        replaceInnerBlocks(clientId, []);
38752      } else {
38753        resetBlocks([]);
38754      }
38755    };
38756  
38757    // Add a subscription to the block-editor registry to detect when changes
38758    // have been made. This lets us inform the data source of changes. This
38759    // is an effect so that the subscriber can run synchronously without
38760    // waiting for React renders for changes.
38761    const onInputRef = (0,external_wp_element_namespaceObject.useRef)(onInput);
38762    const onChangeRef = (0,external_wp_element_namespaceObject.useRef)(onChange);
38763    (0,external_wp_element_namespaceObject.useEffect)(() => {
38764      onInputRef.current = onInput;
38765      onChangeRef.current = onChange;
38766    }, [onInput, onChange]);
38767  
38768    // Determine if blocks need to be reset when they change.
38769    (0,external_wp_element_namespaceObject.useEffect)(() => {
38770      if (pendingChangesRef.current.outgoing.includes(controlledBlocks)) {
38771        // Skip block reset if the value matches expected outbound sync
38772        // triggered by this component by a preceding change detection.
38773        // Only skip if the value matches expectation, since a reset should
38774        // still occur if the value is modified (not equal by reference),
38775        // to allow that the consumer may apply modifications to reflect
38776        // back on the editor.
38777        if (pendingChangesRef.current.outgoing[pendingChangesRef.current.outgoing.length - 1] === controlledBlocks) {
38778          pendingChangesRef.current.outgoing = [];
38779        }
38780      } else if (getBlocks(clientId) !== controlledBlocks) {
38781        // Reset changing value in all other cases than the sync described
38782        // above. Since this can be reached in an update following an out-
38783        // bound sync, unset the outbound value to avoid considering it in
38784        // subsequent renders.
38785        pendingChangesRef.current.outgoing = [];
38786        setControlledBlocks();
38787        if (controlledSelection) {
38788          resetSelection(controlledSelection.selectionStart, controlledSelection.selectionEnd, controlledSelection.initialPosition);
38789        }
38790      }
38791    }, [controlledBlocks, clientId]);
38792    const isMountedRef = (0,external_wp_element_namespaceObject.useRef)(false);
38793    (0,external_wp_element_namespaceObject.useEffect)(() => {
38794      // On mount, controlled blocks are already set in the effect above.
38795      if (!isMountedRef.current) {
38796        isMountedRef.current = true;
38797        return;
38798      }
38799  
38800      // When the block becomes uncontrolled, it means its inner state has been reset
38801      // we need to take the blocks again from the external value property.
38802      if (!isControlled) {
38803        pendingChangesRef.current.outgoing = [];
38804        setControlledBlocks();
38805      }
38806    }, [isControlled]);
38807    (0,external_wp_element_namespaceObject.useEffect)(() => {
38808      const {
38809        getSelectedBlocksInitialCaretPosition,
38810        isLastBlockChangePersistent,
38811        __unstableIsLastBlockChangeIgnored,
38812        areInnerBlocksControlled
38813      } = registry.select(store);
38814      let blocks = getBlocks(clientId);
38815      let isPersistent = isLastBlockChangePersistent();
38816      let previousAreBlocksDifferent = false;
38817      subscribedRef.current = true;
38818      const unsubscribe = registry.subscribe(() => {
38819        // Sometimes, when changing block lists, lingering subscriptions
38820        // might trigger before they are cleaned up. If the block for which
38821        // the subscription runs is no longer in the store, this would clear
38822        // its parent entity's block list. To avoid this, we bail out if
38823        // the subscription is triggering for a block (`clientId !== null`)
38824        // and its block name can't be found because it's not on the list.
38825        // (`getBlockName( clientId ) === null`).
38826        if (clientId !== null && getBlockName(clientId) === null) {
38827          return;
38828        }
38829  
38830        // When RESET_BLOCKS on parent blocks get called, the controlled blocks
38831        // can reset to uncontrolled, in these situations, it means we need to populate
38832        // the blocks again from the external blocks (the value property here)
38833        // and we should stop triggering onChange
38834        const isStillControlled = !clientId || areInnerBlocksControlled(clientId);
38835        if (!isStillControlled) {
38836          return;
38837        }
38838        const newIsPersistent = isLastBlockChangePersistent();
38839        const newBlocks = getBlocks(clientId);
38840        const areBlocksDifferent = newBlocks !== blocks;
38841        blocks = newBlocks;
38842        if (areBlocksDifferent && (pendingChangesRef.current.incoming || __unstableIsLastBlockChangeIgnored())) {
38843          pendingChangesRef.current.incoming = null;
38844          isPersistent = newIsPersistent;
38845          return;
38846        }
38847  
38848        // Since we often dispatch an action to mark the previous action as
38849        // persistent, we need to make sure that the blocks changed on the
38850        // previous action before committing the change.
38851        const didPersistenceChange = previousAreBlocksDifferent && !areBlocksDifferent && newIsPersistent && !isPersistent;
38852        if (areBlocksDifferent || didPersistenceChange) {
38853          isPersistent = newIsPersistent;
38854          // We know that onChange/onInput will update controlledBlocks.
38855          // We need to be aware that it was caused by an outgoing change
38856          // so that we do not treat it as an incoming change later on,
38857          // which would cause a block reset.
38858          pendingChangesRef.current.outgoing.push(blocks);
38859  
38860          // Inform the controlling entity that changes have been made to
38861          // the block-editor store they should be aware about.
38862          const updateParent = isPersistent ? onChangeRef.current : onInputRef.current;
38863          updateParent(blocks, {
38864            selection: {
38865              selectionStart: getSelectionStart(),
38866              selectionEnd: getSelectionEnd(),
38867              initialPosition: getSelectedBlocksInitialCaretPosition()
38868            }
38869          });
38870        }
38871        previousAreBlocksDifferent = areBlocksDifferent;
38872      }, store);
38873      return () => {
38874        subscribedRef.current = false;
38875        unsubscribe();
38876      };
38877    }, [registry, clientId]);
38878    (0,external_wp_element_namespaceObject.useEffect)(() => {
38879      return () => {
38880        unsetControlledBlocks();
38881      };
38882    }, []);
38883  }
38884  
38885  ;// external ["wp","keyboardShortcuts"]
38886  const external_wp_keyboardShortcuts_namespaceObject = window["wp"]["keyboardShortcuts"];
38887  ;// ./node_modules/@wordpress/block-editor/build-module/components/keyboard-shortcuts/index.js
38888  /**
38889   * WordPress dependencies
38890   */
38891  
38892  
38893  
38894  
38895  function KeyboardShortcuts() {
38896    return null;
38897  }
38898  function KeyboardShortcutsRegister() {
38899    // Registering the shortcuts.
38900    const {
38901      registerShortcut
38902    } = (0,external_wp_data_namespaceObject.useDispatch)(external_wp_keyboardShortcuts_namespaceObject.store);
38903    (0,external_wp_element_namespaceObject.useEffect)(() => {
38904      registerShortcut({
38905        name: 'core/block-editor/copy',
38906        category: 'block',
38907        description: (0,external_wp_i18n_namespaceObject.__)('Copy the selected block(s).'),
38908        keyCombination: {
38909          modifier: 'primary',
38910          character: 'c'
38911        }
38912      });
38913      registerShortcut({
38914        name: 'core/block-editor/cut',
38915        category: 'block',
38916        description: (0,external_wp_i18n_namespaceObject.__)('Cut the selected block(s).'),
38917        keyCombination: {
38918          modifier: 'primary',
38919          character: 'x'
38920        }
38921      });
38922      registerShortcut({
38923        name: 'core/block-editor/paste',
38924        category: 'block',
38925        description: (0,external_wp_i18n_namespaceObject.__)('Paste the selected block(s).'),
38926        keyCombination: {
38927          modifier: 'primary',
38928          character: 'v'
38929        }
38930      });
38931      registerShortcut({
38932        name: 'core/block-editor/duplicate',
38933        category: 'block',
38934        description: (0,external_wp_i18n_namespaceObject.__)('Duplicate the selected block(s).'),
38935        keyCombination: {
38936          modifier: 'primaryShift',
38937          character: 'd'
38938        }
38939      });
38940      registerShortcut({
38941        name: 'core/block-editor/remove',
38942        category: 'block',
38943        description: (0,external_wp_i18n_namespaceObject.__)('Remove the selected block(s).'),
38944        keyCombination: {
38945          modifier: 'primaryShift',
38946          character: 'backspace'
38947        }
38948      });
38949      registerShortcut({
38950        name: 'core/block-editor/insert-before',
38951        category: 'block',
38952        description: (0,external_wp_i18n_namespaceObject.__)('Insert a new block before the selected block(s).'),
38953        keyCombination: {
38954          modifier: 'primaryAlt',
38955          character: 't'
38956        }
38957      });
38958      registerShortcut({
38959        name: 'core/block-editor/insert-after',
38960        category: 'block',
38961        description: (0,external_wp_i18n_namespaceObject.__)('Insert a new block after the selected block(s).'),
38962        keyCombination: {
38963          modifier: 'primaryAlt',
38964          character: 'y'
38965        }
38966      });
38967      registerShortcut({
38968        name: 'core/block-editor/delete-multi-selection',
38969        category: 'block',
38970        description: (0,external_wp_i18n_namespaceObject.__)('Delete selection.'),
38971        keyCombination: {
38972          character: 'del'
38973        },
38974        aliases: [{
38975          character: 'backspace'
38976        }]
38977      });
38978      registerShortcut({
38979        name: 'core/block-editor/select-all',
38980        category: 'selection',
38981        description: (0,external_wp_i18n_namespaceObject.__)('Select all text when typing. Press again to select all blocks.'),
38982        keyCombination: {
38983          modifier: 'primary',
38984          character: 'a'
38985        }
38986      });
38987      registerShortcut({
38988        name: 'core/block-editor/unselect',
38989        category: 'selection',
38990        description: (0,external_wp_i18n_namespaceObject.__)('Clear selection.'),
38991        keyCombination: {
38992          character: 'escape'
38993        }
38994      });
38995      registerShortcut({
38996        name: 'core/block-editor/multi-text-selection',
38997        category: 'selection',
38998        description: (0,external_wp_i18n_namespaceObject.__)('Select text across multiple blocks.'),
38999        keyCombination: {
39000          modifier: 'shift',
39001          character: 'arrow'
39002        }
39003      });
39004      registerShortcut({
39005        name: 'core/block-editor/focus-toolbar',
39006        category: 'global',
39007        description: (0,external_wp_i18n_namespaceObject.__)('Navigate to the nearest toolbar.'),
39008        keyCombination: {
39009          modifier: 'alt',
39010          character: 'F10'
39011        }
39012      });
39013      registerShortcut({
39014        name: 'core/block-editor/move-up',
39015        category: 'block',
39016        description: (0,external_wp_i18n_namespaceObject.__)('Move the selected block(s) up.'),
39017        keyCombination: {
39018          modifier: 'secondary',
39019          character: 't'
39020        }
39021      });
39022      registerShortcut({
39023        name: 'core/block-editor/move-down',
39024        category: 'block',
39025        description: (0,external_wp_i18n_namespaceObject.__)('Move the selected block(s) down.'),
39026        keyCombination: {
39027          modifier: 'secondary',
39028          character: 'y'
39029        }
39030      });
39031  
39032      // List view shortcuts.
39033      registerShortcut({
39034        name: 'core/block-editor/collapse-list-view',
39035        category: 'list-view',
39036        description: (0,external_wp_i18n_namespaceObject.__)('Collapse all other items.'),
39037        keyCombination: {
39038          modifier: 'alt',
39039          character: 'l'
39040        }
39041      });
39042      registerShortcut({
39043        name: 'core/block-editor/group',
39044        category: 'block',
39045        description: (0,external_wp_i18n_namespaceObject.__)('Create a group block from the selected multiple blocks.'),
39046        keyCombination: {
39047          modifier: 'primary',
39048          character: 'g'
39049        }
39050      });
39051    }, [registerShortcut]);
39052    return null;
39053  }
39054  KeyboardShortcuts.Register = KeyboardShortcutsRegister;
39055  /* harmony default export */ const keyboard_shortcuts = (KeyboardShortcuts);
39056  
39057  ;// ./node_modules/@wordpress/block-editor/build-module/components/provider/use-media-upload-settings.js
39058  /**
39059   * WordPress dependencies
39060   */
39061  
39062  
39063  /**
39064   * React hook used to compute the media upload settings to use in the post editor.
39065   *
39066   * @param {Object} settings Media upload settings prop.
39067   *
39068   * @return {Object} Media upload settings.
39069   */
39070  function useMediaUploadSettings(settings = {}) {
39071    return (0,external_wp_element_namespaceObject.useMemo)(() => ({
39072      mediaUpload: settings.mediaUpload,
39073      mediaSideload: settings.mediaSideload,
39074      maxUploadFileSize: settings.maxUploadFileSize,
39075      allowedMimeTypes: settings.allowedMimeTypes
39076    }), [settings]);
39077  }
39078  /* harmony default export */ const use_media_upload_settings = (useMediaUploadSettings);
39079  
39080  ;// ./node_modules/@wordpress/block-editor/build-module/components/provider/index.js
39081  /**
39082   * WordPress dependencies
39083   */
39084  
39085  
39086  
39087  
39088  
39089  /**
39090   * Internal dependencies
39091   */
39092  
39093  
39094  
39095  
39096  
39097  
39098  
39099  
39100  /** @typedef {import('@wordpress/data').WPDataRegistry} WPDataRegistry */
39101  
39102  const provider_noop = () => {};
39103  
39104  /**
39105   * Upload a media file when the file upload button is activated
39106   * or when adding a file to the editor via drag & drop.
39107   *
39108   * @param {WPDataRegistry} registry
39109   * @param {Object}         $3                Parameters object passed to the function.
39110   * @param {Array}          $3.allowedTypes   Array with the types of media that can be uploaded, if unset all types are allowed.
39111   * @param {Object}         $3.additionalData Additional data to include in the request.
39112   * @param {Array<File>}    $3.filesList      List of files.
39113   * @param {Function}       $3.onError        Function called when an error happens.
39114   * @param {Function}       $3.onFileChange   Function called each time a file or a temporary representation of the file is available.
39115   * @param {Function}       $3.onSuccess      Function called once a file has completely finished uploading, including thumbnails.
39116   * @param {Function}       $3.onBatchSuccess Function called once all files in a group have completely finished uploading, including thumbnails.
39117   */
39118  function mediaUpload(registry, {
39119    allowedTypes,
39120    additionalData = {},
39121    filesList,
39122    onError = provider_noop,
39123    onFileChange,
39124    onSuccess,
39125    onBatchSuccess
39126  }) {
39127    void registry.dispatch(store_store).addItems({
39128      files: filesList,
39129      onChange: onFileChange,
39130      onSuccess,
39131      onBatchSuccess,
39132      onError: ({
39133        message
39134      }) => onError(message),
39135      additionalData,
39136      allowedTypes
39137    });
39138  }
39139  const ExperimentalBlockEditorProvider = provider_with_registry_provider(props => {
39140    const {
39141      settings: _settings,
39142      registry,
39143      stripExperimentalSettings = false
39144    } = props;
39145    const mediaUploadSettings = use_media_upload_settings(_settings);
39146    let settings = _settings;
39147    if (window.__experimentalMediaProcessing && _settings.mediaUpload) {
39148      // Create a new variable so that the original props.settings.mediaUpload is not modified.
39149      settings = (0,external_wp_element_namespaceObject.useMemo)(() => ({
39150        ..._settings,
39151        mediaUpload: mediaUpload.bind(null, registry)
39152      }), [_settings, registry]);
39153    }
39154    const {
39155      __experimentalUpdateSettings
39156    } = unlock((0,external_wp_data_namespaceObject.useDispatch)(store));
39157    (0,external_wp_element_namespaceObject.useEffect)(() => {
39158      __experimentalUpdateSettings({
39159        ...settings,
39160        __internalIsInitialized: true
39161      }, {
39162        stripExperimentalSettings,
39163        reset: true
39164      });
39165    }, [settings, stripExperimentalSettings, __experimentalUpdateSettings]);
39166  
39167    // Syncs the entity provider with changes in the block-editor store.
39168    useBlockSync(props);
39169    const children = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.SlotFillProvider, {
39170      passthrough: true,
39171      children: [!settings?.isPreviewMode && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(keyboard_shortcuts.Register, {}), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockRefsProvider, {
39172        children: props.children
39173      })]
39174    });
39175    if (window.__experimentalMediaProcessing) {
39176      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(provider, {
39177        settings: mediaUploadSettings,
39178        useSubRegistry: false,
39179        children: children
39180      });
39181    }
39182    return children;
39183  });
39184  const BlockEditorProvider = props => {
39185    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ExperimentalBlockEditorProvider, {
39186      ...props,
39187      stripExperimentalSettings: true,
39188      children: props.children
39189    });
39190  };
39191  /* harmony default export */ const components_provider = (BlockEditorProvider);
39192  
39193  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-context/index.js
39194  /**
39195   * WordPress dependencies
39196   */
39197  
39198  
39199  /** @typedef {import('react').ReactNode} ReactNode */
39200  
39201  /**
39202   * @typedef BlockContextProviderProps
39203   *
39204   * @property {Record<string,*>} value    Context value to merge with current
39205   *                                       value.
39206   * @property {ReactNode}        children Component children.
39207   */
39208  
39209  /** @type {import('react').Context<Record<string,*>>} */
39210  
39211  const block_context_Context = (0,external_wp_element_namespaceObject.createContext)({});
39212  
39213  /**
39214   * Component which merges passed value with current consumed block context.
39215   *
39216   * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/block-context/README.md
39217   *
39218   * @param {BlockContextProviderProps} props
39219   */
39220  function BlockContextProvider({
39221    value,
39222    children
39223  }) {
39224    const context = (0,external_wp_element_namespaceObject.useContext)(block_context_Context);
39225    const nextValue = (0,external_wp_element_namespaceObject.useMemo)(() => ({
39226      ...context,
39227      ...value
39228    }), [context, value]);
39229    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_context_Context.Provider, {
39230      value: nextValue,
39231      children: children
39232    });
39233  }
39234  /* harmony default export */ const block_context = (block_context_Context);
39235  
39236  ;// ./node_modules/@wordpress/block-editor/build-module/utils/block-bindings.js
39237  /**
39238   * WordPress dependencies
39239   */
39240  
39241  
39242  /**
39243   * Internal dependencies
39244   */
39245  
39246  
39247  const DEFAULT_ATTRIBUTE = '__default';
39248  const PATTERN_OVERRIDES_SOURCE = 'core/pattern-overrides';
39249  const BLOCK_BINDINGS_ALLOWED_BLOCKS = {
39250    'core/paragraph': ['content'],
39251    'core/heading': ['content'],
39252    'core/image': ['id', 'url', 'title', 'alt'],
39253    'core/button': ['url', 'text', 'linkTarget', 'rel']
39254  };
39255  
39256  /**
39257   * Checks if the given object is empty.
39258   *
39259   * @param {?Object} object The object to check.
39260   *
39261   * @return {boolean} Whether the object is empty.
39262   */
39263  function isObjectEmpty(object) {
39264    return !object || Object.keys(object).length === 0;
39265  }
39266  
39267  /**
39268   * Based on the given block name, checks if it is possible to bind the block.
39269   *
39270   * @param {string} blockName The name of the block.
39271   *
39272   * @return {boolean} Whether it is possible to bind the block to sources.
39273   */
39274  function canBindBlock(blockName) {
39275    return blockName in BLOCK_BINDINGS_ALLOWED_BLOCKS;
39276  }
39277  
39278  /**
39279   * Based on the given block name and attribute name, checks if it is possible to bind the block attribute.
39280   *
39281   * @param {string} blockName     The name of the block.
39282   * @param {string} attributeName The name of attribute.
39283   *
39284   * @return {boolean} Whether it is possible to bind the block attribute.
39285   */
39286  function canBindAttribute(blockName, attributeName) {
39287    return canBindBlock(blockName) && BLOCK_BINDINGS_ALLOWED_BLOCKS[blockName].includes(attributeName);
39288  }
39289  
39290  /**
39291   * Gets the bindable attributes for a given block.
39292   *
39293   * @param {string} blockName The name of the block.
39294   *
39295   * @return {string[]} The bindable attributes for the block.
39296   */
39297  function getBindableAttributes(blockName) {
39298    return BLOCK_BINDINGS_ALLOWED_BLOCKS[blockName];
39299  }
39300  
39301  /**
39302   * Checks if the block has the `__default` binding for pattern overrides.
39303   *
39304   * @param {?Record<string, object>} bindings A block's bindings from the metadata attribute.
39305   *
39306   * @return {boolean} Whether the block has the `__default` binding for pattern overrides.
39307   */
39308  function hasPatternOverridesDefaultBinding(bindings) {
39309    return bindings?.[DEFAULT_ATTRIBUTE]?.source === PATTERN_OVERRIDES_SOURCE;
39310  }
39311  
39312  /**
39313   * Returns the bindings with the `__default` binding for pattern overrides
39314   * replaced with the full-set of supported attributes. e.g.:
39315   *
39316   * - bindings passed in: `{ __default: { source: 'core/pattern-overrides' } }`
39317   * - bindings returned: `{ content: { source: 'core/pattern-overrides' } }`
39318   *
39319   * @param {string}                  blockName The block name (e.g. 'core/paragraph').
39320   * @param {?Record<string, object>} bindings  A block's bindings from the metadata attribute.
39321   *
39322   * @return {Object} The bindings with default replaced for pattern overrides.
39323   */
39324  function replacePatternOverridesDefaultBinding(blockName, bindings) {
39325    // The `__default` binding currently only works for pattern overrides.
39326    if (hasPatternOverridesDefaultBinding(bindings)) {
39327      const supportedAttributes = BLOCK_BINDINGS_ALLOWED_BLOCKS[blockName];
39328      const bindingsWithDefaults = {};
39329      for (const attributeName of supportedAttributes) {
39330        // If the block has mixed binding sources, retain any non pattern override bindings.
39331        const bindingSource = bindings[attributeName] ? bindings[attributeName] : {
39332          source: PATTERN_OVERRIDES_SOURCE
39333        };
39334        bindingsWithDefaults[attributeName] = bindingSource;
39335      }
39336      return bindingsWithDefaults;
39337    }
39338    return bindings;
39339  }
39340  
39341  /**
39342   * Contains utils to update the block `bindings` metadata.
39343   *
39344   * @typedef {Object} WPBlockBindingsUtils
39345   *
39346   * @property {Function} updateBlockBindings    Updates the value of the bindings connected to block attributes.
39347   * @property {Function} removeAllBlockBindings Removes the bindings property of the `metadata` attribute.
39348   */
39349  
39350  /**
39351   * Retrieves the existing utils needed to update the block `bindings` metadata.
39352   * They can be used to create, modify, or remove connections from the existing block attributes.
39353   *
39354   * It contains the following utils:
39355   * - `updateBlockBindings`: Updates the value of the bindings connected to block attributes. It can be used to remove a specific binding by setting the value to `undefined`.
39356   * - `removeAllBlockBindings`: Removes the bindings property of the `metadata` attribute.
39357   *
39358   * @since 6.7.0 Introduced in WordPress core.
39359   *
39360   * @param {?string} clientId Optional block client ID. If not set, it will use the current block client ID from the context.
39361   *
39362   * @return {?WPBlockBindingsUtils} Object containing the block bindings utils.
39363   *
39364   * @example
39365   * ```js
39366   * import { useBlockBindingsUtils } from '@wordpress/block-editor'
39367   * const { updateBlockBindings, removeAllBlockBindings } = useBlockBindingsUtils();
39368   *
39369   * // Update url and alt attributes.
39370   * updateBlockBindings( {
39371   *     url: {
39372   *         source: 'core/post-meta',
39373   *         args: {
39374   *             key: 'url_custom_field',
39375   *         },
39376   *     },
39377   *     alt: {
39378   *         source: 'core/post-meta',
39379   *         args: {
39380   *             key: 'text_custom_field',
39381   *         },
39382   *     },
39383   * } );
39384   *
39385   * // Remove binding from url attribute.
39386   * updateBlockBindings( { url: undefined } );
39387   *
39388   * // Remove bindings from all attributes.
39389   * removeAllBlockBindings();
39390   * ```
39391   */
39392  function useBlockBindingsUtils(clientId) {
39393    const {
39394      clientId: contextClientId
39395    } = useBlockEditContext();
39396    const blockClientId = clientId || contextClientId;
39397    const {
39398      updateBlockAttributes
39399    } = (0,external_wp_data_namespaceObject.useDispatch)(store);
39400    const {
39401      getBlockAttributes
39402    } = (0,external_wp_data_namespaceObject.useRegistry)().select(store);
39403  
39404    /**
39405     * Updates the value of the bindings connected to block attributes.
39406     * It removes the binding when the new value is `undefined`.
39407     *
39408     * @param {Object} bindings        Bindings including the attributes to update and the new object.
39409     * @param {string} bindings.source The source name to connect to.
39410     * @param {Object} [bindings.args] Object containing the arguments needed by the source.
39411     *
39412     * @example
39413     * ```js
39414     * import { useBlockBindingsUtils } from '@wordpress/block-editor'
39415     *
39416     * const { updateBlockBindings } = useBlockBindingsUtils();
39417     * updateBlockBindings( {
39418     *     url: {
39419     *         source: 'core/post-meta',
39420     *         args: {
39421     *             key: 'url_custom_field',
39422     *         },
39423     *        },
39424     *     alt: {
39425     *         source: 'core/post-meta',
39426     *         args: {
39427     *             key: 'text_custom_field',
39428     *         },
39429     *        }
39430     * } );
39431     * ```
39432     */
39433    const updateBlockBindings = bindings => {
39434      const {
39435        metadata: {
39436          bindings: currentBindings,
39437          ...metadata
39438        } = {}
39439      } = getBlockAttributes(blockClientId);
39440      const newBindings = {
39441        ...currentBindings
39442      };
39443      Object.entries(bindings).forEach(([attribute, binding]) => {
39444        if (!binding && newBindings[attribute]) {
39445          delete newBindings[attribute];
39446          return;
39447        }
39448        newBindings[attribute] = binding;
39449      });
39450      const newMetadata = {
39451        ...metadata,
39452        bindings: newBindings
39453      };
39454      if (isObjectEmpty(newMetadata.bindings)) {
39455        delete newMetadata.bindings;
39456      }
39457      updateBlockAttributes(blockClientId, {
39458        metadata: isObjectEmpty(newMetadata) ? undefined : newMetadata
39459      });
39460    };
39461  
39462    /**
39463     * Removes the bindings property of the `metadata` attribute.
39464     *
39465     * @example
39466     * ```js
39467     * import { useBlockBindingsUtils } from '@wordpress/block-editor'
39468     *
39469     * const { removeAllBlockBindings } = useBlockBindingsUtils();
39470     * removeAllBlockBindings();
39471     * ```
39472     */
39473    const removeAllBlockBindings = () => {
39474      const {
39475        metadata: {
39476          bindings,
39477          ...metadata
39478        } = {}
39479      } = getBlockAttributes(blockClientId);
39480      updateBlockAttributes(blockClientId, {
39481        metadata: isObjectEmpty(metadata) ? undefined : metadata
39482      });
39483    };
39484    return {
39485      updateBlockBindings,
39486      removeAllBlockBindings
39487    };
39488  }
39489  
39490  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-edit/edit.js
39491  /**
39492   * External dependencies
39493   */
39494  
39495  
39496  /**
39497   * WordPress dependencies
39498   */
39499  
39500  
39501  
39502  
39503  
39504  /**
39505   * Internal dependencies
39506   */
39507  
39508  
39509  
39510  
39511  
39512  /**
39513   * Default value used for blocks which do not define their own context needs,
39514   * used to guarantee that a block's `context` prop will always be an object. It
39515   * is assigned as a constant since it is always expected to be an empty object,
39516   * and in order to avoid unnecessary React reconciliations of a changing object.
39517   *
39518   * @type {{}}
39519   */
39520  
39521  const DEFAULT_BLOCK_CONTEXT = {};
39522  const Edit = props => {
39523    const {
39524      name
39525    } = props;
39526    const blockType = (0,external_wp_blocks_namespaceObject.getBlockType)(name);
39527    if (!blockType) {
39528      return null;
39529    }
39530  
39531    // `edit` and `save` are functions or components describing the markup
39532    // with which a block is displayed. If `blockType` is valid, assign
39533    // them preferentially as the render value for the block.
39534    const Component = blockType.edit || blockType.save;
39535    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Component, {
39536      ...props
39537    });
39538  };
39539  const EditWithFilters = (0,external_wp_components_namespaceObject.withFilters)('editor.BlockEdit')(Edit);
39540  const EditWithGeneratedProps = props => {
39541    const {
39542      name,
39543      clientId,
39544      attributes,
39545      setAttributes
39546    } = props;
39547    const registry = (0,external_wp_data_namespaceObject.useRegistry)();
39548    const blockType = (0,external_wp_blocks_namespaceObject.getBlockType)(name);
39549    const blockContext = (0,external_wp_element_namespaceObject.useContext)(block_context);
39550    const registeredSources = (0,external_wp_data_namespaceObject.useSelect)(select => unlock(select(external_wp_blocks_namespaceObject.store)).getAllBlockBindingsSources(), []);
39551    const {
39552      blockBindings,
39553      context,
39554      hasPatternOverrides
39555    } = (0,external_wp_element_namespaceObject.useMemo)(() => {
39556      // Assign context values using the block type's declared context needs.
39557      const computedContext = blockType?.usesContext ? Object.fromEntries(Object.entries(blockContext).filter(([key]) => blockType.usesContext.includes(key))) : DEFAULT_BLOCK_CONTEXT;
39558      // Add context requested by Block Bindings sources.
39559      if (attributes?.metadata?.bindings) {
39560        Object.values(attributes?.metadata?.bindings || {}).forEach(binding => {
39561          registeredSources[binding?.source]?.usesContext?.forEach(key => {
39562            computedContext[key] = blockContext[key];
39563          });
39564        });
39565      }
39566      return {
39567        blockBindings: replacePatternOverridesDefaultBinding(name, attributes?.metadata?.bindings),
39568        context: computedContext,
39569        hasPatternOverrides: hasPatternOverridesDefaultBinding(attributes?.metadata?.bindings)
39570      };
39571    }, [name, blockType?.usesContext, blockContext, attributes?.metadata?.bindings, registeredSources]);
39572    const computedAttributes = (0,external_wp_data_namespaceObject.useSelect)(select => {
39573      if (!blockBindings) {
39574        return attributes;
39575      }
39576      const attributesFromSources = {};
39577      const blockBindingsBySource = new Map();
39578      for (const [attributeName, binding] of Object.entries(blockBindings)) {
39579        const {
39580          source: sourceName,
39581          args: sourceArgs
39582        } = binding;
39583        const source = registeredSources[sourceName];
39584        if (!source || !canBindAttribute(name, attributeName)) {
39585          continue;
39586        }
39587        blockBindingsBySource.set(source, {
39588          ...blockBindingsBySource.get(source),
39589          [attributeName]: {
39590            args: sourceArgs
39591          }
39592        });
39593      }
39594      if (blockBindingsBySource.size) {
39595        for (const [source, bindings] of blockBindingsBySource) {
39596          // Get values in batch if the source supports it.
39597          let values = {};
39598          if (!source.getValues) {
39599            Object.keys(bindings).forEach(attr => {
39600              // Default to the the source label when `getValues` doesn't exist.
39601              values[attr] = source.label;
39602            });
39603          } else {
39604            values = source.getValues({
39605              select,
39606              context,
39607              clientId,
39608              bindings
39609            });
39610          }
39611          for (const [attributeName, value] of Object.entries(values)) {
39612            if (attributeName === 'url' && (!value || !isURLLike(value))) {
39613              // Return null if value is not a valid URL.
39614              attributesFromSources[attributeName] = null;
39615            } else {
39616              attributesFromSources[attributeName] = value;
39617            }
39618          }
39619        }
39620      }
39621      return {
39622        ...attributes,
39623        ...attributesFromSources
39624      };
39625    }, [attributes, blockBindings, clientId, context, name, registeredSources]);
39626    const setBoundAttributes = (0,external_wp_element_namespaceObject.useCallback)(nextAttributes => {
39627      if (!blockBindings) {
39628        setAttributes(nextAttributes);
39629        return;
39630      }
39631      registry.batch(() => {
39632        const keptAttributes = {
39633          ...nextAttributes
39634        };
39635        const blockBindingsBySource = new Map();
39636  
39637        // Loop only over the updated attributes to avoid modifying the bound ones that haven't changed.
39638        for (const [attributeName, newValue] of Object.entries(keptAttributes)) {
39639          if (!blockBindings[attributeName] || !canBindAttribute(name, attributeName)) {
39640            continue;
39641          }
39642          const binding = blockBindings[attributeName];
39643          const source = registeredSources[binding?.source];
39644          if (!source?.setValues) {
39645            continue;
39646          }
39647          blockBindingsBySource.set(source, {
39648            ...blockBindingsBySource.get(source),
39649            [attributeName]: {
39650              args: binding.args,
39651              newValue
39652            }
39653          });
39654          delete keptAttributes[attributeName];
39655        }
39656        if (blockBindingsBySource.size) {
39657          for (const [source, bindings] of blockBindingsBySource) {
39658            source.setValues({
39659              select: registry.select,
39660              dispatch: registry.dispatch,
39661              context,
39662              clientId,
39663              bindings
39664            });
39665          }
39666        }
39667        const hasParentPattern = !!context['pattern/overrides'];
39668        if (
39669        // Don't update non-connected attributes if the block is using pattern overrides
39670        // and the editing is happening while overriding the pattern (not editing the original).
39671        !(hasPatternOverrides && hasParentPattern) && Object.keys(keptAttributes).length) {
39672          // Don't update caption and href until they are supported.
39673          if (hasPatternOverrides) {
39674            delete keptAttributes.caption;
39675            delete keptAttributes.href;
39676          }
39677          setAttributes(keptAttributes);
39678        }
39679      });
39680    }, [blockBindings, clientId, context, hasPatternOverrides, setAttributes, registeredSources, name, registry]);
39681    if (!blockType) {
39682      return null;
39683    }
39684    if (blockType.apiVersion > 1) {
39685      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(EditWithFilters, {
39686        ...props,
39687        attributes: computedAttributes,
39688        context: context,
39689        setAttributes: setBoundAttributes
39690      });
39691    }
39692  
39693    // Generate a class name for the block's editable form.
39694    const generatedClassName = (0,external_wp_blocks_namespaceObject.hasBlockSupport)(blockType, 'className', true) ? (0,external_wp_blocks_namespaceObject.getBlockDefaultClassName)(name) : null;
39695    const className = dist_clsx(generatedClassName, attributes?.className, props.className);
39696    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(EditWithFilters, {
39697      ...props,
39698      attributes: computedAttributes,
39699      className: className,
39700      context: context,
39701      setAttributes: setBoundAttributes
39702    });
39703  };
39704  /* harmony default export */ const block_edit_edit = (EditWithGeneratedProps);
39705  
39706  ;// ./node_modules/@wordpress/icons/build-module/library/more-vertical.js
39707  /**
39708   * WordPress dependencies
39709   */
39710  
39711  
39712  const moreVertical = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
39713    xmlns: "http://www.w3.org/2000/svg",
39714    viewBox: "0 0 24 24",
39715    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
39716      d: "M13 19h-2v-2h2v2zm0-6h-2v-2h2v2zm0-6h-2V5h2v2z"
39717    })
39718  });
39719  /* harmony default export */ const more_vertical = (moreVertical);
39720  
39721  ;// ./node_modules/@wordpress/block-editor/build-module/components/warning/index.js
39722  /**
39723   * External dependencies
39724   */
39725  
39726  
39727  /**
39728   * WordPress dependencies
39729   */
39730  
39731  
39732  
39733  
39734  function Warning({
39735    className,
39736    actions,
39737    children,
39738    secondaryActions
39739  }) {
39740    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
39741      style: {
39742        display: 'contents',
39743        all: 'initial'
39744      },
39745      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
39746        className: dist_clsx(className, 'block-editor-warning'),
39747        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
39748          className: "block-editor-warning__contents",
39749          children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("p", {
39750            className: "block-editor-warning__message",
39751            children: children
39752          }), (actions?.length > 0 || secondaryActions) && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
39753            className: "block-editor-warning__actions",
39754            children: [actions?.length > 0 && actions.map((action, i) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("span", {
39755              className: "block-editor-warning__action",
39756              children: action
39757            }, i)), secondaryActions && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.DropdownMenu, {
39758              className: "block-editor-warning__secondary",
39759              icon: more_vertical,
39760              label: (0,external_wp_i18n_namespaceObject.__)('More options'),
39761              popoverProps: {
39762                position: 'bottom left',
39763                className: 'block-editor-warning__dropdown'
39764              },
39765              noIcons: true,
39766              children: () => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuGroup, {
39767                children: secondaryActions.map((item, pos) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, {
39768                  onClick: item.onClick,
39769                  children: item.title
39770                }, pos))
39771              })
39772            })]
39773          })]
39774        })
39775      })
39776    });
39777  }
39778  
39779  /**
39780   * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/warning/README.md
39781   */
39782  /* harmony default export */ const warning = (Warning);
39783  
39784  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-edit/multiple-usage-warning.js
39785  /**
39786   * WordPress dependencies
39787   */
39788  
39789  
39790  
39791  
39792  
39793  /**
39794   * Internal dependencies
39795   */
39796  
39797  
39798  
39799  function MultipleUsageWarning({
39800    originalBlockClientId,
39801    name,
39802    onReplace
39803  }) {
39804    const {
39805      selectBlock
39806    } = (0,external_wp_data_namespaceObject.useDispatch)(store);
39807    const blockType = (0,external_wp_blocks_namespaceObject.getBlockType)(name);
39808    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(warning, {
39809      actions: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
39810        __next40pxDefaultSize: true,
39811        variant: "secondary",
39812        onClick: () => selectBlock(originalBlockClientId),
39813        children: (0,external_wp_i18n_namespaceObject.__)('Find original')
39814      }, "find-original"), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
39815        __next40pxDefaultSize: true,
39816        variant: "secondary",
39817        onClick: () => onReplace([]),
39818        children: (0,external_wp_i18n_namespaceObject.__)('Remove')
39819      }, "remove")],
39820      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("strong", {
39821        children: [blockType?.title, ": "]
39822      }), (0,external_wp_i18n_namespaceObject.__)('This block can only be used once.')]
39823    });
39824  }
39825  
39826  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-list/private-block-context.js
39827  /**
39828   * WordPress dependencies
39829   */
39830  
39831  const PrivateBlockContext = (0,external_wp_element_namespaceObject.createContext)({});
39832  
39833  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-edit/index.js
39834  /**
39835   * WordPress dependencies
39836   */
39837  
39838  
39839  
39840  /**
39841   * Internal dependencies
39842   */
39843  
39844  
39845  
39846  
39847  
39848  /**
39849   * The `useBlockEditContext` hook provides information about the block this hook is being used in.
39850   * It returns an object with the `name`, `isSelected` state, and the `clientId` of the block.
39851   * It is useful if you want to create custom hooks that need access to the current blocks clientId
39852   * but don't want to rely on the data getting passed in as a parameter.
39853   *
39854   * @return {Object} Block edit context
39855   */
39856  
39857  
39858  function BlockEdit({
39859    mayDisplayControls,
39860    mayDisplayParentControls,
39861    blockEditingMode,
39862    isPreviewMode,
39863    // The remaining props are passed through the BlockEdit filters and are thus
39864    // public API!
39865    ...props
39866  }) {
39867    const {
39868      name,
39869      isSelected,
39870      clientId,
39871      attributes = {},
39872      __unstableLayoutClassNames
39873    } = props;
39874    const {
39875      layout = null,
39876      metadata = {}
39877    } = attributes;
39878    const {
39879      bindings
39880    } = metadata;
39881    const layoutSupport = (0,external_wp_blocks_namespaceObject.hasBlockSupport)(name, 'layout', false) || (0,external_wp_blocks_namespaceObject.hasBlockSupport)(name, '__experimentalLayout', false);
39882    const {
39883      originalBlockClientId
39884    } = (0,external_wp_element_namespaceObject.useContext)(PrivateBlockContext);
39885    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(Provider
39886    // It is important to return the same object if props haven't
39887    // changed to avoid  unnecessary rerenders.
39888    // See https://reactjs.org/docs/context.html#caveats.
39889    , {
39890      value: (0,external_wp_element_namespaceObject.useMemo)(() => ({
39891        name,
39892        isSelected,
39893        clientId,
39894        layout: layoutSupport ? layout : null,
39895        __unstableLayoutClassNames,
39896        // We use symbols in favour of an __unstable prefix to avoid
39897        // usage outside of the package (this context is exposed).
39898        [mayDisplayControlsKey]: mayDisplayControls,
39899        [mayDisplayParentControlsKey]: mayDisplayParentControls,
39900        [blockEditingModeKey]: blockEditingMode,
39901        [blockBindingsKey]: bindings,
39902        [isPreviewModeKey]: isPreviewMode
39903      }), [name, isSelected, clientId, layoutSupport, layout, __unstableLayoutClassNames, mayDisplayControls, mayDisplayParentControls, blockEditingMode, bindings, isPreviewMode]),
39904      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_edit_edit, {
39905        ...props
39906      }), originalBlockClientId && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(MultipleUsageWarning, {
39907        originalBlockClientId: originalBlockClientId,
39908        name: name,
39909        onReplace: props.onReplace
39910      })]
39911    });
39912  }
39913  
39914  // EXTERNAL MODULE: ./node_modules/diff/lib/diff/character.js
39915  var character = __webpack_require__(8021);
39916  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-compare/block-view.js
39917  /**
39918   * WordPress dependencies
39919   */
39920  
39921  
39922  
39923  
39924  function BlockView({
39925    title,
39926    rawContent,
39927    renderedContent,
39928    action,
39929    actionText,
39930    className
39931  }) {
39932    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
39933      className: className,
39934      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
39935        className: "block-editor-block-compare__content",
39936        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("h2", {
39937          className: "block-editor-block-compare__heading",
39938          children: title
39939        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
39940          className: "block-editor-block-compare__html",
39941          children: rawContent
39942        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
39943          className: "block-editor-block-compare__preview edit-post-visual-editor",
39944          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_element_namespaceObject.RawHTML, {
39945            children: (0,external_wp_dom_namespaceObject.safeHTML)(renderedContent)
39946          })
39947        })]
39948      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
39949        className: "block-editor-block-compare__action",
39950        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
39951          __next40pxDefaultSize: true,
39952          variant: "secondary",
39953          tabIndex: "0",
39954          onClick: action,
39955          children: actionText
39956        })
39957      })]
39958    });
39959  }
39960  
39961  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-compare/index.js
39962  /**
39963   * External dependencies
39964   */
39965  
39966  // diff doesn't tree-shake correctly, so we import from the individual
39967  // module here, to avoid including too much of the library
39968  
39969  
39970  /**
39971   * WordPress dependencies
39972   */
39973  
39974  
39975  
39976  /**
39977   * Internal dependencies
39978   */
39979  
39980  
39981  function BlockCompare({
39982    block,
39983    onKeep,
39984    onConvert,
39985    convertor,
39986    convertButtonText
39987  }) {
39988    function getDifference(originalContent, newContent) {
39989      const difference = (0,character/* diffChars */.JJ)(originalContent, newContent);
39990      return difference.map((item, pos) => {
39991        const classes = dist_clsx({
39992          'block-editor-block-compare__added': item.added,
39993          'block-editor-block-compare__removed': item.removed
39994        });
39995        return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("span", {
39996          className: classes,
39997          children: item.value
39998        }, pos);
39999      });
40000    }
40001    function getConvertedContent(convertedBlock) {
40002      // The convertor may return an array of items or a single item.
40003      const newBlocks = Array.isArray(convertedBlock) ? convertedBlock : [convertedBlock];
40004  
40005      // Get converted block details.
40006      const newContent = newBlocks.map(item => (0,external_wp_blocks_namespaceObject.getSaveContent)(item.name, item.attributes, item.innerBlocks));
40007      return newContent.join('');
40008    }
40009    const converted = getConvertedContent(convertor(block));
40010    const difference = getDifference(block.originalContent, converted);
40011    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
40012      className: "block-editor-block-compare__wrapper",
40013      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockView, {
40014        title: (0,external_wp_i18n_namespaceObject.__)('Current'),
40015        className: "block-editor-block-compare__current",
40016        action: onKeep,
40017        actionText: (0,external_wp_i18n_namespaceObject.__)('Convert to HTML'),
40018        rawContent: block.originalContent,
40019        renderedContent: block.originalContent
40020      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockView, {
40021        title: (0,external_wp_i18n_namespaceObject.__)('After Conversion'),
40022        className: "block-editor-block-compare__converted",
40023        action: onConvert,
40024        actionText: convertButtonText,
40025        rawContent: difference,
40026        renderedContent: converted
40027      })]
40028    });
40029  }
40030  /* harmony default export */ const block_compare = (BlockCompare);
40031  
40032  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-list/block-invalid-warning.js
40033  /**
40034   * WordPress dependencies
40035   */
40036  
40037  
40038  
40039  
40040  
40041  
40042  /**
40043   * Internal dependencies
40044   */
40045  
40046  
40047  
40048  
40049  const blockToBlocks = block => (0,external_wp_blocks_namespaceObject.rawHandler)({
40050    HTML: block.originalContent
40051  });
40052  function BlockInvalidWarning({
40053    clientId
40054  }) {
40055    const {
40056      block,
40057      canInsertHTMLBlock,
40058      canInsertClassicBlock
40059    } = (0,external_wp_data_namespaceObject.useSelect)(select => {
40060      const {
40061        canInsertBlockType,
40062        getBlock,
40063        getBlockRootClientId
40064      } = select(store);
40065      const rootClientId = getBlockRootClientId(clientId);
40066      return {
40067        block: getBlock(clientId),
40068        canInsertHTMLBlock: canInsertBlockType('core/html', rootClientId),
40069        canInsertClassicBlock: canInsertBlockType('core/freeform', rootClientId)
40070      };
40071    }, [clientId]);
40072    const {
40073      replaceBlock
40074    } = (0,external_wp_data_namespaceObject.useDispatch)(store);
40075    const [compare, setCompare] = (0,external_wp_element_namespaceObject.useState)(false);
40076    const onCompareClose = (0,external_wp_element_namespaceObject.useCallback)(() => setCompare(false), []);
40077    const convert = (0,external_wp_element_namespaceObject.useMemo)(() => ({
40078      toClassic() {
40079        const classicBlock = (0,external_wp_blocks_namespaceObject.createBlock)('core/freeform', {
40080          content: block.originalContent
40081        });
40082        return replaceBlock(block.clientId, classicBlock);
40083      },
40084      toHTML() {
40085        const htmlBlock = (0,external_wp_blocks_namespaceObject.createBlock)('core/html', {
40086          content: block.originalContent
40087        });
40088        return replaceBlock(block.clientId, htmlBlock);
40089      },
40090      toBlocks() {
40091        const newBlocks = blockToBlocks(block);
40092        return replaceBlock(block.clientId, newBlocks);
40093      },
40094      toRecoveredBlock() {
40095        const recoveredBlock = (0,external_wp_blocks_namespaceObject.createBlock)(block.name, block.attributes, block.innerBlocks);
40096        return replaceBlock(block.clientId, recoveredBlock);
40097      }
40098    }), [block, replaceBlock]);
40099    const secondaryActions = (0,external_wp_element_namespaceObject.useMemo)(() => [{
40100      // translators: Button to fix block content
40101      title: (0,external_wp_i18n_namespaceObject._x)('Resolve', 'imperative verb'),
40102      onClick: () => setCompare(true)
40103    }, canInsertHTMLBlock && {
40104      title: (0,external_wp_i18n_namespaceObject.__)('Convert to HTML'),
40105      onClick: convert.toHTML
40106    }, canInsertClassicBlock && {
40107      title: (0,external_wp_i18n_namespaceObject.__)('Convert to Classic Block'),
40108      onClick: convert.toClassic
40109    }].filter(Boolean), [canInsertHTMLBlock, canInsertClassicBlock, convert]);
40110    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
40111      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(warning, {
40112        actions: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
40113          __next40pxDefaultSize: true,
40114          onClick: convert.toRecoveredBlock,
40115          variant: "primary",
40116          children: (0,external_wp_i18n_namespaceObject.__)('Attempt recovery')
40117        }, "recover")],
40118        secondaryActions: secondaryActions,
40119        children: (0,external_wp_i18n_namespaceObject.__)('Block contains unexpected or invalid content.')
40120      }), compare && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Modal, {
40121        title:
40122        // translators: Dialog title to fix block content
40123        (0,external_wp_i18n_namespaceObject.__)('Resolve Block'),
40124        onRequestClose: onCompareClose,
40125        className: "block-editor-block-compare",
40126        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_compare, {
40127          block: block,
40128          onKeep: convert.toHTML,
40129          onConvert: convert.toBlocks,
40130          convertor: blockToBlocks,
40131          convertButtonText: (0,external_wp_i18n_namespaceObject.__)('Convert to Blocks')
40132        })
40133      })]
40134    });
40135  }
40136  
40137  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-list/block-crash-warning.js
40138  /**
40139   * WordPress dependencies
40140   */
40141  
40142  
40143  /**
40144   * Internal dependencies
40145   */
40146  
40147  
40148  const block_crash_warning_warning = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(warning, {
40149    className: "block-editor-block-list__block-crash-warning",
40150    children: (0,external_wp_i18n_namespaceObject.__)('This block has encountered an error and cannot be previewed.')
40151  });
40152  /* harmony default export */ const block_crash_warning = (() => block_crash_warning_warning);
40153  
40154  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-list/block-crash-boundary.js
40155  /**
40156   * WordPress dependencies
40157   */
40158  
40159  class BlockCrashBoundary extends external_wp_element_namespaceObject.Component {
40160    constructor() {
40161      super(...arguments);
40162      this.state = {
40163        hasError: false
40164      };
40165    }
40166    componentDidCatch() {
40167      this.setState({
40168        hasError: true
40169      });
40170    }
40171    render() {
40172      if (this.state.hasError) {
40173        return this.props.fallback;
40174      }
40175      return this.props.children;
40176    }
40177  }
40178  /* harmony default export */ const block_crash_boundary = (BlockCrashBoundary);
40179  
40180  // EXTERNAL MODULE: ./node_modules/react-autosize-textarea/lib/index.js
40181  var lib = __webpack_require__(4132);
40182  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-list/block-html.js
40183  /**
40184   * External dependencies
40185   */
40186  
40187  
40188  /**
40189   * WordPress dependencies
40190   */
40191  
40192  
40193  
40194  
40195  /**
40196   * Internal dependencies
40197   */
40198  
40199  
40200  function BlockHTML({
40201    clientId
40202  }) {
40203    const [html, setHtml] = (0,external_wp_element_namespaceObject.useState)('');
40204    const block = (0,external_wp_data_namespaceObject.useSelect)(select => select(store).getBlock(clientId), [clientId]);
40205    const {
40206      updateBlock
40207    } = (0,external_wp_data_namespaceObject.useDispatch)(store);
40208    const onChange = () => {
40209      const blockType = (0,external_wp_blocks_namespaceObject.getBlockType)(block.name);
40210      if (!blockType) {
40211        return;
40212      }
40213      const attributes = (0,external_wp_blocks_namespaceObject.getBlockAttributes)(blockType, html, block.attributes);
40214  
40215      // If html is empty  we reset the block to the default HTML and mark it as valid to avoid triggering an error
40216      const content = html ? html : (0,external_wp_blocks_namespaceObject.getSaveContent)(blockType, attributes);
40217      const [isValid] = html ? (0,external_wp_blocks_namespaceObject.validateBlock)({
40218        ...block,
40219        attributes,
40220        originalContent: content
40221      }) : [true];
40222      updateBlock(clientId, {
40223        attributes,
40224        originalContent: content,
40225        isValid
40226      });
40227  
40228      // Ensure the state is updated if we reset so it displays the default content.
40229      if (!html) {
40230        setHtml(content);
40231      }
40232    };
40233    (0,external_wp_element_namespaceObject.useEffect)(() => {
40234      setHtml((0,external_wp_blocks_namespaceObject.getBlockContent)(block));
40235    }, [block]);
40236    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(lib/* default */.A, {
40237      className: "block-editor-block-list__block-html-textarea",
40238      value: html,
40239      onBlur: onChange,
40240      onChange: event => setHtml(event.target.value)
40241    });
40242  }
40243  /* harmony default export */ const block_html = (BlockHTML);
40244  
40245  ;// ./node_modules/@react-spring/rafz/dist/esm/index.js
40246  var esm_f=esm_l(),esm_n=e=>esm_c(e,esm_f),esm_m=esm_l();esm_n.write=e=>esm_c(e,esm_m);var esm_d=esm_l();esm_n.onStart=e=>esm_c(e,esm_d);var esm_h=esm_l();esm_n.onFrame=e=>esm_c(e,esm_h);var esm_p=esm_l();esm_n.onFinish=e=>esm_c(e,esm_p);var esm_i=[];esm_n.setTimeout=(e,t)=>{let a=esm_n.now()+t,o=()=>{let F=esm_i.findIndex(z=>z.cancel==o);~F&&esm_i.splice(F,1),esm_u-=~F?1:0},s={time:a,handler:e,cancel:o};return esm_i.splice(esm_w(a),0,s),esm_u+=1,esm_v(),s};var esm_w=e=>~(~esm_i.findIndex(t=>t.time>e)||~esm_i.length);esm_n.cancel=e=>{esm_d.delete(e),esm_h.delete(e),esm_p.delete(e),esm_f.delete(e),esm_m.delete(e)};esm_n.sync=e=>{T=!0,esm_n.batchedUpdates(e),T=!1};esm_n.throttle=e=>{let t;function a(){try{e(...t)}finally{t=null}}function o(...s){t=s,esm_n.onStart(a)}return o.handler=e,o.cancel=()=>{esm_d.delete(a),t=null},o};var esm_y=typeof window<"u"?window.requestAnimationFrame:()=>{};esm_n.use=e=>esm_y=e;esm_n.now=typeof performance<"u"?()=>performance.now():Date.now;esm_n.batchedUpdates=e=>e();esm_n.catch=console.error;esm_n.frameLoop="always";esm_n.advance=()=>{esm_n.frameLoop!=="demand"?console.warn("Cannot call the manual advancement of rafz whilst frameLoop is not set as demand"):esm_x()};var esm_r=-1,esm_u=0,T=!1;function esm_c(e,t){T?(t.delete(e),e(0)):(t.add(e),esm_v())}function esm_v(){esm_r<0&&(esm_r=0,esm_n.frameLoop!=="demand"&&esm_y(esm_b))}function esm_R(){esm_r=-1}function esm_b(){~esm_r&&(esm_y(esm_b),esm_n.batchedUpdates(esm_x))}function esm_x(){let e=esm_r;esm_r=esm_n.now();let t=esm_w(esm_r);if(t&&(Q(esm_i.splice(0,t),a=>a.handler()),esm_u-=t),!esm_u){esm_R();return}esm_d.flush(),esm_f.flush(e?Math.min(64,esm_r-e):16.667),esm_h.flush(),esm_m.flush(),esm_p.flush()}function esm_l(){let e=new Set,t=e;return{add(a){esm_u+=t==e&&!e.has(a)?1:0,e.add(a)},delete(a){return esm_u-=t==e&&e.has(a)?1:0,e.delete(a)},flush(a){t.size&&(e=new Set,esm_u-=t.size,Q(t,o=>o(a)&&e.add(o)),esm_u+=e.size,t=e)}}}function Q(e,t){e.forEach(a=>{try{t(a)}catch(o){esm_n.catch(o)}})}var esm_S={count(){return esm_u},isRunning(){return esm_r>=0},clear(){esm_r=-1,esm_i=[],esm_d=esm_l(),esm_f=esm_l(),esm_h=esm_l(),esm_m=esm_l(),esm_p=esm_l(),esm_u=0}};
40247  
40248  ;// ./node_modules/@react-spring/shared/dist/esm/index.js
40249  var ze=Object.defineProperty;var Le=(e,t)=>{for(var r in t)ze(e,r,{get:t[r],enumerable:!0})};var dist_esm_p={};Le(dist_esm_p,{assign:()=>U,colors:()=>dist_esm_c,createStringInterpolator:()=>esm_k,skipAnimation:()=>ee,to:()=>J,willAdvance:()=>dist_esm_S});function Y(){}var mt=(e,t,r)=>Object.defineProperty(e,t,{value:r,writable:!0,configurable:!0}),dist_esm_l={arr:Array.isArray,obj:e=>!!e&&e.constructor.name==="Object",fun:e=>typeof e=="function",str:e=>typeof e=="string",num:e=>typeof e=="number",und:e=>e===void 0};function bt(e,t){if(dist_esm_l.arr(e)){if(!dist_esm_l.arr(t)||e.length!==t.length)return!1;for(let r=0;r<e.length;r++)if(e[r]!==t[r])return!1;return!0}return e===t}var esm_Ve=(e,t)=>e.forEach(t);function xt(e,t,r){if(dist_esm_l.arr(e)){for(let n=0;n<e.length;n++)t.call(r,e[n],`$n}`);return}for(let n in e)e.hasOwnProperty(n)&&t.call(r,e[n],n)}var ht=e=>dist_esm_l.und(e)?[]:dist_esm_l.arr(e)?e:[e];function Pe(e,t){if(e.size){let r=Array.from(e);e.clear(),esm_Ve(r,t)}}var yt=(e,...t)=>Pe(e,r=>r(...t)),dist_esm_h=()=>typeof window>"u"||!window.navigator||/ServerSideRendering|^Deno\//.test(window.navigator.userAgent);var esm_k,J,dist_esm_c=null,ee=!1,dist_esm_S=Y,U=e=>{e.to&&(J=e.to),e.now&&(esm_n.now=e.now),e.colors!==void 0&&(dist_esm_c=e.colors),e.skipAnimation!=null&&(ee=e.skipAnimation),e.createStringInterpolator&&(esm_k=e.createStringInterpolator),e.requestAnimationFrame&&esm_n.use(e.requestAnimationFrame),e.batchedUpdates&&(esm_n.batchedUpdates=e.batchedUpdates),e.willAdvance&&(dist_esm_S=e.willAdvance),e.frameLoop&&(esm_n.frameLoop=e.frameLoop)};var esm_E=new Set,dist_esm_u=[],esm_H=[],A=0,qe={get idle(){return!esm_E.size&&!dist_esm_u.length},start(e){A>e.priority?(esm_E.add(e),esm_n.onStart($e)):(te(e),esm_n(B))},advance:B,sort(e){if(A)esm_n.onFrame(()=>qe.sort(e));else{let t=dist_esm_u.indexOf(e);~t&&(dist_esm_u.splice(t,1),re(e))}},clear(){dist_esm_u=[],esm_E.clear()}};function $e(){esm_E.forEach(te),esm_E.clear(),esm_n(B)}function te(e){dist_esm_u.includes(e)||re(e)}function re(e){dist_esm_u.splice(Ge(dist_esm_u,t=>t.priority>e.priority),0,e)}function B(e){let t=esm_H;for(let r=0;r<dist_esm_u.length;r++){let n=dist_esm_u[r];A=n.priority,n.idle||(dist_esm_S(n),n.advance(e),n.idle||t.push(n))}return A=0,esm_H=dist_esm_u,esm_H.length=0,dist_esm_u=t,dist_esm_u.length>0}function Ge(e,t){let r=e.findIndex(t);return r<0?e.length:r}var ne=(e,t,r)=>Math.min(Math.max(r,e),t);var It={transparent:0,aliceblue:4042850303,antiquewhite:4209760255,aqua:16777215,aquamarine:2147472639,azure:4043309055,beige:4126530815,bisque:4293182719,black:255,blanchedalmond:4293643775,blue:65535,blueviolet:2318131967,brown:2771004159,burlywood:3736635391,burntsienna:3934150143,cadetblue:1604231423,chartreuse:2147418367,chocolate:3530104575,coral:4286533887,cornflowerblue:1687547391,cornsilk:4294499583,crimson:3692313855,cyan:16777215,darkblue:35839,darkcyan:9145343,darkgoldenrod:3095792639,darkgray:2846468607,darkgreen:6553855,darkgrey:2846468607,darkkhaki:3182914559,darkmagenta:2332068863,darkolivegreen:1433087999,darkorange:4287365375,darkorchid:2570243327,darkred:2332033279,darksalmon:3918953215,darkseagreen:2411499519,darkslateblue:1211993087,darkslategray:793726975,darkslategrey:793726975,darkturquoise:13554175,darkviolet:2483082239,deeppink:4279538687,deepskyblue:12582911,dimgray:1768516095,dimgrey:1768516095,dodgerblue:512819199,firebrick:2988581631,floralwhite:4294635775,forestgreen:579543807,fuchsia:4278255615,gainsboro:3705462015,ghostwhite:4177068031,gold:4292280575,goldenrod:3668254975,gray:2155905279,green:8388863,greenyellow:2919182335,grey:2155905279,honeydew:4043305215,hotpink:4285117695,indianred:3445382399,indigo:1258324735,ivory:4294963455,khaki:4041641215,lavender:3873897215,lavenderblush:4293981695,lawngreen:2096890111,lemonchiffon:4294626815,lightblue:2916673279,lightcoral:4034953471,lightcyan:3774873599,lightgoldenrodyellow:4210742015,lightgray:3553874943,lightgreen:2431553791,lightgrey:3553874943,lightpink:4290167295,lightsalmon:4288707327,lightseagreen:548580095,lightskyblue:2278488831,lightslategray:2005441023,lightslategrey:2005441023,lightsteelblue:2965692159,lightyellow:4294959359,lime:16711935,limegreen:852308735,linen:4210091775,magenta:4278255615,maroon:2147483903,mediumaquamarine:1724754687,mediumblue:52735,mediumorchid:3126187007,mediumpurple:2473647103,mediumseagreen:1018393087,mediumslateblue:2070474495,mediumspringgreen:16423679,mediumturquoise:1221709055,mediumvioletred:3340076543,midnightblue:421097727,mintcream:4127193855,mistyrose:4293190143,moccasin:4293178879,navajowhite:4292783615,navy:33023,oldlace:4260751103,olive:2155872511,olivedrab:1804477439,orange:4289003775,orangered:4282712319,orchid:3664828159,palegoldenrod:4008225535,palegreen:2566625535,paleturquoise:2951671551,palevioletred:3681588223,papayawhip:4293907967,peachpuff:4292524543,peru:3448061951,pink:4290825215,plum:3718307327,powderblue:2967529215,purple:2147516671,rebeccapurple:1714657791,red:4278190335,rosybrown:3163525119,royalblue:1097458175,saddlebrown:2336560127,salmon:4202722047,sandybrown:4104413439,seagreen:780883967,seashell:4294307583,sienna:2689740287,silver:3233857791,skyblue:2278484991,slateblue:1784335871,slategray:1887473919,slategrey:1887473919,snow:4294638335,springgreen:16744447,steelblue:1182971135,tan:3535047935,teal:8421631,thistle:3636451583,tomato:4284696575,turquoise:1088475391,violet:4001558271,wheat:4125012991,white:4294967295,whitesmoke:4126537215,yellow:4294902015,yellowgreen:2597139199};var dist_esm_d="[-+]?\\d*\\.?\\d+",esm_M=dist_esm_d+"%";function C(...e){return"\\(\\s*("+e.join(")\\s*,\\s*(")+")\\s*\\)"}var oe=new RegExp("rgb"+C(dist_esm_d,dist_esm_d,dist_esm_d)),fe=new RegExp("rgba"+C(dist_esm_d,dist_esm_d,dist_esm_d,dist_esm_d)),ae=new RegExp("hsl"+C(dist_esm_d,esm_M,esm_M)),ie=new RegExp("hsla"+C(dist_esm_d,esm_M,esm_M,dist_esm_d)),se=/^#([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/,ue=/^#([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/,le=/^#([0-9a-fA-F]{6})$/,esm_ce=/^#([0-9a-fA-F]{8})$/;function be(e){let t;return typeof e=="number"?e>>>0===e&&e>=0&&e<=4294967295?e:null:(t=le.exec(e))?parseInt(t[1]+"ff",16)>>>0:dist_esm_c&&dist_esm_c[e]!==void 0?dist_esm_c[e]:(t=oe.exec(e))?(dist_esm_y(t[1])<<24|dist_esm_y(t[2])<<16|dist_esm_y(t[3])<<8|255)>>>0:(t=fe.exec(e))?(dist_esm_y(t[1])<<24|dist_esm_y(t[2])<<16|dist_esm_y(t[3])<<8|me(t[4]))>>>0:(t=se.exec(e))?parseInt(t[1]+t[1]+t[2]+t[2]+t[3]+t[3]+"ff",16)>>>0:(t=esm_ce.exec(e))?parseInt(t[1],16)>>>0:(t=ue.exec(e))?parseInt(t[1]+t[1]+t[2]+t[2]+t[3]+t[3]+t[4]+t[4],16)>>>0:(t=ae.exec(e))?(de(esm_pe(t[1]),esm_z(t[2]),esm_z(t[3]))|255)>>>0:(t=ie.exec(e))?(de(esm_pe(t[1]),esm_z(t[2]),esm_z(t[3]))|me(t[4]))>>>0:null}function esm_j(e,t,r){return r<0&&(r+=1),r>1&&(r-=1),r<1/6?e+(t-e)*6*r:r<1/2?t:r<2/3?e+(t-e)*(2/3-r)*6:e}function de(e,t,r){let n=r<.5?r*(1+t):r+t-r*t,f=2*r-n,o=esm_j(f,n,e+1/3),i=esm_j(f,n,e),s=esm_j(f,n,e-1/3);return Math.round(o*255)<<24|Math.round(i*255)<<16|Math.round(s*255)<<8}function dist_esm_y(e){let t=parseInt(e,10);return t<0?0:t>255?255:t}function esm_pe(e){return(parseFloat(e)%360+360)%360/360}function me(e){let t=parseFloat(e);return t<0?0:t>1?255:Math.round(t*255)}function esm_z(e){let t=parseFloat(e);return t<0?0:t>100?1:t/100}function D(e){let t=be(e);if(t===null)return e;t=t||0;let r=(t&4278190080)>>>24,n=(t&16711680)>>>16,f=(t&65280)>>>8,o=(t&255)/255;return`rgba($r}, $n}, $f}, $o})`}var W=(e,t,r)=>{if(dist_esm_l.fun(e))return e;if(dist_esm_l.arr(e))return W({range:e,output:t,extrapolate:r});if(dist_esm_l.str(e.output[0]))return esm_k(e);let n=e,f=n.output,o=n.range||[0,1],i=n.extrapolateLeft||n.extrapolate||"extend",s=n.extrapolateRight||n.extrapolate||"extend",x=n.easing||(a=>a);return a=>{let F=He(a,o);return Ue(a,o[F],o[F+1],f[F],f[F+1],x,i,s,n.map)}};function Ue(e,t,r,n,f,o,i,s,x){let a=x?x(e):e;if(a<t){if(i==="identity")return a;i==="clamp"&&(a=t)}if(a>r){if(s==="identity")return a;s==="clamp"&&(a=r)}return n===f?n:t===r?e<=t?n:f:(t===-1/0?a=-a:r===1/0?a=a-t:a=(a-t)/(r-t),a=o(a),n===-1/0?a=-a:f===1/0?a=a+n:a=a*(f-n)+n,a)}function He(e,t){for(var r=1;r<t.length-1&&!(t[r]>=e);++r);return r-1}var Be=(e,t="end")=>r=>{r=t==="end"?Math.min(r,.999):Math.max(r,.001);let n=r*e,f=t==="end"?Math.floor(n):Math.ceil(n);return ne(0,1,f/e)},P=1.70158,L=P*1.525,xe=P+1,he=2*Math.PI/3,ye=2*Math.PI/4.5,V=e=>e<1/2.75?7.5625*e*e:e<2/2.75?7.5625*(e-=1.5/2.75)*e+.75:e<2.5/2.75?7.5625*(e-=2.25/2.75)*e+.9375:7.5625*(e-=2.625/2.75)*e+.984375,Lt={linear:e=>e,easeInQuad:e=>e*e,easeOutQuad:e=>1-(1-e)*(1-e),easeInOutQuad:e=>e<.5?2*e*e:1-Math.pow(-2*e+2,2)/2,easeInCubic:e=>e*e*e,easeOutCubic:e=>1-Math.pow(1-e,3),easeInOutCubic:e=>e<.5?4*e*e*e:1-Math.pow(-2*e+2,3)/2,easeInQuart:e=>e*e*e*e,easeOutQuart:e=>1-Math.pow(1-e,4),easeInOutQuart:e=>e<.5?8*e*e*e*e:1-Math.pow(-2*e+2,4)/2,easeInQuint:e=>e*e*e*e*e,easeOutQuint:e=>1-Math.pow(1-e,5),easeInOutQuint:e=>e<.5?16*e*e*e*e*e:1-Math.pow(-2*e+2,5)/2,easeInSine:e=>1-Math.cos(e*Math.PI/2),easeOutSine:e=>Math.sin(e*Math.PI/2),easeInOutSine:e=>-(Math.cos(Math.PI*e)-1)/2,easeInExpo:e=>e===0?0:Math.pow(2,10*e-10),easeOutExpo:e=>e===1?1:1-Math.pow(2,-10*e),easeInOutExpo:e=>e===0?0:e===1?1:e<.5?Math.pow(2,20*e-10)/2:(2-Math.pow(2,-20*e+10))/2,easeInCirc:e=>1-Math.sqrt(1-Math.pow(e,2)),easeOutCirc:e=>Math.sqrt(1-Math.pow(e-1,2)),easeInOutCirc:e=>e<.5?(1-Math.sqrt(1-Math.pow(2*e,2)))/2:(Math.sqrt(1-Math.pow(-2*e+2,2))+1)/2,easeInBack:e=>xe*e*e*e-P*e*e,easeOutBack:e=>1+xe*Math.pow(e-1,3)+P*Math.pow(e-1,2),easeInOutBack:e=>e<.5?Math.pow(2*e,2)*((L+1)*2*e-L)/2:(Math.pow(2*e-2,2)*((L+1)*(e*2-2)+L)+2)/2,easeInElastic:e=>e===0?0:e===1?1:-Math.pow(2,10*e-10)*Math.sin((e*10-10.75)*he),easeOutElastic:e=>e===0?0:e===1?1:Math.pow(2,-10*e)*Math.sin((e*10-.75)*he)+1,easeInOutElastic:e=>e===0?0:e===1?1:e<.5?-(Math.pow(2,20*e-10)*Math.sin((20*e-11.125)*ye))/2:Math.pow(2,-20*e+10)*Math.sin((20*e-11.125)*ye)/2+1,easeInBounce:e=>1-V(1-e),easeOutBounce:V,easeInOutBounce:e=>e<.5?(1-V(1-2*e))/2:(1+V(2*e-1))/2,steps:Be};var esm_g=Symbol.for("FluidValue.get"),dist_esm_m=Symbol.for("FluidValue.observers");var Pt=e=>Boolean(e&&e[esm_g]),ve=e=>e&&e[esm_g]?e[esm_g]():e,esm_qt=e=>e[dist_esm_m]||null;function je(e,t){e.eventObserved?e.eventObserved(t):e(t)}function $t(e,t){let r=e[dist_esm_m];r&&r.forEach(n=>{je(n,t)})}var esm_ge=class{[esm_g];[dist_esm_m];constructor(t){if(!t&&!(t=this.get))throw Error("Unknown getter");De(this,t)}},De=(e,t)=>Ee(e,esm_g,t);function Gt(e,t){if(e[esm_g]){let r=e[dist_esm_m];r||Ee(e,dist_esm_m,r=new Set),r.has(t)||(r.add(t),e.observerAdded&&e.observerAdded(r.size,t))}return t}function Qt(e,t){let r=e[dist_esm_m];if(r&&r.has(t)){let n=r.size-1;n?r.delete(t):e[dist_esm_m]=null,e.observerRemoved&&e.observerRemoved(n,t)}}var Ee=(e,t,r)=>Object.defineProperty(e,t,{value:r,writable:!0,configurable:!0});var O=/[+\-]?(?:0|[1-9]\d*)(?:\.\d*)?(?:[eE][+\-]?\d+)?/g,esm_Oe=/(#(?:[0-9a-f]{2}){2,4}|(#[0-9a-f]{3})|(rgb|hsl)a?\((-?\d+%?[,\s]+){2,3}\s*[\d\.]+%?\))/gi,K=new RegExp(`($O.source})(%|[a-z]+)`,"i"),we=/rgba\(([0-9\.-]+), ([0-9\.-]+), ([0-9\.-]+), ([0-9\.-]+)\)/gi,dist_esm_b=/var\((--[a-zA-Z0-9-_]+),? ?([a-zA-Z0-9 ()%#.,-]+)?\)/;var esm_N=e=>{let[t,r]=We(e);if(!t||dist_esm_h())return e;let n=window.getComputedStyle(document.documentElement).getPropertyValue(t);if(n)return n.trim();if(r&&r.startsWith("--")){let f=window.getComputedStyle(document.documentElement).getPropertyValue(r);return f||e}else{if(r&&dist_esm_b.test(r))return esm_N(r);if(r)return r}return e},We=e=>{let t=dist_esm_b.exec(e);if(!t)return[,];let[,r,n]=t;return[r,n]};var _,esm_Ke=(e,t,r,n,f)=>`rgba($Math.round(t)}, $Math.round(r)}, $Math.round(n)}, $f})`,Xt=e=>{_||(_=dist_esm_c?new RegExp(`($Object.keys(dist_esm_c).join("|")})(?!\\w)`,"g"):/^\b$/);let t=e.output.map(o=>ve(o).replace(dist_esm_b,esm_N).replace(esm_Oe,D).replace(_,D)),r=t.map(o=>o.match(O).map(Number)),f=r[0].map((o,i)=>r.map(s=>{if(!(i in s))throw Error('The arity of each "output" value must be equal');return s[i]})).map(o=>W({...e,output:o}));return o=>{let i=!K.test(t[0])&&t.find(x=>K.test(x))?.replace(O,""),s=0;return t[0].replace(O,()=>`$f[s++](o)}$i||""}`).replace(we,esm_Ke)}};var Z="react-spring: ",Te=e=>{let t=e,r=!1;if(typeof t!="function")throw new TypeError(`$Z}once requires a function parameter`);return(...n)=>{r||(t(...n),r=!0)}},Ne=Te(console.warn);function Jt(){Ne(`$Z}The "interpolate" function is deprecated in v9 (use "to" instead)`)}var _e=Te(console.warn);function er(){_e(`$Z}Directly calling start instead of using the api object is deprecated in v9 (use ".start" instead), this will be removed in later 0.X.0 versions`)}function esm_or(e){return dist_esm_l.str(e)&&(e[0]=="#"||/\d/.test(e)||!dist_esm_h()&&dist_esm_b.test(e)||e in(dist_esm_c||{}))}var dist_esm_v,q=new WeakMap,Ze=e=>e.forEach(({target:t,contentRect:r})=>q.get(t)?.forEach(n=>n(r)));function Fe(e,t){dist_esm_v||typeof ResizeObserver<"u"&&(dist_esm_v=new ResizeObserver(Ze));let r=q.get(t);return r||(r=new Set,q.set(t,r)),r.add(e),dist_esm_v&&dist_esm_v.observe(t),()=>{let n=q.get(t);!n||(n.delete(e),!n.size&&dist_esm_v&&dist_esm_v.unobserve(t))}}var esm_$=new Set,dist_esm_w,esm_Xe=()=>{let e=()=>{esm_$.forEach(t=>t({width:window.innerWidth,height:window.innerHeight}))};return window.addEventListener("resize",e),()=>{window.removeEventListener("resize",e)}},Ie=e=>(esm_$.add(e),dist_esm_w||(dist_esm_w=esm_Xe()),()=>{esm_$.delete(e),!esm_$.size&&dist_esm_w&&(dist_esm_w(),dist_esm_w=void 0)});var ke=(e,{container:t=document.documentElement}={})=>t===document.documentElement?Ie(e):Fe(e,t);var Se=(e,t,r)=>t-e===0?1:(r-e)/(t-e);var esm_Ye={x:{length:"Width",position:"Left"},y:{length:"Height",position:"Top"}},esm_G=class{callback;container;info;constructor(t,r){this.callback=t,this.container=r,this.info={time:0,x:this.createAxis(),y:this.createAxis()}}createAxis=()=>({current:0,progress:0,scrollLength:0});updateAxis=t=>{let r=this.info[t],{length:n,position:f}=esm_Ye[t];r.current=this.container[`scroll$f}`],r.scrollLength=this.container["scroll"+n]-this.container["client"+n],r.progress=Se(0,r.scrollLength,r.current)};update=()=>{this.updateAxis("x"),this.updateAxis("y")};sendEvent=()=>{this.callback(this.info)};advance=()=>{this.update(),this.sendEvent()}};var esm_T=new WeakMap,Ae=new WeakMap,X=new WeakMap,Me=e=>e===document.documentElement?window:e,yr=(e,{container:t=document.documentElement}={})=>{let r=X.get(t);r||(r=new Set,X.set(t,r));let n=new esm_G(e,t);if(r.add(n),!esm_T.has(t)){let o=()=>(r?.forEach(s=>s.advance()),!0);esm_T.set(t,o);let i=Me(t);window.addEventListener("resize",o,{passive:!0}),t!==document.documentElement&&Ae.set(t,ke(o,{container:t})),i.addEventListener("scroll",o,{passive:!0})}let f=esm_T.get(t);return Re(f),()=>{Re.cancel(f);let o=X.get(t);if(!o||(o.delete(n),o.size))return;let i=esm_T.get(t);esm_T.delete(t),i&&(Me(t).removeEventListener("scroll",i),window.removeEventListener("resize",i),Ae.get(t)?.())}};function Er(e){let t=Je(null);return t.current===null&&(t.current=e()),t.current}var esm_Q=dist_esm_h()?external_React_.useEffect:external_React_.useLayoutEffect;var Ce=()=>{let e=(0,external_React_.useRef)(!1);return esm_Q(()=>(e.current=!0,()=>{e.current=!1}),[]),e};function Mr(){let e=(0,external_React_.useState)()[1],t=Ce();return()=>{t.current&&e(Math.random())}}function Lr(e,t){let[r]=(0,external_React_.useState)(()=>({inputs:t,result:e()})),n=(0,external_React_.useRef)(),f=n.current,o=f;return o?Boolean(t&&o.inputs&&it(t,o.inputs))||(o={inputs:t,result:e()}):o=r,(0,external_React_.useEffect)(()=>{n.current=o,f==r&&(r.inputs=r.result=void 0)},[o]),o.result}function it(e,t){if(e.length!==t.length)return!1;for(let r=0;r<e.length;r++)if(e[r]!==t[r])return!1;return!0}var $r=e=>(0,external_React_.useEffect)(e,ut),ut=[];function Ur(e){let t=ct();return lt(()=>{t.current=e}),t.current}var Wr=()=>{let[e,t]=dt(null);return esm_Q(()=>{let r=window.matchMedia("(prefers-reduced-motion)"),n=f=>{t(f.matches),U({skipAnimation:f.matches})};return n(r),r.addEventListener("change",n),()=>{r.removeEventListener("change",n)}},[]),e};
40250  
40251  ;// ./node_modules/@react-spring/animated/dist/esm/index.js
40252  var animated_dist_esm_h=Symbol.for("Animated:node"),animated_dist_esm_v=e=>!!e&&e[animated_dist_esm_h]===e,dist_esm_k=e=>e&&e[animated_dist_esm_h],esm_D=(e,t)=>mt(e,animated_dist_esm_h,t),F=e=>e&&e[animated_dist_esm_h]&&e[animated_dist_esm_h].getPayload(),animated_dist_esm_c=class{payload;constructor(){esm_D(this,this)}getPayload(){return this.payload||[]}};var animated_dist_esm_l=class extends animated_dist_esm_c{constructor(r){super();this._value=r;dist_esm_l.num(this._value)&&(this.lastPosition=this._value)}done=!0;elapsedTime;lastPosition;lastVelocity;v0;durationProgress=0;static create(r){return new animated_dist_esm_l(r)}getPayload(){return[this]}getValue(){return this._value}setValue(r,n){return dist_esm_l.num(r)&&(this.lastPosition=r,n&&(r=Math.round(r/n)*n,this.done&&(this.lastPosition=r))),this._value===r?!1:(this._value=r,!0)}reset(){let{done:r}=this;this.done=!1,dist_esm_l.num(this._value)&&(this.elapsedTime=0,this.durationProgress=0,this.lastPosition=this._value,r&&(this.lastVelocity=null),this.v0=null)}};var animated_dist_esm_d=class extends animated_dist_esm_l{_string=null;_toString;constructor(t){super(0),this._toString=W({output:[t,t]})}static create(t){return new animated_dist_esm_d(t)}getValue(){let t=this._string;return t??(this._string=this._toString(this._value))}setValue(t){if(dist_esm_l.str(t)){if(t==this._string)return!1;this._string=t,this._value=1}else if(super.setValue(t))this._string=null;else return!1;return!0}reset(t){t&&(this._toString=W({output:[this.getValue(),t]})),this._value=0,super.reset()}};var dist_esm_f={dependencies:null};var animated_dist_esm_u=class extends animated_dist_esm_c{constructor(r){super();this.source=r;this.setValue(r)}getValue(r){let n={};return xt(this.source,(a,i)=>{animated_dist_esm_v(a)?n[i]=a.getValue(r):Pt(a)?n[i]=ve(a):r||(n[i]=a)}),n}setValue(r){this.source=r,this.payload=this._makePayload(r)}reset(){this.payload&&esm_Ve(this.payload,r=>r.reset())}_makePayload(r){if(r){let n=new Set;return xt(r,this._addToPayload,n),Array.from(n)}}_addToPayload(r){dist_esm_f.dependencies&&Pt(r)&&dist_esm_f.dependencies.add(r);let n=F(r);n&&esm_Ve(n,a=>this.add(a))}};var animated_dist_esm_y=class extends animated_dist_esm_u{constructor(t){super(t)}static create(t){return new animated_dist_esm_y(t)}getValue(){return this.source.map(t=>t.getValue())}setValue(t){let r=this.getPayload();return t.length==r.length?r.map((n,a)=>n.setValue(t[a])).some(Boolean):(super.setValue(t.map(dist_esm_z)),!0)}};function dist_esm_z(e){return(esm_or(e)?animated_dist_esm_d:animated_dist_esm_l).create(e)}function esm_Le(e){let t=dist_esm_k(e);return t?t.constructor:dist_esm_l.arr(e)?animated_dist_esm_y:esm_or(e)?animated_dist_esm_d:animated_dist_esm_l}var dist_esm_x=(e,t)=>{let r=!dist_esm_l.fun(e)||e.prototype&&e.prototype.isReactComponent;return (0,external_React_.forwardRef)((n,a)=>{let i=(0,external_React_.useRef)(null),o=r&&(0,external_React_.useCallback)(s=>{i.current=esm_ae(a,s)},[a]),[m,T]=esm_ne(n,t),W=Mr(),P=()=>{let s=i.current;if(r&&!s)return;(s?t.applyAnimatedValues(s,m.getValue(!0)):!1)===!1&&W()},_=new animated_dist_esm_b(P,T),p=(0,external_React_.useRef)();esm_Q(()=>(p.current=_,esm_Ve(T,s=>Gt(s,_)),()=>{p.current&&(esm_Ve(p.current.deps,s=>Qt(s,p.current)),esm_n.cancel(p.current.update))})),(0,external_React_.useEffect)(P,[]),$r(()=>()=>{let s=p.current;esm_Ve(s.deps,S=>Qt(S,s))});let $=t.getComponentProps(m.getValue());return external_React_.createElement(e,{...$,ref:o})})},animated_dist_esm_b=class{constructor(t,r){this.update=t;this.deps=r}eventObserved(t){t.type=="change"&&esm_n.write(this.update)}};function esm_ne(e,t){let r=new Set;return dist_esm_f.dependencies=r,e.style&&(e={...e,style:t.createAnimatedStyle(e.style)}),e=new animated_dist_esm_u(e),dist_esm_f.dependencies=null,[e,r]}function esm_ae(e,t){return e&&(dist_esm_l.fun(e)?e(t):e.current=t),t}var dist_esm_j=Symbol.for("AnimatedComponent"),dist_esm_Ke=(e,{applyAnimatedValues:t=()=>!1,createAnimatedStyle:r=a=>new animated_dist_esm_u(a),getComponentProps:n=a=>a}={})=>{let a={applyAnimatedValues:t,createAnimatedStyle:r,getComponentProps:n},i=o=>{let m=esm_I(o)||"Anonymous";return dist_esm_l.str(o)?o=i[o]||(i[o]=dist_esm_x(o,a)):o=o[dist_esm_j]||(o[dist_esm_j]=dist_esm_x(o,a)),o.displayName=`Animated($m})`,o};return xt(e,(o,m)=>{dist_esm_l.arr(e)&&(m=esm_I(o)),i[m]=i(o)}),{animated:i}},esm_I=e=>dist_esm_l.str(e)?e:e&&dist_esm_l.str(e.displayName)?e.displayName:dist_esm_l.fun(e)&&e.name||null;
40253  
40254  ;// ./node_modules/@react-spring/core/dist/esm/index.js
40255  function dist_esm_I(t,...e){return dist_esm_l.fun(t)?t(...e):t}var esm_te=(t,e)=>t===!0||!!(e&&t&&(dist_esm_l.fun(t)?t(e):ht(t).includes(e))),et=(t,e)=>dist_esm_l.obj(t)?e&&t[e]:t;var esm_ke=(t,e)=>t.default===!0?t[e]:t.default?t.default[e]:void 0,nn=t=>t,dist_esm_ne=(t,e=nn)=>{let n=rn;t.default&&t.default!==!0&&(t=t.default,n=Object.keys(t));let r={};for(let o of n){let s=e(t[o],o);dist_esm_l.und(s)||(r[o]=s)}return r},rn=["config","onProps","onStart","onChange","onPause","onResume","onRest"],on={config:1,from:1,to:1,ref:1,loop:1,reset:1,pause:1,cancel:1,reverse:1,immediate:1,default:1,delay:1,onProps:1,onStart:1,onChange:1,onPause:1,onResume:1,onRest:1,onResolve:1,items:1,trail:1,sort:1,expires:1,initial:1,enter:1,update:1,leave:1,children:1,onDestroyed:1,keys:1,callId:1,parentId:1};function sn(t){let e={},n=0;if(xt(t,(r,o)=>{on[o]||(e[o]=r,n++)}),n)return e}function esm_de(t){let e=sn(t);if(e){let n={to:e};return xt(t,(r,o)=>o in e||(n[o]=r)),n}return{...t}}function esm_me(t){return t=ve(t),dist_esm_l.arr(t)?t.map(esm_me):esm_or(t)?dist_esm_p.createStringInterpolator({range:[0,1],output:[t,t]})(1):t}function esm_Ue(t){for(let e in t)return!0;return!1}function esm_Ee(t){return dist_esm_l.fun(t)||dist_esm_l.arr(t)&&dist_esm_l.obj(t[0])}function esm_xe(t,e){t.ref?.delete(t),e?.delete(t)}function esm_he(t,e){e&&t.ref!==e&&(t.ref?.delete(t),e.add(t),t.ref=e)}function wr(t,e,n=1e3){an(()=>{if(e){let r=0;ge(t,(o,s)=>{let a=o.current;if(a.length){let i=n*e[s];isNaN(i)?i=r:r=i,ge(a,u=>{ge(u.queue,p=>{let f=p.delay;p.delay=d=>i+dist_esm_I(f||0,d)})}),o.start()}})}else{let r=Promise.resolve();ge(t,o=>{let s=o.current;if(s.length){let a=s.map(i=>{let u=i.queue;return i.queue=[],u});r=r.then(()=>(ge(s,(i,u)=>ge(a[u]||[],p=>i.queue.push(p))),Promise.all(o.start())))}})}})}var esm_mt={default:{tension:170,friction:26},gentle:{tension:120,friction:14},wobbly:{tension:180,friction:12},stiff:{tension:210,friction:20},slow:{tension:280,friction:60},molasses:{tension:280,friction:120}};var tt={...esm_mt.default,mass:1,damping:1,easing:Lt.linear,clamp:!1},esm_we=class{tension;friction;frequency;damping;mass;velocity=0;restVelocity;precision;progress;duration;easing;clamp;bounce;decay;round;constructor(){Object.assign(this,tt)}};function gt(t,e,n){n&&(n={...n},esm_ht(n,e),e={...n,...e}),esm_ht(t,e),Object.assign(t,e);for(let a in tt)t[a]==null&&(t[a]=tt[a]);let{mass:r,frequency:o,damping:s}=t;return dist_esm_l.und(o)||(o<.01&&(o=.01),s<0&&(s=0),t.tension=Math.pow(2*Math.PI/o,2)*r,t.friction=4*Math.PI*s*r/o),t}function esm_ht(t,e){if(!dist_esm_l.und(e.decay))t.duration=void 0;else{let n=!dist_esm_l.und(e.tension)||!dist_esm_l.und(e.friction);(n||!dist_esm_l.und(e.frequency)||!dist_esm_l.und(e.damping)||!dist_esm_l.und(e.mass))&&(t.duration=void 0,t.decay=void 0),n&&(t.frequency=void 0)}}var esm_yt=[],dist_esm_Le=class{changed=!1;values=esm_yt;toValues=null;fromValues=esm_yt;to;from;config=new esm_we;immediate=!1};function esm_Me(t,{key:e,props:n,defaultProps:r,state:o,actions:s}){return new Promise((a,i)=>{let u,p,f=esm_te(n.cancel??r?.cancel,e);if(f)b();else{dist_esm_l.und(n.pause)||(o.paused=esm_te(n.pause,e));let c=r?.pause;c!==!0&&(c=o.paused||esm_te(c,e)),u=dist_esm_I(n.delay||0,e),c?(o.resumeQueue.add(m),s.pause()):(s.resume(),m())}function d(){o.resumeQueue.add(m),o.timeouts.delete(p),p.cancel(),u=p.time-esm_n.now()}function m(){u>0&&!dist_esm_p.skipAnimation?(o.delayed=!0,p=esm_n.setTimeout(b,u),o.pauseQueue.add(d),o.timeouts.add(p)):b()}function b(){o.delayed&&(o.delayed=!1),o.pauseQueue.delete(d),o.timeouts.delete(p),t<=(o.cancelId||0)&&(f=!0);try{s.start({...n,callId:t,cancel:f},a)}catch(c){i(c)}}})}var esm_be=(t,e)=>e.length==1?e[0]:e.some(n=>n.cancelled)?esm_q(t.get()):e.every(n=>n.noop)?nt(t.get()):dist_esm_E(t.get(),e.every(n=>n.finished)),nt=t=>({value:t,noop:!0,finished:!0,cancelled:!1}),dist_esm_E=(t,e,n=!1)=>({value:t,finished:e,cancelled:n}),esm_q=t=>({value:t,cancelled:!0,finished:!1});function esm_De(t,e,n,r){let{callId:o,parentId:s,onRest:a}=e,{asyncTo:i,promise:u}=n;return!s&&t===i&&!e.reset?u:n.promise=(async()=>{n.asyncId=o,n.asyncTo=t;let p=dist_esm_ne(e,(l,h)=>h==="onRest"?void 0:l),f,d,m=new Promise((l,h)=>(f=l,d=h)),b=l=>{let h=o<=(n.cancelId||0)&&esm_q(r)||o!==n.asyncId&&dist_esm_E(r,!1);if(h)throw l.result=h,d(l),l},c=(l,h)=>{let g=new esm_Ae,x=new esm_Ne;return(async()=>{if(dist_esm_p.skipAnimation)throw esm_oe(n),x.result=dist_esm_E(r,!1),d(x),x;b(g);let S=dist_esm_l.obj(l)?{...l}:{...h,to:l};S.parentId=o,xt(p,(V,_)=>{dist_esm_l.und(S[_])&&(S[_]=V)});let A=await r.start(S);return b(g),n.paused&&await new Promise(V=>{n.resumeQueue.add(V)}),A})()},P;if(dist_esm_p.skipAnimation)return esm_oe(n),dist_esm_E(r,!1);try{let l;dist_esm_l.arr(t)?l=(async h=>{for(let g of h)await c(g)})(t):l=Promise.resolve(t(c,r.stop.bind(r))),await Promise.all([l.then(f),m]),P=dist_esm_E(r.get(),!0,!1)}catch(l){if(l instanceof esm_Ae)P=l.result;else if(l instanceof esm_Ne)P=l.result;else throw l}finally{o==n.asyncId&&(n.asyncId=s,n.asyncTo=s?i:void 0,n.promise=s?u:void 0)}return dist_esm_l.fun(a)&&esm_n.batchedUpdates(()=>{a(P,r,r.item)}),P})()}function esm_oe(t,e){Pe(t.timeouts,n=>n.cancel()),t.pauseQueue.clear(),t.resumeQueue.clear(),t.asyncId=t.asyncTo=t.promise=void 0,e&&(t.cancelId=e)}var esm_Ae=class extends Error{result;constructor(){super("An async animation has been interrupted. You see this error because you forgot to use `await` or `.catch(...)` on its returned promise.")}},esm_Ne=class extends Error{result;constructor(){super("SkipAnimationSignal")}};var esm_Re=t=>t instanceof esm_X,Sn=1,esm_X=class extends esm_ge{id=Sn++;_priority=0;get priority(){return this._priority}set priority(e){this._priority!=e&&(this._priority=e,this._onPriorityChange(e))}get(){let e=dist_esm_k(this);return e&&e.getValue()}to(...e){return dist_esm_p.to(this,e)}interpolate(...e){return Jt(),dist_esm_p.to(this,e)}toJSON(){return this.get()}observerAdded(e){e==1&&this._attach()}observerRemoved(e){e==0&&this._detach()}_attach(){}_detach(){}_onChange(e,n=!1){$t(this,{type:"change",parent:this,value:e,idle:n})}_onPriorityChange(e){this.idle||qe.sort(this),$t(this,{type:"priority",parent:this,priority:e})}};var esm_se=Symbol.for("SpringPhase"),esm_bt=1,rt=2,ot=4,esm_qe=t=>(t[esm_se]&esm_bt)>0,dist_esm_Q=t=>(t[esm_se]&rt)>0,esm_ye=t=>(t[esm_se]&ot)>0,st=(t,e)=>e?t[esm_se]|=rt|esm_bt:t[esm_se]&=~rt,esm_it=(t,e)=>e?t[esm_se]|=ot:t[esm_se]&=~ot;var esm_ue=class extends esm_X{key;animation=new dist_esm_Le;queue;defaultProps={};_state={paused:!1,delayed:!1,pauseQueue:new Set,resumeQueue:new Set,timeouts:new Set};_pendingCalls=new Set;_lastCallId=0;_lastToId=0;_memoizedDuration=0;constructor(e,n){if(super(),!dist_esm_l.und(e)||!dist_esm_l.und(n)){let r=dist_esm_l.obj(e)?{...e}:{...n,from:e};dist_esm_l.und(r.default)&&(r.default=!0),this.start(r)}}get idle(){return!(dist_esm_Q(this)||this._state.asyncTo)||esm_ye(this)}get goal(){return ve(this.animation.to)}get velocity(){let e=dist_esm_k(this);return e instanceof animated_dist_esm_l?e.lastVelocity||0:e.getPayload().map(n=>n.lastVelocity||0)}get hasAnimated(){return esm_qe(this)}get isAnimating(){return dist_esm_Q(this)}get isPaused(){return esm_ye(this)}get isDelayed(){return this._state.delayed}advance(e){let n=!0,r=!1,o=this.animation,{config:s,toValues:a}=o,i=F(o.to);!i&&Pt(o.to)&&(a=ht(ve(o.to))),o.values.forEach((f,d)=>{if(f.done)return;let m=f.constructor==animated_dist_esm_d?1:i?i[d].lastPosition:a[d],b=o.immediate,c=m;if(!b){if(c=f.lastPosition,s.tension<=0){f.done=!0;return}let P=f.elapsedTime+=e,l=o.fromValues[d],h=f.v0!=null?f.v0:f.v0=dist_esm_l.arr(s.velocity)?s.velocity[d]:s.velocity,g,x=s.precision||(l==m?.005:Math.min(1,Math.abs(m-l)*.001));if(dist_esm_l.und(s.duration))if(s.decay){let S=s.decay===!0?.998:s.decay,A=Math.exp(-(1-S)*P);c=l+h/(1-S)*(1-A),b=Math.abs(f.lastPosition-c)<=x,g=h*A}else{g=f.lastVelocity==null?h:f.lastVelocity;let S=s.restVelocity||x/10,A=s.clamp?0:s.bounce,V=!dist_esm_l.und(A),_=l==m?f.v0>0:l<m,v,w=!1,C=1,$=Math.ceil(e/C);for(let L=0;L<$&&(v=Math.abs(g)>S,!(!v&&(b=Math.abs(m-c)<=x,b)));++L){V&&(w=c==m||c>m==_,w&&(g=-g*A,c=m));let N=-s.tension*1e-6*(c-m),y=-s.friction*.001*g,T=(N+y)/s.mass;g=g+T*C,c=c+g*C}}else{let S=1;s.duration>0&&(this._memoizedDuration!==s.duration&&(this._memoizedDuration=s.duration,f.durationProgress>0&&(f.elapsedTime=s.duration*f.durationProgress,P=f.elapsedTime+=e)),S=(s.progress||0)+P/this._memoizedDuration,S=S>1?1:S<0?0:S,f.durationProgress=S),c=l+s.easing(S)*(m-l),g=(c-f.lastPosition)/e,b=S==1}f.lastVelocity=g,Number.isNaN(c)&&(console.warn("Got NaN while animating:",this),b=!0)}i&&!i[d].done&&(b=!1),b?f.done=!0:n=!1,f.setValue(c,s.round)&&(r=!0)});let u=dist_esm_k(this),p=u.getValue();if(n){let f=ve(o.to);(p!==f||r)&&!s.decay?(u.setValue(f),this._onChange(f)):r&&s.decay&&this._onChange(p),this._stop()}else r&&this._onChange(p)}set(e){return esm_n.batchedUpdates(()=>{this._stop(),this._focus(e),this._set(e)}),this}pause(){this._update({pause:!0})}resume(){this._update({pause:!1})}finish(){if(dist_esm_Q(this)){let{to:e,config:n}=this.animation;esm_n.batchedUpdates(()=>{this._onStart(),n.decay||this._set(e,!1),this._stop()})}return this}update(e){return(this.queue||(this.queue=[])).push(e),this}start(e,n){let r;return dist_esm_l.und(e)?(r=this.queue||[],this.queue=[]):r=[dist_esm_l.obj(e)?e:{...n,to:e}],Promise.all(r.map(o=>this._update(o))).then(o=>esm_be(this,o))}stop(e){let{to:n}=this.animation;return this._focus(this.get()),esm_oe(this._state,e&&this._lastCallId),esm_n.batchedUpdates(()=>this._stop(n,e)),this}reset(){this._update({reset:!0})}eventObserved(e){e.type=="change"?this._start():e.type=="priority"&&(this.priority=e.priority+1)}_prepareNode(e){let n=this.key||"",{to:r,from:o}=e;r=dist_esm_l.obj(r)?r[n]:r,(r==null||esm_Ee(r))&&(r=void 0),o=dist_esm_l.obj(o)?o[n]:o,o==null&&(o=void 0);let s={to:r,from:o};return esm_qe(this)||(e.reverse&&([r,o]=[o,r]),o=ve(o),dist_esm_l.und(o)?dist_esm_k(this)||this._set(r):this._set(o)),s}_update({...e},n){let{key:r,defaultProps:o}=this;e.default&&Object.assign(o,dist_esm_ne(e,(i,u)=>/^on/.test(u)?et(i,r):i)),_t(this,e,"onProps"),esm_Ie(this,"onProps",e,this);let s=this._prepareNode(e);if(Object.isFrozen(this))throw Error("Cannot animate a `SpringValue` object that is frozen. Did you forget to pass your component to `animated(...)` before animating its props?");let a=this._state;return esm_Me(++this._lastCallId,{key:r,props:e,defaultProps:o,state:a,actions:{pause:()=>{esm_ye(this)||(esm_it(this,!0),yt(a.pauseQueue),esm_Ie(this,"onPause",dist_esm_E(this,esm_Ce(this,this.animation.to)),this))},resume:()=>{esm_ye(this)&&(esm_it(this,!1),dist_esm_Q(this)&&this._resume(),yt(a.resumeQueue),esm_Ie(this,"onResume",dist_esm_E(this,esm_Ce(this,this.animation.to)),this))},start:this._merge.bind(this,s)}}).then(i=>{if(e.loop&&i.finished&&!(n&&i.noop)){let u=at(e);if(u)return this._update(u,!0)}return i})}_merge(e,n,r){if(n.cancel)return this.stop(!0),r(esm_q(this));let o=!dist_esm_l.und(e.to),s=!dist_esm_l.und(e.from);if(o||s)if(n.callId>this._lastToId)this._lastToId=n.callId;else return r(esm_q(this));let{key:a,defaultProps:i,animation:u}=this,{to:p,from:f}=u,{to:d=p,from:m=f}=e;s&&!o&&(!n.default||dist_esm_l.und(d))&&(d=m),n.reverse&&([d,m]=[m,d]);let b=!bt(m,f);b&&(u.from=m),m=ve(m);let c=!bt(d,p);c&&this._focus(d);let P=esm_Ee(n.to),{config:l}=u,{decay:h,velocity:g}=l;(o||s)&&(l.velocity=0),n.config&&!P&&gt(l,dist_esm_I(n.config,a),n.config!==i.config?dist_esm_I(i.config,a):void 0);let x=dist_esm_k(this);if(!x||dist_esm_l.und(d))return r(dist_esm_E(this,!0));let S=dist_esm_l.und(n.reset)?s&&!n.default:!dist_esm_l.und(m)&&esm_te(n.reset,a),A=S?m:this.get(),V=esm_me(d),_=dist_esm_l.num(V)||dist_esm_l.arr(V)||esm_or(V),v=!P&&(!_||esm_te(i.immediate||n.immediate,a));if(c){let L=esm_Le(d);if(L!==x.constructor)if(v)x=this._set(V);else throw Error(`Cannot animate between $x.constructor.name} and $L.name}, as the "to" prop suggests`)}let w=x.constructor,C=Pt(d),$=!1;if(!C){let L=S||!esm_qe(this)&&b;(c||L)&&($=bt(esm_me(A),V),C=!$),(!bt(u.immediate,v)&&!v||!bt(l.decay,h)||!bt(l.velocity,g))&&(C=!0)}if($&&dist_esm_Q(this)&&(u.changed&&!S?C=!0:C||this._stop(p)),!P&&((C||Pt(p))&&(u.values=x.getPayload(),u.toValues=Pt(d)?null:w==animated_dist_esm_d?[1]:ht(V)),u.immediate!=v&&(u.immediate=v,!v&&!S&&this._set(p)),C)){let{onRest:L}=u;esm_Ve(_n,y=>_t(this,n,y));let N=dist_esm_E(this,esm_Ce(this,p));yt(this._pendingCalls,N),this._pendingCalls.add(r),u.changed&&esm_n.batchedUpdates(()=>{u.changed=!S,L?.(N,this),S?dist_esm_I(i.onRest,N):u.onStart?.(N,this)})}S&&this._set(A),P?r(esm_De(n.to,n,this._state,this)):C?this._start():dist_esm_Q(this)&&!c?this._pendingCalls.add(r):r(nt(A))}_focus(e){let n=this.animation;e!==n.to&&(esm_qt(this)&&this._detach(),n.to=e,esm_qt(this)&&this._attach())}_attach(){let e=0,{to:n}=this.animation;Pt(n)&&(Gt(n,this),esm_Re(n)&&(e=n.priority+1)),this.priority=e}_detach(){let{to:e}=this.animation;Pt(e)&&Qt(e,this)}_set(e,n=!0){let r=ve(e);if(!dist_esm_l.und(r)){let o=dist_esm_k(this);if(!o||!bt(r,o.getValue())){let s=esm_Le(r);!o||o.constructor!=s?esm_D(this,s.create(r)):o.setValue(r),o&&esm_n.batchedUpdates(()=>{this._onChange(r,n)})}}return dist_esm_k(this)}_onStart(){let e=this.animation;e.changed||(e.changed=!0,esm_Ie(this,"onStart",dist_esm_E(this,esm_Ce(this,e.to)),this))}_onChange(e,n){n||(this._onStart(),dist_esm_I(this.animation.onChange,e,this)),dist_esm_I(this.defaultProps.onChange,e,this),super._onChange(e,n)}_start(){let e=this.animation;dist_esm_k(this).reset(ve(e.to)),e.immediate||(e.fromValues=e.values.map(n=>n.lastPosition)),dist_esm_Q(this)||(st(this,!0),esm_ye(this)||this._resume())}_resume(){dist_esm_p.skipAnimation?this.finish():qe.start(this)}_stop(e,n){if(dist_esm_Q(this)){st(this,!1);let r=this.animation;esm_Ve(r.values,s=>{s.done=!0}),r.toValues&&(r.onChange=r.onPause=r.onResume=void 0),$t(this,{type:"idle",parent:this});let o=n?esm_q(this.get()):dist_esm_E(this.get(),esm_Ce(this,e??r.to));yt(this._pendingCalls,o),r.changed&&(r.changed=!1,esm_Ie(this,"onRest",o,this))}}};function esm_Ce(t,e){let n=esm_me(e),r=esm_me(t.get());return bt(r,n)}function at(t,e=t.loop,n=t.to){let r=dist_esm_I(e);if(r){let o=r!==!0&&esm_de(r),s=(o||t).reverse,a=!o||o.reset;return esm_Pe({...t,loop:e,default:!1,pause:void 0,to:!s||esm_Ee(n)?n:void 0,from:a?t.from:void 0,reset:a,...o})}}function esm_Pe(t){let{to:e,from:n}=t=esm_de(t),r=new Set;return dist_esm_l.obj(e)&&Vt(e,r),dist_esm_l.obj(n)&&Vt(n,r),t.keys=r.size?Array.from(r):null,t}function Ot(t){let e=esm_Pe(t);return R.und(e.default)&&(e.default=dist_esm_ne(e)),e}function Vt(t,e){xt(t,(n,r)=>n!=null&&e.add(r))}var _n=["onStart","onRest","onChange","onPause","onResume"];function _t(t,e,n){t.animation[n]=e[n]!==esm_ke(e,n)?et(e[n],t.key):void 0}function esm_Ie(t,e,...n){t.animation[e]?.(...n),t.defaultProps[e]?.(...n)}var Fn=["onStart","onChange","onRest"],kn=1,esm_le=class{id=kn++;springs={};queue=[];ref;_flush;_initialProps;_lastAsyncId=0;_active=new Set;_changed=new Set;_started=!1;_item;_state={paused:!1,pauseQueue:new Set,resumeQueue:new Set,timeouts:new Set};_events={onStart:new Map,onChange:new Map,onRest:new Map};constructor(e,n){this._onFrame=this._onFrame.bind(this),n&&(this._flush=n),e&&this.start({default:!0,...e})}get idle(){return!this._state.asyncTo&&Object.values(this.springs).every(e=>e.idle&&!e.isDelayed&&!e.isPaused)}get item(){return this._item}set item(e){this._item=e}get(){let e={};return this.each((n,r)=>e[r]=n.get()),e}set(e){for(let n in e){let r=e[n];dist_esm_l.und(r)||this.springs[n].set(r)}}update(e){return e&&this.queue.push(esm_Pe(e)),this}start(e){let{queue:n}=this;return e?n=ht(e).map(esm_Pe):this.queue=[],this._flush?this._flush(this,n):(jt(this,n),esm_ze(this,n))}stop(e,n){if(e!==!!e&&(n=e),n){let r=this.springs;esm_Ve(ht(n),o=>r[o].stop(!!e))}else esm_oe(this._state,this._lastAsyncId),this.each(r=>r.stop(!!e));return this}pause(e){if(dist_esm_l.und(e))this.start({pause:!0});else{let n=this.springs;esm_Ve(ht(e),r=>n[r].pause())}return this}resume(e){if(dist_esm_l.und(e))this.start({pause:!1});else{let n=this.springs;esm_Ve(ht(e),r=>n[r].resume())}return this}each(e){xt(this.springs,e)}_onFrame(){let{onStart:e,onChange:n,onRest:r}=this._events,o=this._active.size>0,s=this._changed.size>0;(o&&!this._started||s&&!this._started)&&(this._started=!0,Pe(e,([u,p])=>{p.value=this.get(),u(p,this,this._item)}));let a=!o&&this._started,i=s||a&&r.size?this.get():null;s&&n.size&&Pe(n,([u,p])=>{p.value=i,u(p,this,this._item)}),a&&(this._started=!1,Pe(r,([u,p])=>{p.value=i,u(p,this,this._item)}))}eventObserved(e){if(e.type=="change")this._changed.add(e.parent),e.idle||this._active.add(e.parent);else if(e.type=="idle")this._active.delete(e.parent);else return;esm_n.onFrame(this._onFrame)}};function esm_ze(t,e){return Promise.all(e.map(n=>wt(t,n))).then(n=>esm_be(t,n))}async function wt(t,e,n){let{keys:r,to:o,from:s,loop:a,onRest:i,onResolve:u}=e,p=dist_esm_l.obj(e.default)&&e.default;a&&(e.loop=!1),o===!1&&(e.to=null),s===!1&&(e.from=null);let f=dist_esm_l.arr(o)||dist_esm_l.fun(o)?o:void 0;f?(e.to=void 0,e.onRest=void 0,p&&(p.onRest=void 0)):esm_Ve(Fn,P=>{let l=e[P];if(dist_esm_l.fun(l)){let h=t._events[P];e[P]=({finished:g,cancelled:x})=>{let S=h.get(l);S?(g||(S.finished=!1),x&&(S.cancelled=!0)):h.set(l,{value:null,finished:g||!1,cancelled:x||!1})},p&&(p[P]=e[P])}});let d=t._state;e.pause===!d.paused?(d.paused=e.pause,yt(e.pause?d.pauseQueue:d.resumeQueue)):d.paused&&(e.pause=!0);let m=(r||Object.keys(t.springs)).map(P=>t.springs[P].start(e)),b=e.cancel===!0||esm_ke(e,"cancel")===!0;(f||b&&d.asyncId)&&m.push(esm_Me(++t._lastAsyncId,{props:e,state:d,actions:{pause:Y,resume:Y,start(P,l){b?(esm_oe(d,t._lastAsyncId),l(esm_q(t))):(P.onRest=i,l(esm_De(f,P,d,t)))}}})),d.paused&&await new Promise(P=>{d.resumeQueue.add(P)});let c=esm_be(t,await Promise.all(m));if(a&&c.finished&&!(n&&c.noop)){let P=at(e,a,o);if(P)return jt(t,[P]),wt(t,P,!0)}return u&&esm_n.batchedUpdates(()=>u(c,t,t.item)),c}function esm_e(t,e){let n={...t.springs};return e&&pe(Ve(e),r=>{z.und(r.keys)&&(r=esm_Pe(r)),z.obj(r.to)||(r={...r,to:void 0}),Mt(n,r,o=>esm_Lt(o))}),pt(t,n),n}function pt(t,e){Ut(e,(n,r)=>{t.springs[r]||(t.springs[r]=n,Et(n,t))})}function esm_Lt(t,e){let n=new esm_ue;return n.key=t,e&&Gt(n,e),n}function Mt(t,e,n){e.keys&&esm_Ve(e.keys,r=>{(t[r]||(t[r]=n(r)))._prepareNode(e)})}function jt(t,e){esm_Ve(e,n=>{Mt(t.springs,n,r=>esm_Lt(r,t))})}var dist_esm_H=({children:t,...e})=>{let n=(0,external_React_.useContext)(esm_Ge),r=e.pause||!!n.pause,o=e.immediate||!!n.immediate;e=Lr(()=>({pause:r,immediate:o}),[r,o]);let{Provider:s}=esm_Ge;return external_React_.createElement(s,{value:e},t)},esm_Ge=wn(dist_esm_H,{});dist_esm_H.Provider=esm_Ge.Provider;dist_esm_H.Consumer=esm_Ge.Consumer;function wn(t,e){return Object.assign(t,external_React_.createContext(e)),t.Provider._context=t,t.Consumer._context=t,t}var esm_fe=()=>{let t=[],e=function(r){Ln();let o=[];return ce(t,(s,a)=>{if(Ke.und(r))o.push(s.start());else{let i=n(r,s,a);i&&o.push(s.start(i))}}),o};e.current=t,e.add=function(r){t.includes(r)||t.push(r)},e.delete=function(r){let o=t.indexOf(r);~o&&t.splice(o,1)},e.pause=function(){return ce(t,r=>r.pause(...arguments)),this},e.resume=function(){return ce(t,r=>r.resume(...arguments)),this},e.set=function(r){ce(t,(o,s)=>{let a=Ke.fun(r)?r(s,o):r;a&&o.set(a)})},e.start=function(r){let o=[];return ce(t,(s,a)=>{if(Ke.und(r))o.push(s.start());else{let i=this._getProps(r,s,a);i&&o.push(s.start(i))}}),o},e.stop=function(){return ce(t,r=>r.stop(...arguments)),this},e.update=function(r){return ce(t,(o,s)=>o.update(this._getProps(r,o,s))),this};let n=function(r,o,s){return Ke.fun(r)?r(s,o):r};return e._getProps=n,e};function esm_He(t,e,n){let r=jn.fun(e)&&e;r&&!n&&(n=[]);let o=Xe(()=>r||arguments.length==3?esm_fe():void 0,[]),s=Nt(0),a=Dn(),i=Xe(()=>({ctrls:[],queue:[],flush(h,g){let x=esm_e(h,g);return s.current>0&&!i.queue.length&&!Object.keys(x).some(A=>!h.springs[A])?esm_ze(h,g):new Promise(A=>{pt(h,x),i.queue.push(()=>{A(esm_ze(h,g))}),a()})}}),[]),u=Nt([...i.ctrls]),p=[],f=Dt(t)||0;Xe(()=>{Ye(u.current.slice(t,f),h=>{esm_xe(h,o),h.stop(!0)}),u.current.length=t,d(f,t)},[t]),Xe(()=>{d(0,Math.min(f,t))},n);function d(h,g){for(let x=h;x<g;x++){let S=u.current[x]||(u.current[x]=new esm_le(null,i.flush)),A=r?r(x,S):e[x];A&&(p[x]=Ot(A))}}let m=u.current.map((h,g)=>esm_e(h,p[g])),b=Mn(dist_esm_H),c=Dt(b),P=b!==c&&esm_Ue(b);qn(()=>{s.current++,i.ctrls=u.current;let{queue:h}=i;h.length&&(i.queue=[],Ye(h,g=>g())),Ye(u.current,(g,x)=>{o?.add(g),P&&g.start({default:b});let S=p[x];S&&(esm_he(g,S.ref),g.ref?g.queue.push(S):g.start(S))})}),Nn(()=>()=>{Ye(i.ctrls,h=>h.stop(!0))});let l=m.map(h=>({...h}));return o?[l,o]:l}function esm_J(t,e){let n=Qn.fun(t),[[r],o]=esm_He(1,n?t:[t],n?e||[]:e);return n||arguments.length==2?[r,o]:r}var Gn=()=>esm_fe(),Xo=()=>zn(Gn)[0];var Wo=(t,e)=>{let n=Bn(()=>new esm_ue(t,e));return Kn(()=>()=>{n.stop()}),n};function esm_Qt(t,e,n){let r=qt.fun(e)&&e;r&&!n&&(n=[]);let o=!0,s,a=esm_He(t,(i,u)=>{let p=r?r(i,u):e;return s=p.ref,o=o&&p.reverse,p},n||[{}]);if(Yn(()=>{Xn(a[1].current,(i,u)=>{let p=a[1].current[u+(o?1:-1)];if(esm_he(i,s),i.ref){p&&i.update({to:p.springs});return}p?i.start({to:p.springs}):i.start()})},n),r||arguments.length==3){let i=s??a[1];return i._getProps=(u,p,f)=>{let d=qt.fun(u)?u(f,p):u;if(d){let m=i.current[f+(d.reverse?1:-1)];return m&&(d.to=m.springs),d}},a}return a[0]}function esm_Gt(t,e,n){let r=G.fun(e)&&e,{reset:o,sort:s,trail:a=0,expires:i=!0,exitBeforeEnter:u=!1,onDestroyed:p,ref:f,config:d}=r?r():e,m=Jn(()=>r||arguments.length==3?esm_fe():void 0,[]),b=zt(t),c=[],P=lt(null),l=o?null:P.current;Je(()=>{P.current=c}),$n(()=>(j(c,y=>{m?.add(y.ctrl),y.ctrl.ref=m}),()=>{j(P.current,y=>{y.expired&&clearTimeout(y.expirationId),esm_xe(y.ctrl,m),y.ctrl.stop(!0)})}));let h=tr(b,r?r():e,l),g=o&&P.current||[];Je(()=>j(g,({ctrl:y,item:T,key:F})=>{esm_xe(y,m),dist_esm_I(p,T,F)}));let x=[];if(l&&j(l,(y,T)=>{y.expired?(clearTimeout(y.expirationId),g.push(y)):(T=x[T]=h.indexOf(y.key),~T&&(c[T]=y))}),j(b,(y,T)=>{c[T]||(c[T]={key:h[T],item:y,phase:"mount",ctrl:new esm_le},c[T].ctrl.item=y)}),x.length){let y=-1,{leave:T}=r?r():e;j(x,(F,k)=>{let O=l[k];~F?(y=c.indexOf(O),c[y]={...O,item:b[F]}):T&&c.splice(++y,0,O)})}G.fun(s)&&c.sort((y,T)=>s(y.item,T.item));let S=-a,A=Wn(),V=dist_esm_ne(e),_=new Map,v=lt(new Map),w=lt(!1);j(c,(y,T)=>{let F=y.key,k=y.phase,O=r?r():e,U,D,Jt=dist_esm_I(O.delay||0,F);if(k=="mount")U=O.enter,D="enter";else{let M=h.indexOf(F)<0;if(k!="leave")if(M)U=O.leave,D="leave";else if(U=O.update)D="update";else return;else if(!M)U=O.enter,D="enter";else return}if(U=dist_esm_I(U,y.item,T),U=G.obj(U)?esm_de(U):{to:U},!U.config){let M=d||V.config;U.config=dist_esm_I(M,y.item,T,D)}S+=a;let Z={...V,delay:Jt+S,ref:f,immediate:O.immediate,reset:!1,...U};if(D=="enter"&&G.und(Z.from)){let M=r?r():e,Te=G.und(M.initial)||l?M.from:M.initial;Z.from=dist_esm_I(Te,y.item,T)}let{onResolve:Wt}=Z;Z.onResolve=M=>{dist_esm_I(Wt,M);let Te=P.current,B=Te.find(Fe=>Fe.key===F);if(!!B&&!(M.cancelled&&B.phase!="update")&&B.ctrl.idle){let Fe=Te.every(ee=>ee.ctrl.idle);if(B.phase=="leave"){let ee=dist_esm_I(i,B.item);if(ee!==!1){let Ze=ee===!0?0:ee;if(B.expired=!0,!Fe&&Ze>0){Ze<=2147483647&&(B.expirationId=setTimeout(A,Ze));return}}}Fe&&Te.some(ee=>ee.expired)&&(v.current.delete(B),u&&(w.current=!0),A())}};let ft=esm_e(y.ctrl,Z);D==="leave"&&u?v.current.set(y,{phase:D,springs:ft,payload:Z}):_.set(y,{phase:D,springs:ft,payload:Z})});let C=Hn(dist_esm_H),$=Zn(C),L=C!==$&&esm_Ue(C);Je(()=>{L&&j(c,y=>{y.ctrl.start({default:C})})},[C]),j(_,(y,T)=>{if(v.current.size){let F=c.findIndex(k=>k.key===T.key);c.splice(F,1)}}),Je(()=>{j(v.current.size?v.current:_,({phase:y,payload:T},F)=>{let{ctrl:k}=F;F.phase=y,m?.add(k),L&&y=="enter"&&k.start({default:C}),T&&(esm_he(k,T.ref),(k.ref||m)&&!w.current?k.update(T):(k.start(T),w.current&&(w.current=!1)))})},o?void 0:n);let N=y=>Oe.createElement(Oe.Fragment,null,c.map((T,F)=>{let{springs:k}=_.get(T)||T.ctrl,O=y({...k},T.item,T,F);return O&&O.type?Oe.createElement(O.type,{...O.props,key:G.str(T.key)||G.num(T.key)?T.key:T.ctrl.id,ref:O.ref}):O}));return m?[N,m]:N}var esm_er=1;function tr(t,{key:e,keys:n=e},r){if(n===null){let o=new Set;return t.map(s=>{let a=r&&r.find(i=>i.item===s&&i.phase!=="leave"&&!o.has(i));return a?(o.add(a),a.key):esm_er++})}return G.und(n)?t:G.fun(n)?t.map(n):zt(n)}var hs=({container:t,...e}={})=>{let[n,r]=esm_J(()=>({scrollX:0,scrollY:0,scrollXProgress:0,scrollYProgress:0,...e}),[]);return or(()=>{let o=rr(({x:s,y:a})=>{r.start({scrollX:s.current,scrollXProgress:s.progress,scrollY:a.current,scrollYProgress:a.progress})},{container:t?.current||void 0});return()=>{nr(Object.values(n),s=>s.stop()),o()}},[]),n};var Ps=({container:t,...e})=>{let[n,r]=esm_J(()=>({width:0,height:0,...e}),[]);return ar(()=>{let o=sr(({width:s,height:a})=>{r.start({width:s,height:a,immediate:n.width.get()===0||n.height.get()===0})},{container:t?.current||void 0});return()=>{ir(Object.values(n),s=>s.stop()),o()}},[]),n};var cr={any:0,all:1};function Cs(t,e){let[n,r]=pr(!1),o=ur(),s=Bt.fun(t)&&t,a=s?s():{},{to:i={},from:u={},...p}=a,f=s?e:t,[d,m]=esm_J(()=>({from:u,...p}),[]);return lr(()=>{let b=o.current,{root:c,once:P,amount:l="any",...h}=f??{};if(!b||P&&n||typeof IntersectionObserver>"u")return;let g=new WeakMap,x=()=>(i&&m.start(i),r(!0),P?void 0:()=>{u&&m.start(u),r(!1)}),S=V=>{V.forEach(_=>{let v=g.get(_.target);if(_.isIntersecting!==Boolean(v))if(_.isIntersecting){let w=x();Bt.fun(w)?g.set(_.target,w):A.unobserve(_.target)}else v&&(v(),g.delete(_.target))})},A=new IntersectionObserver(S,{root:c&&c.current||void 0,threshold:typeof l=="number"||Array.isArray(l)?l:cr[l],...h});return A.observe(b),()=>A.unobserve(b)},[f]),s?[o,d]:[o,n]}function qs({children:t,...e}){return t(esm_J(e))}function Bs({items:t,children:e,...n}){let r=esm_Qt(t.length,n);return t.map((o,s)=>{let a=e(o,s);return fr.fun(a)?a(r[s]):a})}function Ys({items:t,children:e,...n}){return esm_Gt(t,n)(e)}var esm_W=class extends esm_X{constructor(n,r){super();this.source=n;this.calc=W(...r);let o=this._get(),s=esm_Le(o);esm_D(this,s.create(o))}key;idle=!0;calc;_active=new Set;advance(n){let r=this._get(),o=this.get();bt(r,o)||(dist_esm_k(this).setValue(r),this._onChange(r,this.idle)),!this.idle&&Yt(this._active)&&esm_ct(this)}_get(){let n=dist_esm_l.arr(this.source)?this.source.map(ve):ht(ve(this.source));return this.calc(...n)}_start(){this.idle&&!Yt(this._active)&&(this.idle=!1,esm_Ve(F(this),n=>{n.done=!1}),dist_esm_p.skipAnimation?(esm_n.batchedUpdates(()=>this.advance()),esm_ct(this)):qe.start(this))}_attach(){let n=1;esm_Ve(ht(this.source),r=>{Pt(r)&&Gt(r,this),esm_Re(r)&&(r.idle||this._active.add(r),n=Math.max(n,r.priority+1))}),this.priority=n,this._start()}_detach(){esm_Ve(ht(this.source),n=>{Pt(n)&&Qt(n,this)}),this._active.clear(),esm_ct(this)}eventObserved(n){n.type=="change"?n.idle?this.advance():(this._active.add(n.parent),this._start()):n.type=="idle"?this._active.delete(n.parent):n.type=="priority"&&(this.priority=ht(this.source).reduce((r,o)=>Math.max(r,(esm_Re(o)?o.priority:0)+1),0))}};function vr(t){return t.idle!==!1}function Yt(t){return!t.size||Array.from(t).every(vr)}function esm_ct(t){t.idle||(t.idle=!0,esm_Ve(F(t),e=>{e.done=!0}),$t(t,{type:"idle",parent:t}))}var esm_ui=(t,...e)=>new esm_W(t,e),pi=(t,...e)=>(Cr(),new esm_W(t,e));dist_esm_p.assign({createStringInterpolator:Xt,to:(t,e)=>new esm_W(t,e)});var di=qe.advance;
40256  
40257  ;// external "ReactDOM"
40258  const external_ReactDOM_namespaceObject = window["ReactDOM"];
40259  ;// ./node_modules/@react-spring/web/dist/esm/index.js
40260  var web_dist_esm_k=/^--/;function web_dist_esm_I(t,e){return e==null||typeof e=="boolean"||e===""?"":typeof e=="number"&&e!==0&&!web_dist_esm_k.test(t)&&!(web_dist_esm_c.hasOwnProperty(t)&&web_dist_esm_c[t])?e+"px":(""+e).trim()}var web_dist_esm_v={};function esm_V(t,e){if(!t.nodeType||!t.setAttribute)return!1;let r=t.nodeName==="filter"||t.parentNode&&t.parentNode.nodeName==="filter",{style:i,children:s,scrollTop:u,scrollLeft:l,viewBox:a,...n}=e,d=Object.values(n),m=Object.keys(n).map(o=>r||t.hasAttribute(o)?o:web_dist_esm_v[o]||(web_dist_esm_v[o]=o.replace(/([A-Z])/g,p=>"-"+p.toLowerCase())));s!==void 0&&(t.textContent=s);for(let o in i)if(i.hasOwnProperty(o)){let p=web_dist_esm_I(o,i[o]);web_dist_esm_k.test(o)?t.style.setProperty(o,p):t.style[o]=p}m.forEach((o,p)=>{t.setAttribute(o,d[p])}),u!==void 0&&(t.scrollTop=u),l!==void 0&&(t.scrollLeft=l),a!==void 0&&t.setAttribute("viewBox",a)}var web_dist_esm_c={animationIterationCount:!0,borderImageOutset:!0,borderImageSlice:!0,borderImageWidth:!0,boxFlex:!0,boxFlexGroup:!0,boxOrdinalGroup:!0,columnCount:!0,columns:!0,flex:!0,flexGrow:!0,flexPositive:!0,flexShrink:!0,flexNegative:!0,flexOrder:!0,gridRow:!0,gridRowEnd:!0,gridRowSpan:!0,gridRowStart:!0,gridColumn:!0,gridColumnEnd:!0,gridColumnSpan:!0,gridColumnStart:!0,fontWeight:!0,lineClamp:!0,lineHeight:!0,opacity:!0,order:!0,orphans:!0,tabSize:!0,widows:!0,zIndex:!0,zoom:!0,fillOpacity:!0,floodOpacity:!0,stopOpacity:!0,strokeDasharray:!0,strokeDashoffset:!0,strokeMiterlimit:!0,strokeOpacity:!0,strokeWidth:!0},esm_F=(t,e)=>t+e.charAt(0).toUpperCase()+e.substring(1),esm_L=["Webkit","Ms","Moz","O"];web_dist_esm_c=Object.keys(web_dist_esm_c).reduce((t,e)=>(esm_L.forEach(r=>t[esm_F(r,e)]=t[e]),t),web_dist_esm_c);var esm_=/^(matrix|translate|scale|rotate|skew)/,dist_esm_$=/^(translate)/,dist_esm_G=/^(rotate|skew)/,web_dist_esm_y=(t,e)=>dist_esm_l.num(t)&&t!==0?t+e:t,web_dist_esm_h=(t,e)=>dist_esm_l.arr(t)?t.every(r=>web_dist_esm_h(r,e)):dist_esm_l.num(t)?t===e:parseFloat(t)===e,dist_esm_g=class extends animated_dist_esm_u{constructor({x:e,y:r,z:i,...s}){let u=[],l=[];(e||r||i)&&(u.push([e||0,r||0,i||0]),l.push(a=>[`translate3d($a.map(n=>web_dist_esm_y(n,"px")).join(",")})`,web_dist_esm_h(a,0)])),xt(s,(a,n)=>{if(n==="transform")u.push([a||""]),l.push(d=>[d,d===""]);else if(esm_.test(n)){if(delete s[n],dist_esm_l.und(a))return;let d=dist_esm_$.test(n)?"px":dist_esm_G.test(n)?"deg":"";u.push(ht(a)),l.push(n==="rotate3d"?([m,o,p,O])=>[`rotate3d($m},$o},$p},$web_dist_esm_y(O,d)})`,web_dist_esm_h(O,0)]:m=>[`$n}($m.map(o=>web_dist_esm_y(o,d)).join(",")})`,web_dist_esm_h(m,n.startsWith("scale")?1:0)])}}),u.length&&(s.transform=new web_dist_esm_x(u,l)),super(s)}},web_dist_esm_x=class extends esm_ge{constructor(r,i){super();this.inputs=r;this.transforms=i}_value=null;get(){return this._value||(this._value=this._get())}_get(){let r="",i=!0;return esm_Ve(this.inputs,(s,u)=>{let l=ve(s[0]),[a,n]=this.transforms[u](dist_esm_l.arr(l)?l:s.map(ve));r+=" "+a,i=i&&n}),i?"none":r}observerAdded(r){r==1&&esm_Ve(this.inputs,i=>esm_Ve(i,s=>Pt(s)&&Gt(s,this)))}observerRemoved(r){r==0&&esm_Ve(this.inputs,i=>esm_Ve(i,s=>Pt(s)&&Qt(s,this)))}eventObserved(r){r.type=="change"&&(this._value=null),$t(this,r)}};var esm_C=["a","abbr","address","area","article","aside","audio","b","base","bdi","bdo","big","blockquote","body","br","button","canvas","caption","cite","code","col","colgroup","data","datalist","dd","del","details","dfn","dialog","div","dl","dt","em","embed","fieldset","figcaption","figure","footer","form","h1","h2","h3","h4","h5","h6","head","header","hgroup","hr","html","i","iframe","img","input","ins","kbd","keygen","label","legend","li","link","main","map","mark","menu","menuitem","meta","meter","nav","noscript","object","ol","optgroup","option","output","p","param","picture","pre","progress","q","rp","rt","ruby","s","samp","script","section","select","small","source","span","strong","style","sub","summary","sup","table","tbody","td","textarea","tfoot","th","thead","time","title","tr","track","u","ul","var","video","wbr","circle","clipPath","defs","ellipse","foreignObject","g","image","line","linearGradient","mask","path","pattern","polygon","polyline","radialGradient","rect","stop","svg","text","tspan"];dist_esm_p.assign({batchedUpdates:external_ReactDOM_namespaceObject.unstable_batchedUpdates,createStringInterpolator:Xt,colors:It});var dist_esm_q=dist_esm_Ke(esm_C,{applyAnimatedValues:esm_V,createAnimatedStyle:t=>new dist_esm_g(t),getComponentProps:({scrollTop:t,scrollLeft:e,...r})=>r}),dist_esm_it=dist_esm_q.animated;
40261  
40262  ;// ./node_modules/@wordpress/block-editor/build-module/components/use-moving-animation/index.js
40263  /**
40264   * External dependencies
40265   */
40266  
40267  
40268  /**
40269   * WordPress dependencies
40270   */
40271  
40272  
40273  
40274  
40275  /**
40276   * Internal dependencies
40277   */
40278  
40279  
40280  /**
40281   * If the block count exceeds the threshold, we disable the reordering animation
40282   * to avoid laginess.
40283   */
40284  const BLOCK_ANIMATION_THRESHOLD = 200;
40285  function getAbsolutePosition(element) {
40286    return {
40287      top: element.offsetTop,
40288      left: element.offsetLeft
40289    };
40290  }
40291  
40292  /**
40293   * Hook used to compute the styles required to move a div into a new position.
40294   *
40295   * The way this animation works is the following:
40296   *  - It first renders the element as if there was no animation.
40297   *  - It takes a snapshot of the position of the block to use it
40298   *    as a destination point for the animation.
40299   *  - It restores the element to the previous position using a CSS transform
40300   *  - It uses the "resetAnimation" flag to reset the animation
40301   *    from the beginning in order to animate to the new destination point.
40302   *
40303   * @param {Object} $1                          Options
40304   * @param {*}      $1.triggerAnimationOnChange Variable used to trigger the animation if it changes.
40305   * @param {string} $1.clientId
40306   */
40307  function useMovingAnimation({
40308    triggerAnimationOnChange,
40309    clientId
40310  }) {
40311    const ref = (0,external_wp_element_namespaceObject.useRef)();
40312    const {
40313      isTyping,
40314      getGlobalBlockCount,
40315      isBlockSelected,
40316      isFirstMultiSelectedBlock,
40317      isBlockMultiSelected,
40318      isAncestorMultiSelected,
40319      isDraggingBlocks
40320    } = (0,external_wp_data_namespaceObject.useSelect)(store);
40321  
40322    // Whenever the trigger changes, we need to take a snapshot of the current
40323    // position of the block to use it as a destination point for the animation.
40324    const {
40325      previous,
40326      prevRect
40327    } = (0,external_wp_element_namespaceObject.useMemo)(() => ({
40328      previous: ref.current && getAbsolutePosition(ref.current),
40329      prevRect: ref.current && ref.current.getBoundingClientRect()
40330    }), [triggerAnimationOnChange]);
40331    (0,external_wp_element_namespaceObject.useLayoutEffect)(() => {
40332      if (!previous || !ref.current) {
40333        return;
40334      }
40335      const scrollContainer = (0,external_wp_dom_namespaceObject.getScrollContainer)(ref.current);
40336      const isSelected = isBlockSelected(clientId);
40337      const adjustScrolling = isSelected || isFirstMultiSelectedBlock(clientId);
40338      const isDragging = isDraggingBlocks();
40339      function preserveScrollPosition() {
40340        // The user already scrolled when dragging blocks.
40341        if (isDragging) {
40342          return;
40343        }
40344        if (adjustScrolling && prevRect) {
40345          const blockRect = ref.current.getBoundingClientRect();
40346          const diff = blockRect.top - prevRect.top;
40347          if (diff) {
40348            scrollContainer.scrollTop += diff;
40349          }
40350        }
40351      }
40352  
40353      // We disable the animation if the user has a preference for reduced
40354      // motion, if the user is typing (insertion by Enter), or if the block
40355      // count exceeds the threshold (insertion caused all the blocks that
40356      // follow to animate).
40357      // To do: consider enabling the _moving_ animation even for large
40358      // posts, while only disabling the _insertion_ animation?
40359      const disableAnimation = window.matchMedia('(prefers-reduced-motion: reduce)').matches || isTyping() || getGlobalBlockCount() > BLOCK_ANIMATION_THRESHOLD;
40360      if (disableAnimation) {
40361        // If the animation is disabled and the scroll needs to be adjusted,
40362        // just move directly to the final scroll position.
40363        preserveScrollPosition();
40364        return;
40365      }
40366      const isPartOfSelection = isSelected || isBlockMultiSelected(clientId) || isAncestorMultiSelected(clientId);
40367  
40368      // The user already dragged the blocks to the new position, so don't
40369      // animate the dragged blocks.
40370      if (isPartOfSelection && isDragging) {
40371        return;
40372      }
40373  
40374      // Make sure the other blocks move under the selected block(s).
40375      const zIndex = isPartOfSelection ? '1' : '';
40376      const controller = new esm_le({
40377        x: 0,
40378        y: 0,
40379        config: {
40380          mass: 5,
40381          tension: 2000,
40382          friction: 200
40383        },
40384        onChange({
40385          value
40386        }) {
40387          if (!ref.current) {
40388            return;
40389          }
40390          let {
40391            x,
40392            y
40393          } = value;
40394          x = Math.round(x);
40395          y = Math.round(y);
40396          const finishedMoving = x === 0 && y === 0;
40397          ref.current.style.transformOrigin = 'center center';
40398          ref.current.style.transform = finishedMoving ? null // Set to `null` to explicitly remove the transform.
40399          : `translate3d($x}px,$y}px,0)`;
40400          ref.current.style.zIndex = zIndex;
40401          preserveScrollPosition();
40402        }
40403      });
40404      ref.current.style.transform = undefined;
40405      const destination = getAbsolutePosition(ref.current);
40406      const x = Math.round(previous.left - destination.left);
40407      const y = Math.round(previous.top - destination.top);
40408      controller.start({
40409        x: 0,
40410        y: 0,
40411        from: {
40412          x,
40413          y
40414        }
40415      });
40416      return () => {
40417        controller.stop();
40418        controller.set({
40419          x: 0,
40420          y: 0
40421        });
40422      };
40423    }, [previous, prevRect, clientId, isTyping, getGlobalBlockCount, isBlockSelected, isFirstMultiSelectedBlock, isBlockMultiSelected, isAncestorMultiSelected, isDraggingBlocks]);
40424    return ref;
40425  }
40426  /* harmony default export */ const use_moving_animation = (useMovingAnimation);
40427  
40428  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-list/use-block-props/use-focus-first-element.js
40429  /**
40430   * WordPress dependencies
40431   */
40432  
40433  
40434  
40435  
40436  /**
40437   * Internal dependencies
40438   */
40439  
40440  
40441  
40442  
40443  /** @typedef {import('@wordpress/element').RefObject} RefObject */
40444  
40445  /**
40446   * Transitions focus to the block or inner tabbable when the block becomes
40447   * selected and an initial position is set.
40448   *
40449   * @param {string} clientId Block client ID.
40450   *
40451   * @return {RefObject} React ref with the block element.
40452   */
40453  function useFocusFirstElement({
40454    clientId,
40455    initialPosition
40456  }) {
40457    const ref = (0,external_wp_element_namespaceObject.useRef)();
40458    const {
40459      isBlockSelected,
40460      isMultiSelecting,
40461      isZoomOut
40462    } = unlock((0,external_wp_data_namespaceObject.useSelect)(store));
40463    (0,external_wp_element_namespaceObject.useEffect)(() => {
40464      // Check if the block is still selected at the time this effect runs.
40465      if (!isBlockSelected(clientId) || isMultiSelecting() || isZoomOut()) {
40466        return;
40467      }
40468      if (initialPosition === undefined || initialPosition === null) {
40469        return;
40470      }
40471      if (!ref.current) {
40472        return;
40473      }
40474      const {
40475        ownerDocument
40476      } = ref.current;
40477  
40478      // Do not focus the block if it already contains the active element.
40479      if (isInsideRootBlock(ref.current, ownerDocument.activeElement)) {
40480        return;
40481      }
40482  
40483      // Find all tabbables within node.
40484      const textInputs = external_wp_dom_namespaceObject.focus.tabbable.find(ref.current).filter(node => (0,external_wp_dom_namespaceObject.isTextField)(node));
40485  
40486      // If reversed (e.g. merge via backspace), use the last in the set of
40487      // tabbables.
40488      const isReverse = -1 === initialPosition;
40489      const target = textInputs[isReverse ? textInputs.length - 1 : 0] || ref.current;
40490      if (!isInsideRootBlock(ref.current, target)) {
40491        ref.current.focus();
40492        return;
40493      }
40494  
40495      // Check to see if element is focussable before a generic caret insert.
40496      if (!ref.current.getAttribute('contenteditable')) {
40497        const focusElement = external_wp_dom_namespaceObject.focus.tabbable.findNext(ref.current);
40498        // Make sure focusElement is valid, contained in the same block, and a form field.
40499        if (focusElement && isInsideRootBlock(ref.current, focusElement) && (0,external_wp_dom_namespaceObject.isFormElement)(focusElement)) {
40500          focusElement.focus();
40501          return;
40502        }
40503      }
40504      (0,external_wp_dom_namespaceObject.placeCaretAtHorizontalEdge)(target, isReverse);
40505    }, [initialPosition, clientId]);
40506    return ref;
40507  }
40508  
40509  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-list/use-block-props/use-is-hovered.js
40510  /**
40511   * WordPress dependencies
40512   */
40513  
40514  
40515  
40516  /**
40517   * Internal dependencies
40518   */
40519  
40520  
40521  /*
40522   * Adds `is-hovered` class when the block is hovered and in navigation or
40523   * outline mode.
40524   */
40525  function useIsHovered({
40526    clientId
40527  }) {
40528    const {
40529      hoverBlock
40530    } = (0,external_wp_data_namespaceObject.useDispatch)(store);
40531    function listener(event) {
40532      if (event.defaultPrevented) {
40533        return;
40534      }
40535      const action = event.type === 'mouseover' ? 'add' : 'remove';
40536      event.preventDefault();
40537      event.currentTarget.classList[action]('is-hovered');
40538      if (action === 'add') {
40539        hoverBlock(clientId);
40540      } else {
40541        hoverBlock(null);
40542      }
40543    }
40544    return (0,external_wp_compose_namespaceObject.useRefEffect)(node => {
40545      node.addEventListener('mouseout', listener);
40546      node.addEventListener('mouseover', listener);
40547      return () => {
40548        node.removeEventListener('mouseout', listener);
40549        node.removeEventListener('mouseover', listener);
40550  
40551        // Remove class in case it lingers.
40552        node.classList.remove('is-hovered');
40553        hoverBlock(null);
40554      };
40555    }, []);
40556  }
40557  
40558  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-list/use-block-props/use-focus-handler.js
40559  /**
40560   * WordPress dependencies
40561   */
40562  
40563  
40564  
40565  /**
40566   * Internal dependencies
40567   */
40568  
40569  
40570  
40571  /**
40572   * Selects the block if it receives focus.
40573   *
40574   * @param {string} clientId Block client ID.
40575   */
40576  function useFocusHandler(clientId) {
40577    const {
40578      isBlockSelected
40579    } = (0,external_wp_data_namespaceObject.useSelect)(store);
40580    const {
40581      selectBlock,
40582      selectionChange
40583    } = (0,external_wp_data_namespaceObject.useDispatch)(store);
40584    return (0,external_wp_compose_namespaceObject.useRefEffect)(node => {
40585      /**
40586       * Marks the block as selected when focused and not already
40587       * selected. This specifically handles the case where block does not
40588       * set focus on its own (via `setFocus`), typically if there is no
40589       * focusable input in the block.
40590       *
40591       * @param {FocusEvent} event Focus event.
40592       */
40593      function onFocus(event) {
40594        // When the whole editor is editable, let writing flow handle
40595        // selection.
40596        if (node.parentElement.closest('[contenteditable="true"]')) {
40597          return;
40598        }
40599  
40600        // Check synchronously because a non-selected block might be
40601        // getting data through `useSelect` asynchronously.
40602        if (isBlockSelected(clientId)) {
40603          // Potentially change selection away from rich text.
40604          if (!event.target.isContentEditable) {
40605            selectionChange(clientId);
40606          }
40607          return;
40608        }
40609  
40610        // If an inner block is focussed, that block is responsible for
40611        // setting the selected block.
40612        if (!isInsideRootBlock(node, event.target)) {
40613          return;
40614        }
40615        selectBlock(clientId);
40616      }
40617      node.addEventListener('focusin', onFocus);
40618      return () => {
40619        node.removeEventListener('focusin', onFocus);
40620      };
40621    }, [isBlockSelected, selectBlock]);
40622  }
40623  
40624  ;// ./node_modules/@wordpress/icons/build-module/library/drag-handle.js
40625  /**
40626   * WordPress dependencies
40627   */
40628  
40629  
40630  const dragHandle = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
40631    width: "24",
40632    height: "24",
40633    xmlns: "http://www.w3.org/2000/svg",
40634    viewBox: "0 0 24 24",
40635    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
40636      d: "M8 7h2V5H8v2zm0 6h2v-2H8v2zm0 6h2v-2H8v2zm6-14v2h2V5h-2zm0 8h2v-2h-2v2zm0 6h2v-2h-2v2z"
40637    })
40638  });
40639  /* harmony default export */ const drag_handle = (dragHandle);
40640  
40641  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-draggable/draggable-chip.js
40642  /**
40643   * WordPress dependencies
40644   */
40645  
40646  
40647  
40648  
40649  /**
40650   * Internal dependencies
40651   */
40652  
40653  
40654  function BlockDraggableChip({
40655    count,
40656    icon,
40657    isPattern,
40658    fadeWhenDisabled
40659  }) {
40660    const patternLabel = isPattern && (0,external_wp_i18n_namespaceObject.__)('Pattern');
40661    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
40662      className: "block-editor-block-draggable-chip-wrapper",
40663      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
40664        className: "block-editor-block-draggable-chip",
40665        "data-testid": "block-draggable-chip",
40666        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.Flex, {
40667          justify: "center",
40668          className: "block-editor-block-draggable-chip__content",
40669          children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FlexItem, {
40670            children: icon ? /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_icon, {
40671              icon: icon
40672            }) : patternLabel || (0,external_wp_i18n_namespaceObject.sprintf)(/* translators: %d: Number of blocks. */
40673            (0,external_wp_i18n_namespaceObject._n)('%d block', '%d blocks', count), count)
40674          }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FlexItem, {
40675            children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_icon, {
40676              icon: drag_handle
40677            })
40678          }), fadeWhenDisabled && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FlexItem, {
40679            className: "block-editor-block-draggable-chip__disabled",
40680            children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("span", {
40681              className: "block-editor-block-draggable-chip__disabled-icon"
40682            })
40683          })]
40684        })
40685      })
40686    });
40687  }
40688  
40689  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-list/use-block-props/use-selected-block-event-handlers.js
40690  /**
40691   * WordPress dependencies
40692   */
40693  
40694  
40695  
40696  
40697  
40698  
40699  
40700  /**
40701   * Internal dependencies
40702   */
40703  
40704  
40705  
40706  
40707  /**
40708   * Adds block behaviour:
40709   *   - Removes the block on BACKSPACE.
40710   *   - Inserts a default block on ENTER.
40711   *   - Disables dragging of block contents.
40712   *
40713   * @param {string} clientId Block client ID.
40714   */
40715  
40716  function useEventHandlers({
40717    clientId,
40718    isSelected
40719  }) {
40720    const {
40721      getBlockType
40722    } = (0,external_wp_data_namespaceObject.useSelect)(external_wp_blocks_namespaceObject.store);
40723    const {
40724      getBlockRootClientId,
40725      isZoomOut,
40726      hasMultiSelection,
40727      getBlockName
40728    } = unlock((0,external_wp_data_namespaceObject.useSelect)(store));
40729    const {
40730      insertAfterBlock,
40731      removeBlock,
40732      resetZoomLevel,
40733      startDraggingBlocks,
40734      stopDraggingBlocks
40735    } = unlock((0,external_wp_data_namespaceObject.useDispatch)(store));
40736    return (0,external_wp_compose_namespaceObject.useRefEffect)(node => {
40737      if (!isSelected) {
40738        return;
40739      }
40740  
40741      /**
40742       * Interprets keydown event intent to remove or insert after block if
40743       * key event occurs on wrapper node. This can occur when the block has
40744       * no text fields of its own, particularly after initial insertion, to
40745       * allow for easy deletion and continuous writing flow to add additional
40746       * content.
40747       *
40748       * @param {KeyboardEvent} event Keydown event.
40749       */
40750      function onKeyDown(event) {
40751        const {
40752          keyCode,
40753          target
40754        } = event;
40755        if (keyCode !== external_wp_keycodes_namespaceObject.ENTER && keyCode !== external_wp_keycodes_namespaceObject.BACKSPACE && keyCode !== external_wp_keycodes_namespaceObject.DELETE) {
40756          return;
40757        }
40758        if (target !== node || (0,external_wp_dom_namespaceObject.isTextField)(target)) {
40759          return;
40760        }
40761        event.preventDefault();
40762        if (keyCode === external_wp_keycodes_namespaceObject.ENTER && isZoomOut()) {
40763          resetZoomLevel();
40764        } else if (keyCode === external_wp_keycodes_namespaceObject.ENTER) {
40765          insertAfterBlock(clientId);
40766        } else {
40767          removeBlock(clientId);
40768        }
40769      }
40770  
40771      /**
40772       * Prevents default dragging behavior within a block. To do: we must
40773       * handle this in the future and clean up the drag target.
40774       *
40775       * @param {DragEvent} event Drag event.
40776       */
40777      function onDragStart(event) {
40778        if (node !== event.target || node.isContentEditable || node.ownerDocument.activeElement !== node || hasMultiSelection()) {
40779          event.preventDefault();
40780          return;
40781        }
40782        const data = JSON.stringify({
40783          type: 'block',
40784          srcClientIds: [clientId],
40785          srcRootClientId: getBlockRootClientId(clientId)
40786        });
40787        event.dataTransfer.effectAllowed = 'move'; // remove "+" cursor
40788        event.dataTransfer.clearData();
40789        event.dataTransfer.setData('wp-blocks', data);
40790        const {
40791          ownerDocument
40792        } = node;
40793        const {
40794          defaultView
40795        } = ownerDocument;
40796        const selection = defaultView.getSelection();
40797        selection.removeAllRanges();
40798        const domNode = document.createElement('div');
40799        const root = (0,external_wp_element_namespaceObject.createRoot)(domNode);
40800        root.render(/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockDraggableChip, {
40801          icon: getBlockType(getBlockName(clientId)).icon
40802        }));
40803        document.body.appendChild(domNode);
40804        domNode.style.position = 'absolute';
40805        domNode.style.top = '0';
40806        domNode.style.left = '0';
40807        domNode.style.zIndex = '1000';
40808        domNode.style.pointerEvents = 'none';
40809  
40810        // Setting the drag chip as the drag image actually works, but
40811        // the behaviour is slightly different in every browser. In
40812        // Safari, it animates, in Firefox it's slightly transparent...
40813        // So we set a fake drag image and have to reposition it
40814        // ourselves.
40815        const dragElement = ownerDocument.createElement('div');
40816        // Chrome will show a globe icon if the drag element does not
40817        // have dimensions.
40818        dragElement.style.width = '1px';
40819        dragElement.style.height = '1px';
40820        dragElement.style.position = 'fixed';
40821        dragElement.style.visibility = 'hidden';
40822        ownerDocument.body.appendChild(dragElement);
40823        event.dataTransfer.setDragImage(dragElement, 0, 0);
40824        let offset = {
40825          x: 0,
40826          y: 0
40827        };
40828        if (document !== ownerDocument) {
40829          const frame = defaultView.frameElement;
40830          if (frame) {
40831            const rect = frame.getBoundingClientRect();
40832            offset = {
40833              x: rect.left,
40834              y: rect.top
40835            };
40836          }
40837        }
40838  
40839        // chip handle offset
40840        offset.x -= 58;
40841        function over(e) {
40842          domNode.style.transform = `translate( $e.clientX + offset.x}px, $e.clientY + offset.y}px )`;
40843        }
40844        over(event);
40845        function end() {
40846          ownerDocument.removeEventListener('dragover', over);
40847          ownerDocument.removeEventListener('dragend', end);
40848          domNode.remove();
40849          dragElement.remove();
40850          stopDraggingBlocks();
40851          document.body.classList.remove('is-dragging-components-draggable');
40852          ownerDocument.documentElement.classList.remove('is-dragging');
40853        }
40854        ownerDocument.addEventListener('dragover', over);
40855        ownerDocument.addEventListener('dragend', end);
40856        ownerDocument.addEventListener('drop', end);
40857        startDraggingBlocks([clientId]);
40858        // Important because it hides the block toolbar.
40859        document.body.classList.add('is-dragging-components-draggable');
40860        ownerDocument.documentElement.classList.add('is-dragging');
40861      }
40862      node.addEventListener('keydown', onKeyDown);
40863      node.addEventListener('dragstart', onDragStart);
40864      return () => {
40865        node.removeEventListener('keydown', onKeyDown);
40866        node.removeEventListener('dragstart', onDragStart);
40867      };
40868    }, [clientId, isSelected, getBlockRootClientId, insertAfterBlock, removeBlock, isZoomOut, resetZoomLevel, hasMultiSelection, startDraggingBlocks, stopDraggingBlocks]);
40869  }
40870  
40871  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-list/use-block-props/use-intersection-observer.js
40872  /**
40873   * WordPress dependencies
40874   */
40875  
40876  
40877  
40878  /**
40879   * Internal dependencies
40880   */
40881  
40882  function useIntersectionObserver() {
40883    const observer = (0,external_wp_element_namespaceObject.useContext)(block_list_IntersectionObserver);
40884    return (0,external_wp_compose_namespaceObject.useRefEffect)(node => {
40885      if (observer) {
40886        observer.observe(node);
40887        return () => {
40888          observer.unobserve(node);
40889        };
40890      }
40891    }, [observer]);
40892  }
40893  
40894  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-list/use-block-props/use-scroll-into-view.js
40895  /**
40896   * WordPress dependencies
40897   */
40898  
40899  function useScrollIntoView({
40900    isSelected
40901  }) {
40902    const prefersReducedMotion = (0,external_wp_compose_namespaceObject.useReducedMotion)();
40903    return (0,external_wp_compose_namespaceObject.useRefEffect)(node => {
40904      if (isSelected) {
40905        const {
40906          ownerDocument
40907        } = node;
40908        const {
40909          defaultView
40910        } = ownerDocument;
40911        if (!defaultView.IntersectionObserver) {
40912          return;
40913        }
40914        const observer = new defaultView.IntersectionObserver(entries => {
40915          // Once observing starts, we always get an initial
40916          // entry with the intersecting state.
40917          if (!entries[0].isIntersecting) {
40918            node.scrollIntoView({
40919              behavior: prefersReducedMotion ? 'instant' : 'smooth'
40920            });
40921          }
40922          observer.disconnect();
40923        });
40924        observer.observe(node);
40925        return () => {
40926          observer.disconnect();
40927        };
40928      }
40929    }, [isSelected]);
40930  }
40931  
40932  ;// ./node_modules/@wordpress/block-editor/build-module/components/use-flash-editable-blocks/index.js
40933  /**
40934   * WordPress dependencies
40935   */
40936  
40937  
40938  
40939  /**
40940   * Internal dependencies
40941   */
40942  
40943  
40944  function useFlashEditableBlocks({
40945    clientId = '',
40946    isEnabled = true
40947  } = {}) {
40948    const {
40949      getEnabledClientIdsTree
40950    } = unlock((0,external_wp_data_namespaceObject.useSelect)(store));
40951    return (0,external_wp_compose_namespaceObject.useRefEffect)(element => {
40952      if (!isEnabled) {
40953        return;
40954      }
40955      const flashEditableBlocks = () => {
40956        getEnabledClientIdsTree(clientId).forEach(({
40957          clientId: id
40958        }) => {
40959          const block = element.querySelector(`[data-block="$id}"]`);
40960          if (!block) {
40961            return;
40962          }
40963          block.classList.remove('has-editable-outline');
40964          // Force reflow to trigger the animation.
40965          // eslint-disable-next-line no-unused-expressions
40966          block.offsetWidth;
40967          block.classList.add('has-editable-outline');
40968        });
40969      };
40970      const handleClick = event => {
40971        const shouldFlash = event.target === element || event.target.classList.contains('is-root-container');
40972        if (!shouldFlash) {
40973          return;
40974        }
40975        if (event.defaultPrevented) {
40976          return;
40977        }
40978        event.preventDefault();
40979        flashEditableBlocks();
40980      };
40981      element.addEventListener('click', handleClick);
40982      return () => element.removeEventListener('click', handleClick);
40983    }, [isEnabled]);
40984  }
40985  
40986  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-list/use-block-props/use-firefox-draggable-compatibility.js
40987  /**
40988   * WordPress dependencies
40989   */
40990  
40991  const nodesByDocument = new Map();
40992  function add(doc, node) {
40993    let set = nodesByDocument.get(doc);
40994    if (!set) {
40995      set = new Set();
40996      nodesByDocument.set(doc, set);
40997      doc.addEventListener('pointerdown', down);
40998    }
40999    set.add(node);
41000  }
41001  function remove(doc, node) {
41002    const set = nodesByDocument.get(doc);
41003    if (set) {
41004      set.delete(node);
41005      restore(node);
41006      if (set.size === 0) {
41007        nodesByDocument.delete(doc);
41008        doc.removeEventListener('pointerdown', down);
41009      }
41010    }
41011  }
41012  function restore(node) {
41013    const prevDraggable = node.getAttribute('data-draggable');
41014    if (prevDraggable) {
41015      node.removeAttribute('data-draggable');
41016      // Only restore if `draggable` is still removed. It could have been
41017      // changed by React in the meantime.
41018      if (prevDraggable === 'true' && !node.getAttribute('draggable')) {
41019        node.setAttribute('draggable', 'true');
41020      }
41021    }
41022  }
41023  function down(event) {
41024    const {
41025      target
41026    } = event;
41027    const {
41028      ownerDocument,
41029      isContentEditable,
41030      tagName
41031    } = target;
41032    const isInputOrTextArea = ['INPUT', 'TEXTAREA'].includes(tagName);
41033    const nodes = nodesByDocument.get(ownerDocument);
41034    if (isContentEditable || isInputOrTextArea) {
41035      // Whenever an editable element or an input or textarea is clicked,
41036      // check which draggable blocks contain this element, and temporarily
41037      // disable draggability.
41038      for (const node of nodes) {
41039        if (node.getAttribute('draggable') === 'true' && node.contains(target)) {
41040          node.removeAttribute('draggable');
41041          node.setAttribute('data-draggable', 'true');
41042        }
41043      }
41044    } else {
41045      // Whenever a non-editable element or an input or textarea is clicked,
41046      // re-enable draggability for any blocks that were previously disabled.
41047      for (const node of nodes) {
41048        restore(node);
41049      }
41050    }
41051  }
41052  
41053  /**
41054   * In Firefox, the `draggable` and `contenteditable` or `input` or `textarea`
41055   * elements don't play well together. When these elements are within a
41056   * `draggable` element, selection doesn't get set in the right place. The only
41057   * solution is to temporarily remove the `draggable` attribute clicking inside
41058   * these elements.
41059   * @return {Function} Cleanup function.
41060   */
41061  function useFirefoxDraggableCompatibility() {
41062    return (0,external_wp_compose_namespaceObject.useRefEffect)(node => {
41063      add(node.ownerDocument, node);
41064      return () => {
41065        remove(node.ownerDocument, node);
41066      };
41067    }, []);
41068  }
41069  
41070  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-list/use-block-props/index.js
41071  /**
41072   * External dependencies
41073   */
41074  
41075  
41076  /**
41077   * WordPress dependencies
41078   */
41079  
41080  
41081  
41082  
41083  
41084  
41085  /**
41086   * Internal dependencies
41087   */
41088  
41089  
41090  
41091  
41092  
41093  
41094  
41095  
41096  
41097  
41098  
41099  
41100  
41101  
41102  /**
41103   * This hook is used to lightly mark an element as a block element. The element
41104   * should be the outermost element of a block. Call this hook and pass the
41105   * returned props to the element to mark as a block. If you define a ref for the
41106   * element, it is important to pass the ref to this hook, which the hook in turn
41107   * will pass to the component through the props it returns. Optionally, you can
41108   * also pass any other props through this hook, and they will be merged and
41109   * returned.
41110   *
41111   * Use of this hook on the outermost element of a block is required if using API >= v2.
41112   *
41113   * @example
41114   * ```js
41115   * import { useBlockProps } from '@wordpress/block-editor';
41116   *
41117   * export default function Edit() {
41118   *
41119   *   const blockProps = useBlockProps( {
41120   *     className: 'my-custom-class',
41121   *     style: {
41122   *       color: '#222222',
41123   *       backgroundColor: '#eeeeee'
41124   *     }
41125   *   } )
41126   *
41127   *   return (
41128   *        <div { ...blockProps }>
41129   *
41130   *     </div>
41131   *   )
41132   * }
41133   *
41134   * ```
41135   *
41136   *
41137   * @param {Object}  props                    Optional. Props to pass to the element. Must contain
41138   *                                           the ref if one is defined.
41139   * @param {Object}  options                  Options for internal use only.
41140   * @param {boolean} options.__unstableIsHtml
41141   *
41142   * @return {Object} Props to pass to the element to mark as a block.
41143   */
41144  function use_block_props_useBlockProps(props = {}, {
41145    __unstableIsHtml
41146  } = {}) {
41147    const {
41148      clientId,
41149      className,
41150      wrapperProps = {},
41151      isAligned,
41152      index,
41153      mode,
41154      name,
41155      blockApiVersion,
41156      blockTitle,
41157      isSelected,
41158      isSubtreeDisabled,
41159      hasOverlay,
41160      initialPosition,
41161      blockEditingMode,
41162      isHighlighted,
41163      isMultiSelected,
41164      isPartiallySelected,
41165      isReusable,
41166      isDragging,
41167      hasChildSelected,
41168      isEditingDisabled,
41169      hasEditableOutline,
41170      isTemporarilyEditingAsBlocks,
41171      defaultClassName,
41172      isSectionBlock,
41173      canMove
41174    } = (0,external_wp_element_namespaceObject.useContext)(PrivateBlockContext);
41175  
41176    // translators: %s: Type of block (i.e. Text, Image etc)
41177    const blockLabel = (0,external_wp_i18n_namespaceObject.sprintf)((0,external_wp_i18n_namespaceObject.__)('Block: %s'), blockTitle);
41178    const htmlSuffix = mode === 'html' && !__unstableIsHtml ? '-visual' : '';
41179    const ffDragRef = useFirefoxDraggableCompatibility();
41180    const mergedRefs = (0,external_wp_compose_namespaceObject.useMergeRefs)([props.ref, useFocusFirstElement({
41181      clientId,
41182      initialPosition
41183    }), useBlockRefProvider(clientId), useFocusHandler(clientId), useEventHandlers({
41184      clientId,
41185      isSelected
41186    }), useIsHovered({
41187      clientId
41188    }), useIntersectionObserver(), use_moving_animation({
41189      triggerAnimationOnChange: index,
41190      clientId
41191    }), (0,external_wp_compose_namespaceObject.useDisabled)({
41192      isDisabled: !hasOverlay
41193    }), useFlashEditableBlocks({
41194      clientId,
41195      isEnabled: isSectionBlock
41196    }), useScrollIntoView({
41197      isSelected
41198    }), canMove ? ffDragRef : undefined]);
41199    const blockEditContext = useBlockEditContext();
41200    const hasBlockBindings = !!blockEditContext[blockBindingsKey];
41201    const bindingsStyle = hasBlockBindings && canBindBlock(name) ? {
41202      '--wp-admin-theme-color': 'var(--wp-block-synced-color)',
41203      '--wp-admin-theme-color--rgb': 'var(--wp-block-synced-color--rgb)'
41204    } : {};
41205  
41206    // Ensures it warns only inside the `edit` implementation for the block.
41207    if (blockApiVersion < 2 && clientId === blockEditContext.clientId) {
41208       true ? external_wp_warning_default()(`Block type "$name}" must support API version 2 or higher to work correctly with "useBlockProps" method.`) : 0;
41209    }
41210    let hasNegativeMargin = false;
41211    if (wrapperProps?.style?.marginTop?.charAt(0) === '-' || wrapperProps?.style?.marginBottom?.charAt(0) === '-' || wrapperProps?.style?.marginLeft?.charAt(0) === '-' || wrapperProps?.style?.marginRight?.charAt(0) === '-') {
41212      hasNegativeMargin = true;
41213    }
41214    return {
41215      tabIndex: blockEditingMode === 'disabled' ? -1 : 0,
41216      draggable: canMove && !hasChildSelected ? true : undefined,
41217      ...wrapperProps,
41218      ...props,
41219      ref: mergedRefs,
41220      id: `block-$clientId}$htmlSuffix}`,
41221      role: 'document',
41222      'aria-label': blockLabel,
41223      'data-block': clientId,
41224      'data-type': name,
41225      'data-title': blockTitle,
41226      inert: isSubtreeDisabled ? 'true' : undefined,
41227      className: dist_clsx('block-editor-block-list__block', {
41228        // The wp-block className is important for editor styles.
41229        'wp-block': !isAligned,
41230        'has-block-overlay': hasOverlay,
41231        'is-selected': isSelected,
41232        'is-highlighted': isHighlighted,
41233        'is-multi-selected': isMultiSelected,
41234        'is-partially-selected': isPartiallySelected,
41235        'is-reusable': isReusable,
41236        'is-dragging': isDragging,
41237        'has-child-selected': hasChildSelected,
41238        'is-editing-disabled': isEditingDisabled,
41239        'has-editable-outline': hasEditableOutline,
41240        'has-negative-margin': hasNegativeMargin,
41241        'is-content-locked-temporarily-editing-as-blocks': isTemporarilyEditingAsBlocks
41242      }, className, props.className, wrapperProps.className, defaultClassName),
41243      style: {
41244        ...wrapperProps.style,
41245        ...props.style,
41246        ...bindingsStyle
41247      }
41248    };
41249  }
41250  
41251  /**
41252   * Call within a save function to get the props for the block wrapper.
41253   *
41254   * @param {Object} props Optional. Props to pass to the element.
41255   */
41256  use_block_props_useBlockProps.save = external_wp_blocks_namespaceObject.__unstableGetBlockProps;
41257  
41258  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-list/block.js
41259  /**
41260   * External dependencies
41261   */
41262  
41263  
41264  /**
41265   * WordPress dependencies
41266   */
41267  
41268  
41269  
41270  
41271  
41272  
41273  
41274  /**
41275   * Internal dependencies
41276   */
41277  
41278  
41279  
41280  
41281  
41282  
41283  
41284  
41285  
41286  
41287  
41288  /**
41289   * Merges wrapper props with special handling for classNames and styles.
41290   *
41291   * @param {Object} propsA
41292   * @param {Object} propsB
41293   *
41294   * @return {Object} Merged props.
41295   */
41296  
41297  function mergeWrapperProps(propsA, propsB) {
41298    const newProps = {
41299      ...propsA,
41300      ...propsB
41301    };
41302  
41303    // May be set to undefined, so check if the property is set!
41304    if (propsA?.hasOwnProperty('className') && propsB?.hasOwnProperty('className')) {
41305      newProps.className = dist_clsx(propsA.className, propsB.className);
41306    }
41307    if (propsA?.hasOwnProperty('style') && propsB?.hasOwnProperty('style')) {
41308      newProps.style = {
41309        ...propsA.style,
41310        ...propsB.style
41311      };
41312    }
41313    return newProps;
41314  }
41315  function Block({
41316    children,
41317    isHtml,
41318    ...props
41319  }) {
41320    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
41321      ...use_block_props_useBlockProps(props, {
41322        __unstableIsHtml: isHtml
41323      }),
41324      children: children
41325    });
41326  }
41327  function BlockListBlock({
41328    block: {
41329      __unstableBlockSource
41330    },
41331    mode,
41332    isLocked,
41333    canRemove,
41334    clientId,
41335    isSelected,
41336    isSelectionEnabled,
41337    className,
41338    __unstableLayoutClassNames: layoutClassNames,
41339    name,
41340    isValid,
41341    attributes,
41342    wrapperProps,
41343    setAttributes,
41344    onReplace,
41345    onRemove,
41346    onInsertBlocksAfter,
41347    onMerge,
41348    toggleSelection
41349  }) {
41350    var _wrapperProps;
41351    const {
41352      mayDisplayControls,
41353      mayDisplayParentControls,
41354      themeSupportsLayout,
41355      ...context
41356    } = (0,external_wp_element_namespaceObject.useContext)(PrivateBlockContext);
41357    const parentLayout = useLayout() || {};
41358  
41359    // We wrap the BlockEdit component in a div that hides it when editing in
41360    // HTML mode. This allows us to render all of the ancillary pieces
41361    // (InspectorControls, etc.) which are inside `BlockEdit` but not
41362    // `BlockHTML`, even in HTML mode.
41363    let blockEdit = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockEdit, {
41364      name: name,
41365      isSelected: isSelected,
41366      attributes: attributes,
41367      setAttributes: setAttributes,
41368      insertBlocksAfter: isLocked ? undefined : onInsertBlocksAfter,
41369      onReplace: canRemove ? onReplace : undefined,
41370      onRemove: canRemove ? onRemove : undefined,
41371      mergeBlocks: canRemove ? onMerge : undefined,
41372      clientId: clientId,
41373      isSelectionEnabled: isSelectionEnabled,
41374      toggleSelection: toggleSelection,
41375      __unstableLayoutClassNames: layoutClassNames,
41376      __unstableParentLayout: Object.keys(parentLayout).length ? parentLayout : undefined,
41377      mayDisplayControls: mayDisplayControls,
41378      mayDisplayParentControls: mayDisplayParentControls,
41379      blockEditingMode: context.blockEditingMode,
41380      isPreviewMode: context.isPreviewMode
41381    });
41382    const blockType = (0,external_wp_blocks_namespaceObject.getBlockType)(name);
41383  
41384    // Determine whether the block has props to apply to the wrapper.
41385    if (blockType?.getEditWrapperProps) {
41386      wrapperProps = mergeWrapperProps(wrapperProps, blockType.getEditWrapperProps(attributes));
41387    }
41388    const isAligned = wrapperProps && !!wrapperProps['data-align'] && !themeSupportsLayout;
41389  
41390    // Support for sticky position in classic themes with alignment wrappers.
41391  
41392    const isSticky = className?.includes('is-position-sticky');
41393  
41394    // For aligned blocks, provide a wrapper element so the block can be
41395    // positioned relative to the block column.
41396    // This is only kept for classic themes that don't support layout
41397    // Historically we used to rely on extra divs and data-align to
41398    // provide the alignments styles in the editor.
41399    // Due to the differences between frontend and backend, we migrated
41400    // to the layout feature, and we're now aligning the markup of frontend
41401    // and backend.
41402    if (isAligned) {
41403      blockEdit = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
41404        className: dist_clsx('wp-block', isSticky && className),
41405        "data-align": wrapperProps['data-align'],
41406        children: blockEdit
41407      });
41408    }
41409    let block;
41410    if (!isValid) {
41411      const saveContent = __unstableBlockSource ? (0,external_wp_blocks_namespaceObject.serializeRawBlock)(__unstableBlockSource) : (0,external_wp_blocks_namespaceObject.getSaveContent)(blockType, attributes);
41412      block = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(Block, {
41413        className: "has-warning",
41414        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockInvalidWarning, {
41415          clientId: clientId
41416        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_element_namespaceObject.RawHTML, {
41417          children: (0,external_wp_dom_namespaceObject.safeHTML)(saveContent)
41418        })]
41419      });
41420    } else if (mode === 'html') {
41421      // Render blockEdit so the inspector controls don't disappear.
41422      // See #8969.
41423      block = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
41424        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
41425          style: {
41426            display: 'none'
41427          },
41428          children: blockEdit
41429        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Block, {
41430          isHtml: true,
41431          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_html, {
41432            clientId: clientId
41433          })
41434        })]
41435      });
41436    } else if (blockType?.apiVersion > 1) {
41437      block = blockEdit;
41438    } else {
41439      block = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Block, {
41440        children: blockEdit
41441      });
41442    }
41443    const {
41444      'data-align': dataAlign,
41445      ...restWrapperProps
41446    } = (_wrapperProps = wrapperProps) !== null && _wrapperProps !== void 0 ? _wrapperProps : {};
41447    const updatedWrapperProps = {
41448      ...restWrapperProps,
41449      className: dist_clsx(restWrapperProps.className, dataAlign && themeSupportsLayout && `align$dataAlign}`, !(dataAlign && isSticky) && className)
41450    };
41451  
41452    // We set a new context with the adjusted and filtered wrapperProps (through
41453    // `editor.BlockListBlock`), which the `BlockListBlockProvider` did not have
41454    // access to.
41455    // Note that the context value doesn't have to be memoized in this case
41456    // because when it changes, this component will be re-rendered anyway, and
41457    // none of the consumers (BlockListBlock and useBlockProps) are memoized or
41458    // "pure". This is different from the public BlockEditContext, where
41459    // consumers might be memoized or "pure".
41460    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PrivateBlockContext.Provider, {
41461      value: {
41462        wrapperProps: updatedWrapperProps,
41463        isAligned,
41464        ...context
41465      },
41466      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_crash_boundary, {
41467        fallback: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Block, {
41468          className: "has-warning",
41469          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_crash_warning, {})
41470        }),
41471        children: block
41472      })
41473    });
41474  }
41475  const applyWithDispatch = (0,external_wp_data_namespaceObject.withDispatch)((dispatch, ownProps, registry) => {
41476    const {
41477      updateBlockAttributes,
41478      insertBlocks,
41479      mergeBlocks,
41480      replaceBlocks,
41481      toggleSelection,
41482      __unstableMarkLastChangeAsPersistent,
41483      moveBlocksToPosition,
41484      removeBlock,
41485      selectBlock
41486    } = dispatch(store);
41487  
41488    // Do not add new properties here, use `useDispatch` instead to avoid
41489    // leaking new props to the public API (editor.BlockListBlock filter).
41490    return {
41491      setAttributes(newAttributes) {
41492        const {
41493          getMultiSelectedBlockClientIds
41494        } = registry.select(store);
41495        const multiSelectedBlockClientIds = getMultiSelectedBlockClientIds();
41496        const {
41497          clientId
41498        } = ownProps;
41499        const clientIds = multiSelectedBlockClientIds.length ? multiSelectedBlockClientIds : [clientId];
41500        updateBlockAttributes(clientIds, newAttributes);
41501      },
41502      onInsertBlocks(blocks, index) {
41503        const {
41504          rootClientId
41505        } = ownProps;
41506        insertBlocks(blocks, index, rootClientId);
41507      },
41508      onInsertBlocksAfter(blocks) {
41509        const {
41510          clientId,
41511          rootClientId
41512        } = ownProps;
41513        const {
41514          getBlockIndex
41515        } = registry.select(store);
41516        const index = getBlockIndex(clientId);
41517        insertBlocks(blocks, index + 1, rootClientId);
41518      },
41519      onMerge(forward) {
41520        const {
41521          clientId,
41522          rootClientId
41523        } = ownProps;
41524        const {
41525          getPreviousBlockClientId,
41526          getNextBlockClientId,
41527          getBlock,
41528          getBlockAttributes,
41529          getBlockName,
41530          getBlockOrder,
41531          getBlockIndex,
41532          getBlockRootClientId,
41533          canInsertBlockType
41534        } = registry.select(store);
41535        function switchToDefaultOrRemove() {
41536          const block = getBlock(clientId);
41537          const defaultBlockName = (0,external_wp_blocks_namespaceObject.getDefaultBlockName)();
41538          const defaultBlockType = (0,external_wp_blocks_namespaceObject.getBlockType)(defaultBlockName);
41539          if (getBlockName(clientId) !== defaultBlockName) {
41540            const replacement = (0,external_wp_blocks_namespaceObject.switchToBlockType)(block, defaultBlockName);
41541            if (replacement && replacement.length) {
41542              replaceBlocks(clientId, replacement);
41543            }
41544          } else if ((0,external_wp_blocks_namespaceObject.isUnmodifiedDefaultBlock)(block)) {
41545            const nextBlockClientId = getNextBlockClientId(clientId);
41546            if (nextBlockClientId) {
41547              registry.batch(() => {
41548                removeBlock(clientId);
41549                selectBlock(nextBlockClientId);
41550              });
41551            }
41552          } else if (defaultBlockType.merge) {
41553            const attributes = defaultBlockType.merge({}, block.attributes);
41554            replaceBlocks([clientId], [(0,external_wp_blocks_namespaceObject.createBlock)(defaultBlockName, attributes)]);
41555          }
41556        }
41557  
41558        /**
41559         * Moves the block with clientId up one level. If the block type
41560         * cannot be inserted at the new location, it will be attempted to
41561         * convert to the default block type.
41562         *
41563         * @param {string}  _clientId       The block to move.
41564         * @param {boolean} changeSelection Whether to change the selection
41565         *                                  to the moved block.
41566         */
41567        function moveFirstItemUp(_clientId, changeSelection = true) {
41568          const wrapperBlockName = getBlockName(_clientId);
41569          const wrapperBlockType = (0,external_wp_blocks_namespaceObject.getBlockType)(wrapperBlockName);
41570          const isTextualWrapper = wrapperBlockType.category === 'text';
41571          const targetRootClientId = getBlockRootClientId(_clientId);
41572          const blockOrder = getBlockOrder(_clientId);
41573          const [firstClientId] = blockOrder;
41574          if (blockOrder.length === 1 && (0,external_wp_blocks_namespaceObject.isUnmodifiedBlock)(getBlock(firstClientId))) {
41575            removeBlock(_clientId);
41576          } else if (isTextualWrapper) {
41577            registry.batch(() => {
41578              if (canInsertBlockType(getBlockName(firstClientId), targetRootClientId)) {
41579                moveBlocksToPosition([firstClientId], _clientId, targetRootClientId, getBlockIndex(_clientId));
41580              } else {
41581                const replacement = (0,external_wp_blocks_namespaceObject.switchToBlockType)(getBlock(firstClientId), (0,external_wp_blocks_namespaceObject.getDefaultBlockName)());
41582                if (replacement && replacement.length && replacement.every(block => canInsertBlockType(block.name, targetRootClientId))) {
41583                  insertBlocks(replacement, getBlockIndex(_clientId), targetRootClientId, changeSelection);
41584                  removeBlock(firstClientId, false);
41585                } else {
41586                  switchToDefaultOrRemove();
41587                }
41588              }
41589              if (!getBlockOrder(_clientId).length && (0,external_wp_blocks_namespaceObject.isUnmodifiedBlock)(getBlock(_clientId))) {
41590                removeBlock(_clientId, false);
41591              }
41592            });
41593          } else {
41594            switchToDefaultOrRemove();
41595          }
41596        }
41597  
41598        // For `Delete` or forward merge, we should do the exact same thing
41599        // as `Backspace`, but from the other block.
41600        if (forward) {
41601          if (rootClientId) {
41602            const nextRootClientId = getNextBlockClientId(rootClientId);
41603            if (nextRootClientId) {
41604              // If there is a block that follows with the same parent
41605              // block name and the same attributes, merge the inner
41606              // blocks.
41607              if (getBlockName(rootClientId) === getBlockName(nextRootClientId)) {
41608                const rootAttributes = getBlockAttributes(rootClientId);
41609                const previousRootAttributes = getBlockAttributes(nextRootClientId);
41610                if (Object.keys(rootAttributes).every(key => rootAttributes[key] === previousRootAttributes[key])) {
41611                  registry.batch(() => {
41612                    moveBlocksToPosition(getBlockOrder(nextRootClientId), nextRootClientId, rootClientId);
41613                    removeBlock(nextRootClientId, false);
41614                  });
41615                  return;
41616                }
41617              } else {
41618                mergeBlocks(rootClientId, nextRootClientId);
41619                return;
41620              }
41621            }
41622          }
41623          const nextBlockClientId = getNextBlockClientId(clientId);
41624          if (!nextBlockClientId) {
41625            return;
41626          }
41627          if (getBlockOrder(nextBlockClientId).length) {
41628            moveFirstItemUp(nextBlockClientId, false);
41629          } else {
41630            mergeBlocks(clientId, nextBlockClientId);
41631          }
41632        } else {
41633          const previousBlockClientId = getPreviousBlockClientId(clientId);
41634          if (previousBlockClientId) {
41635            mergeBlocks(previousBlockClientId, clientId);
41636          } else if (rootClientId) {
41637            const previousRootClientId = getPreviousBlockClientId(rootClientId);
41638  
41639            // If there is a preceding block with the same parent block
41640            // name and the same attributes, merge the inner blocks.
41641            if (previousRootClientId && getBlockName(rootClientId) === getBlockName(previousRootClientId)) {
41642              const rootAttributes = getBlockAttributes(rootClientId);
41643              const previousRootAttributes = getBlockAttributes(previousRootClientId);
41644              if (Object.keys(rootAttributes).every(key => rootAttributes[key] === previousRootAttributes[key])) {
41645                registry.batch(() => {
41646                  moveBlocksToPosition(getBlockOrder(rootClientId), rootClientId, previousRootClientId);
41647                  removeBlock(rootClientId, false);
41648                });
41649                return;
41650              }
41651            }
41652            moveFirstItemUp(rootClientId);
41653          } else {
41654            switchToDefaultOrRemove();
41655          }
41656        }
41657      },
41658      onReplace(blocks, indexToSelect, initialPosition) {
41659        if (blocks.length && !(0,external_wp_blocks_namespaceObject.isUnmodifiedDefaultBlock)(blocks[blocks.length - 1])) {
41660          __unstableMarkLastChangeAsPersistent();
41661        }
41662        //Unsynced patterns are nested in an array so we need to flatten them.
41663        const replacementBlocks = blocks?.length === 1 && Array.isArray(blocks[0]) ? blocks[0] : blocks;
41664        replaceBlocks([ownProps.clientId], replacementBlocks, indexToSelect, initialPosition);
41665      },
41666      onRemove() {
41667        removeBlock(ownProps.clientId);
41668      },
41669      toggleSelection(selectionEnabled) {
41670        toggleSelection(selectionEnabled);
41671      }
41672    };
41673  });
41674  
41675  // This component is used by the BlockListBlockProvider component below. It will
41676  // add the props necessary for the `editor.BlockListBlock` filters.
41677  BlockListBlock = (0,external_wp_compose_namespaceObject.compose)(applyWithDispatch, (0,external_wp_components_namespaceObject.withFilters)('editor.BlockListBlock'))(BlockListBlock);
41678  
41679  // This component provides all the information we need through a single store
41680  // subscription (useSelect mapping). Only the necessary props are passed down
41681  // to the BlockListBlock component, which is a filtered component, so these
41682  // props are public API. To avoid adding to the public API, we use a private
41683  // context to pass the rest of the information to the filtered BlockListBlock
41684  // component, and useBlockProps.
41685  function BlockListBlockProvider(props) {
41686    const {
41687      clientId,
41688      rootClientId
41689    } = props;
41690    const selectedProps = (0,external_wp_data_namespaceObject.useSelect)(select => {
41691      const {
41692        isBlockSelected,
41693        getBlockMode,
41694        isSelectionEnabled,
41695        getTemplateLock,
41696        isSectionBlock: _isSectionBlock,
41697        getBlockWithoutAttributes,
41698        getBlockAttributes,
41699        canRemoveBlock,
41700        canMoveBlock,
41701        getSettings,
41702        getTemporarilyEditingAsBlocks,
41703        getBlockEditingMode,
41704        getBlockName,
41705        isFirstMultiSelectedBlock,
41706        getMultiSelectedBlockClientIds,
41707        hasSelectedInnerBlock,
41708        getBlocksByName,
41709        getBlockIndex,
41710        isBlockMultiSelected,
41711        isBlockSubtreeDisabled,
41712        isBlockHighlighted,
41713        __unstableIsFullySelected,
41714        __unstableSelectionHasUnmergeableBlock,
41715        isBlockBeingDragged,
41716        isDragging,
41717        __unstableHasActiveBlockOverlayActive,
41718        getSelectedBlocksInitialCaretPosition
41719      } = unlock(select(store));
41720      const blockWithoutAttributes = getBlockWithoutAttributes(clientId);
41721  
41722      // This is a temporary fix.
41723      // This function should never be called when a block is not
41724      // present in the state. It happens now because the order in
41725      // withSelect rendering is not correct.
41726      if (!blockWithoutAttributes) {
41727        return;
41728      }
41729      const {
41730        hasBlockSupport: _hasBlockSupport,
41731        getActiveBlockVariation
41732      } = select(external_wp_blocks_namespaceObject.store);
41733      const attributes = getBlockAttributes(clientId);
41734      const {
41735        name: blockName,
41736        isValid
41737      } = blockWithoutAttributes;
41738      const blockType = (0,external_wp_blocks_namespaceObject.getBlockType)(blockName);
41739      const {
41740        supportsLayout,
41741        isPreviewMode
41742      } = getSettings();
41743      const hasLightBlockWrapper = blockType?.apiVersion > 1;
41744      const previewContext = {
41745        isPreviewMode,
41746        blockWithoutAttributes,
41747        name: blockName,
41748        attributes,
41749        isValid,
41750        themeSupportsLayout: supportsLayout,
41751        index: getBlockIndex(clientId),
41752        isReusable: (0,external_wp_blocks_namespaceObject.isReusableBlock)(blockType),
41753        className: hasLightBlockWrapper ? attributes.className : undefined,
41754        defaultClassName: hasLightBlockWrapper ? (0,external_wp_blocks_namespaceObject.getBlockDefaultClassName)(blockName) : undefined,
41755        blockTitle: blockType?.title
41756      };
41757  
41758      // When in preview mode, we can avoid a lot of selection and
41759      // editing related selectors.
41760      if (isPreviewMode) {
41761        return previewContext;
41762      }
41763      const _isSelected = isBlockSelected(clientId);
41764      const canRemove = canRemoveBlock(clientId);
41765      const canMove = canMoveBlock(clientId);
41766      const match = getActiveBlockVariation(blockName, attributes);
41767      const isMultiSelected = isBlockMultiSelected(clientId);
41768      const checkDeep = true;
41769      const isAncestorOfSelectedBlock = hasSelectedInnerBlock(clientId, checkDeep);
41770      const blockEditingMode = getBlockEditingMode(clientId);
41771      const multiple = (0,external_wp_blocks_namespaceObject.hasBlockSupport)(blockName, 'multiple', true);
41772  
41773      // For block types with `multiple` support, there is no "original
41774      // block" to be found in the content, as the block itself is valid.
41775      const blocksWithSameName = multiple ? [] : getBlocksByName(blockName);
41776      const isInvalid = blocksWithSameName.length && blocksWithSameName[0] !== clientId;
41777      return {
41778        ...previewContext,
41779        mode: getBlockMode(clientId),
41780        isSelectionEnabled: isSelectionEnabled(),
41781        isLocked: !!getTemplateLock(rootClientId),
41782        isSectionBlock: _isSectionBlock(clientId),
41783        canRemove,
41784        canMove,
41785        isSelected: _isSelected,
41786        isTemporarilyEditingAsBlocks: getTemporarilyEditingAsBlocks() === clientId,
41787        blockEditingMode,
41788        mayDisplayControls: _isSelected || isFirstMultiSelectedBlock(clientId) && getMultiSelectedBlockClientIds().every(id => getBlockName(id) === blockName),
41789        mayDisplayParentControls: _hasBlockSupport(getBlockName(clientId), '__experimentalExposeControlsToChildren', false) && hasSelectedInnerBlock(clientId),
41790        blockApiVersion: blockType?.apiVersion || 1,
41791        blockTitle: match?.title || blockType?.title,
41792        isSubtreeDisabled: blockEditingMode === 'disabled' && isBlockSubtreeDisabled(clientId),
41793        hasOverlay: __unstableHasActiveBlockOverlayActive(clientId) && !isDragging(),
41794        initialPosition: _isSelected ? getSelectedBlocksInitialCaretPosition() : undefined,
41795        isHighlighted: isBlockHighlighted(clientId),
41796        isMultiSelected,
41797        isPartiallySelected: isMultiSelected && !__unstableIsFullySelected() && !__unstableSelectionHasUnmergeableBlock(),
41798        isDragging: isBlockBeingDragged(clientId),
41799        hasChildSelected: isAncestorOfSelectedBlock,
41800        isEditingDisabled: blockEditingMode === 'disabled',
41801        hasEditableOutline: blockEditingMode !== 'disabled' && getBlockEditingMode(rootClientId) === 'disabled',
41802        originalBlockClientId: isInvalid ? blocksWithSameName[0] : false
41803      };
41804    }, [clientId, rootClientId]);
41805    const {
41806      isPreviewMode,
41807      // Fill values that end up as a public API and may not be defined in
41808      // preview mode.
41809      mode = 'visual',
41810      isSelectionEnabled = false,
41811      isLocked = false,
41812      canRemove = false,
41813      canMove = false,
41814      blockWithoutAttributes,
41815      name,
41816      attributes,
41817      isValid,
41818      isSelected = false,
41819      themeSupportsLayout,
41820      isTemporarilyEditingAsBlocks,
41821      blockEditingMode,
41822      mayDisplayControls,
41823      mayDisplayParentControls,
41824      index,
41825      blockApiVersion,
41826      blockTitle,
41827      isSubtreeDisabled,
41828      hasOverlay,
41829      initialPosition,
41830      isHighlighted,
41831      isMultiSelected,
41832      isPartiallySelected,
41833      isReusable,
41834      isDragging,
41835      hasChildSelected,
41836      isSectionBlock,
41837      isEditingDisabled,
41838      hasEditableOutline,
41839      className,
41840      defaultClassName,
41841      originalBlockClientId
41842    } = selectedProps;
41843  
41844    // Users of the editor.BlockListBlock filter used to be able to
41845    // access the block prop.
41846    // Ideally these blocks would rely on the clientId prop only.
41847    // This is kept for backward compatibility reasons.
41848    const block = (0,external_wp_element_namespaceObject.useMemo)(() => ({
41849      ...blockWithoutAttributes,
41850      attributes
41851    }), [blockWithoutAttributes, attributes]);
41852  
41853    // Block is sometimes not mounted at the right time, causing it be
41854    // undefined see issue for more info
41855    // https://github.com/WordPress/gutenberg/issues/17013
41856    if (!selectedProps) {
41857      return null;
41858    }
41859    const privateContext = {
41860      isPreviewMode,
41861      clientId,
41862      className,
41863      index,
41864      mode,
41865      name,
41866      blockApiVersion,
41867      blockTitle,
41868      isSelected,
41869      isSubtreeDisabled,
41870      hasOverlay,
41871      initialPosition,
41872      blockEditingMode,
41873      isHighlighted,
41874      isMultiSelected,
41875      isPartiallySelected,
41876      isReusable,
41877      isDragging,
41878      hasChildSelected,
41879      isSectionBlock,
41880      isEditingDisabled,
41881      hasEditableOutline,
41882      isTemporarilyEditingAsBlocks,
41883      defaultClassName,
41884      mayDisplayControls,
41885      mayDisplayParentControls,
41886      originalBlockClientId,
41887      themeSupportsLayout,
41888      canMove
41889    };
41890  
41891    // Here we separate between the props passed to BlockListBlock and any other
41892    // information we selected for internal use. BlockListBlock is a filtered
41893    // component and thus ALL the props are PUBLIC API.
41894  
41895    // Note that the context value doesn't have to be memoized in this case
41896    // because when it changes, this component will be re-rendered anyway, and
41897    // none of the consumers (BlockListBlock and useBlockProps) are memoized or
41898    // "pure". This is different from the public BlockEditContext, where
41899    // consumers might be memoized or "pure".
41900    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PrivateBlockContext.Provider, {
41901      value: privateContext,
41902      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockListBlock, {
41903        ...props,
41904        mode,
41905        isSelectionEnabled,
41906        isLocked,
41907        canRemove,
41908        canMove,
41909        // Users of the editor.BlockListBlock filter used to be able
41910        // to access the block prop. Ideally these blocks would rely
41911        // on the clientId prop only. This is kept for backward
41912        // compatibility reasons.
41913        block,
41914        name,
41915        attributes,
41916        isValid,
41917        isSelected
41918      })
41919    });
41920  }
41921  /* harmony default export */ const block = ((0,external_wp_element_namespaceObject.memo)(BlockListBlockProvider));
41922  
41923  ;// external ["wp","htmlEntities"]
41924  const external_wp_htmlEntities_namespaceObject = window["wp"]["htmlEntities"];
41925  ;// ./node_modules/@wordpress/block-editor/build-module/components/default-block-appender/index.js
41926  /**
41927   * External dependencies
41928   */
41929  
41930  
41931  /**
41932   * WordPress dependencies
41933   */
41934  
41935  
41936  
41937  
41938  
41939  /**
41940   * Internal dependencies
41941   */
41942  
41943  
41944  
41945  /**
41946   * Zero width non-breaking space, used as padding for the paragraph when it is
41947   * empty.
41948   */
41949  
41950  const ZWNBSP = '\ufeff';
41951  function DefaultBlockAppender({
41952    rootClientId
41953  }) {
41954    const {
41955      showPrompt,
41956      isLocked,
41957      placeholder,
41958      isManualGrid
41959    } = (0,external_wp_data_namespaceObject.useSelect)(select => {
41960      const {
41961        getBlockCount,
41962        getSettings,
41963        getTemplateLock,
41964        getBlockAttributes
41965      } = select(store);
41966      const isEmpty = !getBlockCount(rootClientId);
41967      const {
41968        bodyPlaceholder
41969      } = getSettings();
41970      return {
41971        showPrompt: isEmpty,
41972        isLocked: !!getTemplateLock(rootClientId),
41973        placeholder: bodyPlaceholder,
41974        isManualGrid: getBlockAttributes(rootClientId)?.layout?.isManualPlacement
41975      };
41976    }, [rootClientId]);
41977    const {
41978      insertDefaultBlock,
41979      startTyping
41980    } = (0,external_wp_data_namespaceObject.useDispatch)(store);
41981    if (isLocked || isManualGrid) {
41982      return null;
41983    }
41984    const value = (0,external_wp_htmlEntities_namespaceObject.decodeEntities)(placeholder) || (0,external_wp_i18n_namespaceObject.__)('Type / to choose a block');
41985    const onAppend = () => {
41986      insertDefaultBlock(undefined, rootClientId);
41987      startTyping();
41988    };
41989    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
41990      "data-root-client-id": rootClientId || '',
41991      className: dist_clsx('block-editor-default-block-appender', {
41992        'has-visible-prompt': showPrompt
41993      }),
41994      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("p", {
41995        tabIndex: "0"
41996        // We want this element to be styled as a paragraph by themes.
41997        // eslint-disable-next-line jsx-a11y/no-noninteractive-element-to-interactive-role
41998        ,
41999        role: "button",
42000        "aria-label": (0,external_wp_i18n_namespaceObject.__)('Add default block')
42001        // A wrapping container for this one already has the wp-block className.
42002        ,
42003        className: "block-editor-default-block-appender__content",
42004        onKeyDown: event => {
42005          if (external_wp_keycodes_namespaceObject.ENTER === event.keyCode || external_wp_keycodes_namespaceObject.SPACE === event.keyCode) {
42006            onAppend();
42007          }
42008        },
42009        onClick: () => onAppend(),
42010        onFocus: () => {
42011          if (showPrompt) {
42012            onAppend();
42013          }
42014        },
42015        children: showPrompt ? value : ZWNBSP
42016      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inserter, {
42017        rootClientId: rootClientId,
42018        position: "bottom right",
42019        isAppender: true,
42020        __experimentalIsQuick: true
42021      })]
42022    });
42023  }
42024  
42025  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-list-appender/index.js
42026  /**
42027   * External dependencies
42028   */
42029  
42030  
42031  /**
42032   * WordPress dependencies
42033   */
42034  
42035  
42036  
42037  /**
42038   * Internal dependencies
42039   */
42040  
42041  
42042  
42043  
42044  function DefaultAppender({
42045    rootClientId
42046  }) {
42047    const canInsertDefaultBlock = (0,external_wp_data_namespaceObject.useSelect)(select => select(store).canInsertBlockType((0,external_wp_blocks_namespaceObject.getDefaultBlockName)(), rootClientId));
42048    if (canInsertDefaultBlock) {
42049      // Render the default block appender if the context supports use
42050      // of the default appender.
42051      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(DefaultBlockAppender, {
42052        rootClientId: rootClientId
42053      });
42054    }
42055  
42056    // Fallback in case the default block can't be inserted.
42057    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(button_block_appender, {
42058      rootClientId: rootClientId,
42059      className: "block-list-appender__toggle"
42060    });
42061  }
42062  function BlockListAppender({
42063    rootClientId,
42064    CustomAppender,
42065    className,
42066    tagName: TagName = 'div'
42067  }) {
42068    const isDragOver = (0,external_wp_data_namespaceObject.useSelect)(select => {
42069      const {
42070        getBlockInsertionPoint,
42071        isBlockInsertionPointVisible,
42072        getBlockCount
42073      } = select(store);
42074      const insertionPoint = getBlockInsertionPoint();
42075      // Ideally we should also check for `isDragging` but currently it
42076      // requires a lot more setup. We can revisit this once we refactor
42077      // the DnD utility hooks.
42078      return isBlockInsertionPointVisible() && rootClientId === insertionPoint?.rootClientId && getBlockCount(rootClientId) === 0;
42079    }, [rootClientId]);
42080    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(TagName
42081    // A `tabIndex` is used on the wrapping `div` element in order to
42082    // force a focus event to occur when an appender `button` element
42083    // is clicked. In some browsers (Firefox, Safari), button clicks do
42084    // not emit a focus event, which could cause this event to propagate
42085    // unexpectedly. The `tabIndex` ensures that the interaction is
42086    // captured as a focus, without also adding an extra tab stop.
42087    //
42088    // See: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/button#Clicking_and_focus
42089    , {
42090      tabIndex: -1,
42091      className: dist_clsx('block-list-appender wp-block', className, {
42092        'is-drag-over': isDragOver
42093      })
42094      // Needed in case the whole editor is content editable (for multi
42095      // selection). It fixes an edge case where ArrowDown and ArrowRight
42096      // should collapse the selection to the end of that selection and
42097      // not into the appender.
42098      ,
42099      contentEditable: false
42100      // The appender exists to let you add the first Paragraph before
42101      // any is inserted. To that end, this appender should visually be
42102      // presented as a block. That means theme CSS should style it as if
42103      // it were an empty paragraph block. That means a `wp-block` class to
42104      // ensure the width is correct, and a [data-block] attribute to ensure
42105      // the correct margin is applied, especially for classic themes which
42106      // have commonly targeted that attribute for margins.
42107      ,
42108      "data-block": true,
42109      children: CustomAppender ? /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(CustomAppender, {}) : /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(DefaultAppender, {
42110        rootClientId: rootClientId
42111      })
42112    });
42113  }
42114  
42115  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-popover/inbetween.js
42116  /**
42117   * External dependencies
42118   */
42119  
42120  
42121  /**
42122   * WordPress dependencies
42123   */
42124  
42125  
42126  
42127  
42128  
42129  /**
42130   * Internal dependencies
42131   */
42132  
42133  
42134  
42135  
42136  const inbetween_MAX_POPOVER_RECOMPUTE_COUNTER = Number.MAX_SAFE_INTEGER;
42137  const InsertionPointOpenRef = (0,external_wp_element_namespaceObject.createContext)();
42138  function BlockPopoverInbetween({
42139    previousClientId,
42140    nextClientId,
42141    children,
42142    __unstablePopoverSlot,
42143    __unstableContentRef,
42144    operation = 'insert',
42145    nearestSide = 'right',
42146    ...props
42147  }) {
42148    // This is a temporary hack to get the inbetween inserter to recompute properly.
42149    const [popoverRecomputeCounter, forcePopoverRecompute] = (0,external_wp_element_namespaceObject.useReducer)(
42150    // Module is there to make sure that the counter doesn't overflow.
42151    s => (s + 1) % inbetween_MAX_POPOVER_RECOMPUTE_COUNTER, 0);
42152    const {
42153      orientation,
42154      rootClientId,
42155      isVisible
42156    } = (0,external_wp_data_namespaceObject.useSelect)(select => {
42157      const {
42158        getBlockListSettings,
42159        getBlockRootClientId,
42160        isBlockVisible
42161      } = select(store);
42162      const _rootClientId = getBlockRootClientId(previousClientId !== null && previousClientId !== void 0 ? previousClientId : nextClientId);
42163      return {
42164        orientation: getBlockListSettings(_rootClientId)?.orientation || 'vertical',
42165        rootClientId: _rootClientId,
42166        isVisible: isBlockVisible(previousClientId) && isBlockVisible(nextClientId)
42167      };
42168    }, [previousClientId, nextClientId]);
42169    const previousElement = useBlockElement(previousClientId);
42170    const nextElement = useBlockElement(nextClientId);
42171    const isVertical = orientation === 'vertical';
42172    const popoverAnchor = (0,external_wp_element_namespaceObject.useMemo)(() => {
42173      if (
42174      // popoverRecomputeCounter is by definition always equal or greater than 0.
42175      // This check is only there to satisfy the correctness of the
42176      // exhaustive-deps rule for the `useMemo` hook.
42177      popoverRecomputeCounter < 0 || !previousElement && !nextElement || !isVisible) {
42178        return undefined;
42179      }
42180      const contextElement = operation === 'group' ? nextElement || previousElement : previousElement || nextElement;
42181      return {
42182        contextElement,
42183        getBoundingClientRect() {
42184          const previousRect = previousElement ? previousElement.getBoundingClientRect() : null;
42185          const nextRect = nextElement ? nextElement.getBoundingClientRect() : null;
42186          let left = 0;
42187          let top = 0;
42188          let width = 0;
42189          let height = 0;
42190          if (operation === 'group') {
42191            const targetRect = nextRect || previousRect;
42192            top = targetRect.top;
42193            // No spacing is likely around blocks in this operation.
42194            // So width of the inserter containing rect is set to 0.
42195            width = 0;
42196            height = targetRect.bottom - targetRect.top;
42197            // Popover calculates its distance from mid-block so some
42198            // adjustments are needed to make it appear in the right place.
42199            left = nearestSide === 'left' ? targetRect.left - 2 : targetRect.right - 2;
42200          } else if (isVertical) {
42201            // vertical
42202            top = previousRect ? previousRect.bottom : nextRect.top;
42203            width = previousRect ? previousRect.width : nextRect.width;
42204            height = nextRect && previousRect ? nextRect.top - previousRect.bottom : 0;
42205            left = previousRect ? previousRect.left : nextRect.left;
42206          } else {
42207            top = previousRect ? previousRect.top : nextRect.top;
42208            height = previousRect ? previousRect.height : nextRect.height;
42209            if ((0,external_wp_i18n_namespaceObject.isRTL)()) {
42210              // non vertical, rtl
42211              left = nextRect ? nextRect.right : previousRect.left;
42212              width = previousRect && nextRect ? previousRect.left - nextRect.right : 0;
42213            } else {
42214              // non vertical, ltr
42215              left = previousRect ? previousRect.right : nextRect.left;
42216              width = previousRect && nextRect ? nextRect.left - previousRect.right : 0;
42217            }
42218  
42219            // Avoid a negative width which happens when the next rect
42220            // is on the next line.
42221            width = Math.max(width, 0);
42222          }
42223          return new window.DOMRect(left, top, width, height);
42224        }
42225      };
42226    }, [previousElement, nextElement, popoverRecomputeCounter, isVertical, isVisible, operation, nearestSide]);
42227    const popoverScrollRef = use_popover_scroll(__unstableContentRef);
42228  
42229    // This is only needed for a smooth transition when moving blocks.
42230    // When blocks are moved up/down, their position can be set by
42231    // updating the `transform` property manually (i.e. without using CSS
42232    // transitions or animations). The animation, which can also scroll the block
42233    // editor, can sometimes cause the position of the Popover to get out of sync.
42234    // A MutationObserver is therefore used to make sure that changes to the
42235    // selectedElement's attribute (i.e. `transform`) can be tracked and used to
42236    // trigger the Popover to rerender.
42237    (0,external_wp_element_namespaceObject.useLayoutEffect)(() => {
42238      if (!previousElement) {
42239        return;
42240      }
42241      const observer = new window.MutationObserver(forcePopoverRecompute);
42242      observer.observe(previousElement, {
42243        attributes: true
42244      });
42245      return () => {
42246        observer.disconnect();
42247      };
42248    }, [previousElement]);
42249    (0,external_wp_element_namespaceObject.useLayoutEffect)(() => {
42250      if (!nextElement) {
42251        return;
42252      }
42253      const observer = new window.MutationObserver(forcePopoverRecompute);
42254      observer.observe(nextElement, {
42255        attributes: true
42256      });
42257      return () => {
42258        observer.disconnect();
42259      };
42260    }, [nextElement]);
42261    (0,external_wp_element_namespaceObject.useLayoutEffect)(() => {
42262      if (!previousElement) {
42263        return;
42264      }
42265      previousElement.ownerDocument.defaultView.addEventListener('resize', forcePopoverRecompute);
42266      return () => {
42267        previousElement.ownerDocument.defaultView?.removeEventListener('resize', forcePopoverRecompute);
42268      };
42269    }, [previousElement]);
42270  
42271    // If there's either a previous or a next element, show the inbetween popover.
42272    // Note that drag and drop uses the inbetween popover to show the drop indicator
42273    // before the first block and after the last block.
42274    if (!previousElement && !nextElement || !isVisible) {
42275      return null;
42276    }
42277  
42278    /* eslint-disable jsx-a11y/no-static-element-interactions, jsx-a11y/click-events-have-key-events */
42279    // While ideally it would be enough to capture the
42280    // bubbling focus event from the Inserter, due to the
42281    // characteristics of click focusing of `button`s in
42282    // Firefox and Safari, it is not reliable.
42283    //
42284    // See: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/button#Clicking_and_focus
42285    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Popover, {
42286      ref: popoverScrollRef,
42287      animate: false,
42288      anchor: popoverAnchor,
42289      focusOnMount: false
42290      // Render in the old slot if needed for backward compatibility,
42291      // otherwise render in place (not in the default popover slot).
42292      ,
42293      __unstableSlotName: __unstablePopoverSlot,
42294      inline: !__unstablePopoverSlot
42295      // Forces a remount of the popover when its position changes
42296      // This makes sure the popover doesn't animate from its previous position.
42297      ,
42298      ...props,
42299      className: dist_clsx('block-editor-block-popover', 'block-editor-block-popover__inbetween', props.className),
42300      resize: false,
42301      flip: false,
42302      placement: "overlay",
42303      variant: "unstyled",
42304      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
42305        className: "block-editor-block-popover__inbetween-container",
42306        children: children
42307      })
42308    }, nextClientId + '--' + rootClientId);
42309    /* eslint-enable jsx-a11y/no-static-element-interactions, jsx-a11y/click-events-have-key-events */
42310  }
42311  /* harmony default export */ const inbetween = (BlockPopoverInbetween);
42312  
42313  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-popover/drop-zone.js
42314  /**
42315   * WordPress dependencies
42316   */
42317  
42318  
42319  
42320  
42321  /**
42322   * Internal dependencies
42323   */
42324  
42325  
42326  
42327  const animateVariants = {
42328    hide: {
42329      opacity: 0,
42330      scaleY: 0.75
42331    },
42332    show: {
42333      opacity: 1,
42334      scaleY: 1
42335    },
42336    exit: {
42337      opacity: 0,
42338      scaleY: 0.9
42339    }
42340  };
42341  function BlockDropZonePopover({
42342    __unstablePopoverSlot,
42343    __unstableContentRef
42344  }) {
42345    const {
42346      clientId
42347    } = (0,external_wp_data_namespaceObject.useSelect)(select => {
42348      const {
42349        getBlockOrder,
42350        getBlockInsertionPoint
42351      } = select(store);
42352      const insertionPoint = getBlockInsertionPoint();
42353      const order = getBlockOrder(insertionPoint.rootClientId);
42354      if (!order.length) {
42355        return {};
42356      }
42357      return {
42358        clientId: order[insertionPoint.index]
42359      };
42360    }, []);
42361    const reducedMotion = (0,external_wp_compose_namespaceObject.useReducedMotion)();
42362    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(cover, {
42363      clientId: clientId,
42364      __unstablePopoverSlot: __unstablePopoverSlot,
42365      __unstableContentRef: __unstableContentRef,
42366      className: "block-editor-block-popover__drop-zone",
42367      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__unstableMotion.div, {
42368        "data-testid": "block-popover-drop-zone",
42369        initial: reducedMotion ? animateVariants.show : animateVariants.hide,
42370        animate: animateVariants.show,
42371        exit: reducedMotion ? animateVariants.show : animateVariants.exit,
42372        className: "block-editor-block-popover__drop-zone-foreground"
42373      })
42374    });
42375  }
42376  /* harmony default export */ const drop_zone = (BlockDropZonePopover);
42377  
42378  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-tools/insertion-point.js
42379  /**
42380   * External dependencies
42381   */
42382  
42383  
42384  /**
42385   * WordPress dependencies
42386   */
42387  
42388  
42389  
42390  
42391  
42392  /**
42393   * Internal dependencies
42394   */
42395  
42396  
42397  
42398  
42399  
42400  
42401  const insertion_point_InsertionPointOpenRef = (0,external_wp_element_namespaceObject.createContext)();
42402  function InbetweenInsertionPointPopover({
42403    __unstablePopoverSlot,
42404    __unstableContentRef,
42405    operation = 'insert',
42406    nearestSide = 'right'
42407  }) {
42408    const {
42409      selectBlock,
42410      hideInsertionPoint
42411    } = (0,external_wp_data_namespaceObject.useDispatch)(store);
42412    const openRef = (0,external_wp_element_namespaceObject.useContext)(insertion_point_InsertionPointOpenRef);
42413    const ref = (0,external_wp_element_namespaceObject.useRef)();
42414    const {
42415      orientation,
42416      previousClientId,
42417      nextClientId,
42418      rootClientId,
42419      isInserterShown,
42420      isDistractionFree,
42421      isZoomOutMode
42422    } = (0,external_wp_data_namespaceObject.useSelect)(select => {
42423      const {
42424        getBlockOrder,
42425        getBlockListSettings,
42426        getBlockInsertionPoint,
42427        isBlockBeingDragged,
42428        getPreviousBlockClientId,
42429        getNextBlockClientId,
42430        getSettings,
42431        isZoomOut
42432      } = unlock(select(store));
42433      const insertionPoint = getBlockInsertionPoint();
42434      const order = getBlockOrder(insertionPoint.rootClientId);
42435      if (!order.length) {
42436        return {};
42437      }
42438      let _previousClientId = order[insertionPoint.index - 1];
42439      let _nextClientId = order[insertionPoint.index];
42440      while (isBlockBeingDragged(_previousClientId)) {
42441        _previousClientId = getPreviousBlockClientId(_previousClientId);
42442      }
42443      while (isBlockBeingDragged(_nextClientId)) {
42444        _nextClientId = getNextBlockClientId(_nextClientId);
42445      }
42446      const settings = getSettings();
42447      return {
42448        previousClientId: _previousClientId,
42449        nextClientId: _nextClientId,
42450        orientation: getBlockListSettings(insertionPoint.rootClientId)?.orientation || 'vertical',
42451        rootClientId: insertionPoint.rootClientId,
42452        isDistractionFree: settings.isDistractionFree,
42453        isInserterShown: insertionPoint?.__unstableWithInserter,
42454        isZoomOutMode: isZoomOut()
42455      };
42456    }, []);
42457    const {
42458      getBlockEditingMode
42459    } = (0,external_wp_data_namespaceObject.useSelect)(store);
42460    const disableMotion = (0,external_wp_compose_namespaceObject.useReducedMotion)();
42461    function onClick(event) {
42462      if (event.target === ref.current && nextClientId && getBlockEditingMode(nextClientId) !== 'disabled') {
42463        selectBlock(nextClientId, -1);
42464      }
42465    }
42466    function maybeHideInserterPoint(event) {
42467      // Only hide the inserter if it's triggered on the wrapper,
42468      // and the inserter is not open.
42469      if (event.target === ref.current && !openRef.current) {
42470        hideInsertionPoint();
42471      }
42472    }
42473    function onFocus(event) {
42474      // Only handle click on the wrapper specifically, and not an event
42475      // bubbled from the inserter itself.
42476      if (event.target !== ref.current) {
42477        openRef.current = true;
42478      }
42479    }
42480    const lineVariants = {
42481      // Initial position starts from the center and invisible.
42482      start: {
42483        opacity: 0,
42484        scale: 0
42485      },
42486      // The line expands to fill the container. If the inserter is visible it
42487      // is delayed so it appears orchestrated.
42488      rest: {
42489        opacity: 1,
42490        scale: 1,
42491        transition: {
42492          delay: isInserterShown ? 0.5 : 0,
42493          type: 'tween'
42494        }
42495      },
42496      hover: {
42497        opacity: 1,
42498        scale: 1,
42499        transition: {
42500          delay: 0.5,
42501          type: 'tween'
42502        }
42503      }
42504    };
42505    const inserterVariants = {
42506      start: {
42507        scale: disableMotion ? 1 : 0
42508      },
42509      rest: {
42510        scale: 1,
42511        transition: {
42512          delay: 0.4,
42513          type: 'tween'
42514        }
42515      }
42516    };
42517    if (isDistractionFree) {
42518      return null;
42519    }
42520  
42521    // Zoom out mode should only show the insertion point for the insert operation.
42522    // Other operations such as "group" are when the editor tries to create a row
42523    // block by grouping the block being dragged with the block it's being dropped
42524    // onto.
42525    if (isZoomOutMode && operation !== 'insert') {
42526      return null;
42527    }
42528    const orientationClassname = orientation === 'horizontal' || operation === 'group' ? 'is-horizontal' : 'is-vertical';
42529    const className = dist_clsx('block-editor-block-list__insertion-point', orientationClassname);
42530    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inbetween, {
42531      previousClientId: previousClientId,
42532      nextClientId: nextClientId,
42533      __unstablePopoverSlot: __unstablePopoverSlot,
42534      __unstableContentRef: __unstableContentRef,
42535      operation: operation,
42536      nearestSide: nearestSide,
42537      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__unstableMotion.div, {
42538        layout: !disableMotion,
42539        initial: disableMotion ? 'rest' : 'start',
42540        animate: "rest",
42541        whileHover: "hover",
42542        whileTap: "pressed",
42543        exit: "start",
42544        ref: ref,
42545        tabIndex: -1,
42546        onClick: onClick,
42547        onFocus: onFocus,
42548        className: dist_clsx(className, {
42549          'is-with-inserter': isInserterShown
42550        }),
42551        onHoverEnd: maybeHideInserterPoint,
42552        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__unstableMotion.div, {
42553          variants: lineVariants,
42554          className: "block-editor-block-list__insertion-point-indicator",
42555          "data-testid": "block-list-insertion-point-indicator"
42556        }), isInserterShown && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__unstableMotion.div, {
42557          variants: inserterVariants,
42558          className: dist_clsx('block-editor-block-list__insertion-point-inserter'),
42559          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inserter, {
42560            position: "bottom center",
42561            clientId: nextClientId,
42562            rootClientId: rootClientId,
42563            __experimentalIsQuick: true,
42564            onToggle: isOpen => {
42565              openRef.current = isOpen;
42566            },
42567            onSelectOrClose: () => {
42568              openRef.current = false;
42569            }
42570          })
42571        })]
42572      })
42573    });
42574  }
42575  function InsertionPoint(props) {
42576    const {
42577      insertionPoint,
42578      isVisible,
42579      isBlockListEmpty
42580    } = (0,external_wp_data_namespaceObject.useSelect)(select => {
42581      const {
42582        getBlockInsertionPoint,
42583        isBlockInsertionPointVisible,
42584        getBlockCount
42585      } = select(store);
42586      const blockInsertionPoint = getBlockInsertionPoint();
42587      return {
42588        insertionPoint: blockInsertionPoint,
42589        isVisible: isBlockInsertionPointVisible(),
42590        isBlockListEmpty: getBlockCount(blockInsertionPoint?.rootClientId) === 0
42591      };
42592    }, []);
42593    if (!isVisible ||
42594    // Don't render the insertion point if the block list is empty.
42595    // The insertion point will be represented by the appender instead.
42596    isBlockListEmpty) {
42597      return null;
42598    }
42599  
42600    /**
42601     * Render a popover that overlays the block when the desired operation is to replace it.
42602     * Otherwise, render a popover in between blocks for the indication of inserting between them.
42603     */
42604    return insertionPoint.operation === 'replace' ? /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(drop_zone
42605    // Force remount to trigger the animation.
42606    , {
42607      ...props
42608    }, `$insertionPoint.rootClientId}-$insertionPoint.index}`) : /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(InbetweenInsertionPointPopover, {
42609      operation: insertionPoint.operation,
42610      nearestSide: insertionPoint.nearestSide,
42611      ...props
42612    });
42613  }
42614  
42615  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-list/use-in-between-inserter.js
42616  /**
42617   * WordPress dependencies
42618   */
42619  
42620  
42621  
42622  
42623  
42624  /**
42625   * Internal dependencies
42626   */
42627  
42628  
42629  
42630  function useInBetweenInserter() {
42631    const openRef = (0,external_wp_element_namespaceObject.useContext)(insertion_point_InsertionPointOpenRef);
42632    const isInBetweenInserterDisabled = (0,external_wp_data_namespaceObject.useSelect)(select => select(store).getSettings().isDistractionFree || unlock(select(store)).isZoomOut(), []);
42633    const {
42634      getBlockListSettings,
42635      getBlockIndex,
42636      isMultiSelecting,
42637      getSelectedBlockClientIds,
42638      getSettings,
42639      getTemplateLock,
42640      __unstableIsWithinBlockOverlay,
42641      getBlockEditingMode,
42642      getBlockName,
42643      getBlockAttributes,
42644      getParentSectionBlock
42645    } = unlock((0,external_wp_data_namespaceObject.useSelect)(store));
42646    const {
42647      showInsertionPoint,
42648      hideInsertionPoint
42649    } = (0,external_wp_data_namespaceObject.useDispatch)(store);
42650    return (0,external_wp_compose_namespaceObject.useRefEffect)(node => {
42651      if (isInBetweenInserterDisabled) {
42652        return;
42653      }
42654      function onMouseMove(event) {
42655        // openRef is the reference to the insertion point between blocks.
42656        // If the reference is not set or the insertion point is already open, return.
42657        if (openRef === undefined || openRef.current) {
42658          return;
42659        }
42660  
42661        // Ignore text nodes sometimes detected in FireFox.
42662        if (event.target.nodeType === event.target.TEXT_NODE) {
42663          return;
42664        }
42665        if (isMultiSelecting()) {
42666          return;
42667        }
42668        if (!event.target.classList.contains('block-editor-block-list__layout')) {
42669          hideInsertionPoint();
42670          return;
42671        }
42672        let rootClientId;
42673        if (!event.target.classList.contains('is-root-container')) {
42674          const blockElement = !!event.target.getAttribute('data-block') ? event.target : event.target.closest('[data-block]');
42675          rootClientId = blockElement.getAttribute('data-block');
42676        }
42677        if (getTemplateLock(rootClientId) || getBlockEditingMode(rootClientId) === 'disabled' || getBlockName(rootClientId) === 'core/block' || rootClientId && getBlockAttributes(rootClientId).layout?.isManualPlacement) {
42678          return;
42679        }
42680        const blockListSettings = getBlockListSettings(rootClientId);
42681        const orientation = blockListSettings?.orientation || 'vertical';
42682        const captureToolbars = !!blockListSettings?.__experimentalCaptureToolbars;
42683        const offsetTop = event.clientY;
42684        const offsetLeft = event.clientX;
42685        const children = Array.from(event.target.children);
42686        let element = children.find(blockEl => {
42687          const blockElRect = blockEl.getBoundingClientRect();
42688          return blockEl.classList.contains('wp-block') && orientation === 'vertical' && blockElRect.top > offsetTop || blockEl.classList.contains('wp-block') && orientation === 'horizontal' && ((0,external_wp_i18n_namespaceObject.isRTL)() ? blockElRect.right < offsetLeft : blockElRect.left > offsetLeft);
42689        });
42690        if (!element) {
42691          hideInsertionPoint();
42692          return;
42693        }
42694  
42695        // The block may be in an alignment wrapper, so check the first direct
42696        // child if the element has no ID.
42697        if (!element.id) {
42698          element = element.firstElementChild;
42699          if (!element) {
42700            hideInsertionPoint();
42701            return;
42702          }
42703        }
42704  
42705        // Don't show the insertion point if a parent block has an "overlay"
42706        // See https://github.com/WordPress/gutenberg/pull/34012#pullrequestreview-727762337
42707        const clientId = element.id.slice('block-'.length);
42708        if (!clientId || __unstableIsWithinBlockOverlay(clientId) || !!getParentSectionBlock(clientId)) {
42709          return;
42710        }
42711  
42712        // Don't show the inserter if the following conditions are met,
42713        // as it conflicts with the block toolbar:
42714        // 1. when hovering above or inside selected block(s)
42715        // 2. when the orientation is vertical
42716        // 3. when the __experimentalCaptureToolbars is not enabled
42717        // 4. when the Top Toolbar is not disabled
42718        if (getSelectedBlockClientIds().includes(clientId) && orientation === 'vertical' && !captureToolbars && !getSettings().hasFixedToolbar) {
42719          return;
42720        }
42721        const elementRect = element.getBoundingClientRect();
42722        if (orientation === 'horizontal' && (event.clientY > elementRect.bottom || event.clientY < elementRect.top) || orientation === 'vertical' && (event.clientX > elementRect.right || event.clientX < elementRect.left)) {
42723          hideInsertionPoint();
42724          return;
42725        }
42726        const index = getBlockIndex(clientId);
42727  
42728        // Don't show the in-between inserter before the first block in
42729        // the list (preserves the original behaviour).
42730        if (index === 0) {
42731          hideInsertionPoint();
42732          return;
42733        }
42734        showInsertionPoint(rootClientId, index, {
42735          __unstableWithInserter: true
42736        });
42737      }
42738      node.addEventListener('mousemove', onMouseMove);
42739      return () => {
42740        node.removeEventListener('mousemove', onMouseMove);
42741      };
42742    }, [openRef, getBlockListSettings, getBlockIndex, isMultiSelecting, showInsertionPoint, hideInsertionPoint, getSelectedBlockClientIds, isInBetweenInserterDisabled]);
42743  }
42744  
42745  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-selection-clearer/index.js
42746  /**
42747   * WordPress dependencies
42748   */
42749  
42750  
42751  
42752  /**
42753   * Internal dependencies
42754   */
42755  
42756  
42757  /**
42758   * Pass the returned ref callback to an element that should clear block
42759   * selection. Selection will only be cleared if the element is clicked directly,
42760   * not if a child element is clicked.
42761   *
42762   * @return {import('react').RefCallback} Ref callback.
42763   */
42764  
42765  function useBlockSelectionClearer() {
42766    const {
42767      getSettings,
42768      hasSelectedBlock,
42769      hasMultiSelection
42770    } = (0,external_wp_data_namespaceObject.useSelect)(store);
42771    const {
42772      clearSelectedBlock
42773    } = (0,external_wp_data_namespaceObject.useDispatch)(store);
42774    const {
42775      clearBlockSelection: isEnabled
42776    } = getSettings();
42777    return (0,external_wp_compose_namespaceObject.useRefEffect)(node => {
42778      if (!isEnabled) {
42779        return;
42780      }
42781      function onMouseDown(event) {
42782        if (!hasSelectedBlock() && !hasMultiSelection()) {
42783          return;
42784        }
42785  
42786        // Only handle clicks on the element, not the children.
42787        if (event.target !== node) {
42788          return;
42789        }
42790        clearSelectedBlock();
42791      }
42792      node.addEventListener('mousedown', onMouseDown);
42793      return () => {
42794        node.removeEventListener('mousedown', onMouseDown);
42795      };
42796    }, [hasSelectedBlock, hasMultiSelection, clearSelectedBlock, isEnabled]);
42797  }
42798  function BlockSelectionClearer(props) {
42799    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
42800      ref: useBlockSelectionClearer(),
42801      ...props
42802    });
42803  }
42804  
42805  ;// ./node_modules/@wordpress/block-editor/build-module/components/inner-blocks/button-block-appender.js
42806  /**
42807   * External dependencies
42808   */
42809  
42810  
42811  /**
42812   * Internal dependencies
42813   */
42814  
42815  
42816  
42817  function ButtonBlockAppender({
42818    showSeparator,
42819    isFloating,
42820    onAddBlock,
42821    isToggle
42822  }) {
42823    const {
42824      clientId
42825    } = useBlockEditContext();
42826    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(button_block_appender, {
42827      className: dist_clsx({
42828        'block-list-appender__toggle': isToggle
42829      }),
42830      rootClientId: clientId,
42831      showSeparator: showSeparator,
42832      isFloating: isFloating,
42833      onAddBlock: onAddBlock
42834    });
42835  }
42836  
42837  ;// ./node_modules/@wordpress/block-editor/build-module/components/inner-blocks/default-block-appender.js
42838  /**
42839   * Internal dependencies
42840   */
42841  
42842  
42843  
42844  function default_block_appender_DefaultBlockAppender() {
42845    const {
42846      clientId
42847    } = useBlockEditContext();
42848    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(DefaultBlockAppender, {
42849      rootClientId: clientId
42850    });
42851  }
42852  
42853  ;// ./node_modules/@wordpress/block-editor/build-module/components/inner-blocks/use-nested-settings-update.js
42854  /**
42855   * WordPress dependencies
42856   */
42857  
42858  
42859  
42860  
42861  
42862  /**
42863   * Internal dependencies
42864   */
42865  
42866  
42867  
42868  /** @typedef {import('../../selectors').WPDirectInsertBlock } WPDirectInsertBlock */
42869  
42870  const pendingSettingsUpdates = new WeakMap();
42871  
42872  // Creates a memoizing caching function that remembers the last value and keeps returning it
42873  // as long as the new values are shallowly equal. Helps keep dependencies stable.
42874  function createShallowMemo() {
42875    let value;
42876    return newValue => {
42877      if (value === undefined || !external_wp_isShallowEqual_default()(value, newValue)) {
42878        value = newValue;
42879      }
42880      return value;
42881    };
42882  }
42883  function useShallowMemo(value) {
42884    const [memo] = (0,external_wp_element_namespaceObject.useState)(createShallowMemo);
42885    return memo(value);
42886  }
42887  
42888  /**
42889   * This hook is a side effect which updates the block-editor store when changes
42890   * happen to inner block settings. The given props are transformed into a
42891   * settings object, and if that is different from the current settings object in
42892   * the block-editor store, then the store is updated with the new settings which
42893   * came from props.
42894   *
42895   * @param {string}               clientId                   The client ID of the block to update.
42896   * @param {string}               parentLock
42897   * @param {string[]}             allowedBlocks              An array of block names which are permitted
42898   *                                                          in inner blocks.
42899   * @param {string[]}             prioritizedInserterBlocks  Block names and/or block variations to be prioritized in the inserter, in the format {blockName}/{variationName}.
42900   * @param {?WPDirectInsertBlock} defaultBlock               The default block to insert: [ blockName, { blockAttributes } ].
42901   * @param {?boolean}             directInsert               If a default block should be inserted directly by the appender.
42902   *
42903   * @param {?WPDirectInsertBlock} __experimentalDefaultBlock A deprecated prop for the default block to insert: [ blockName, { blockAttributes } ]. Use `defaultBlock` instead.
42904   *
42905   * @param {?boolean}             __experimentalDirectInsert A deprecated prop for whether a default block should be inserted directly by the appender. Use `directInsert` instead.
42906   *
42907   * @param {string}               [templateLock]             The template lock specified for the inner
42908   *                                                          blocks component. (e.g. "all")
42909   * @param {boolean}              captureToolbars            Whether or children toolbars should be shown
42910   *                                                          in the inner blocks component rather than on
42911   *                                                          the child block.
42912   * @param {string}               orientation                The direction in which the block
42913   *                                                          should face.
42914   * @param {Object}               layout                     The layout object for the block container.
42915   */
42916  function useNestedSettingsUpdate(clientId, parentLock, allowedBlocks, prioritizedInserterBlocks, defaultBlock, directInsert, __experimentalDefaultBlock, __experimentalDirectInsert, templateLock, captureToolbars, orientation, layout) {
42917    // Instead of adding a useSelect mapping here, please add to the useSelect
42918    // mapping in InnerBlocks! Every subscription impacts performance.
42919  
42920    const registry = (0,external_wp_data_namespaceObject.useRegistry)();
42921  
42922    // Implementors often pass a new array on every render,
42923    // and the contents of the arrays are just strings, so the entire array
42924    // can be passed as dependencies but We need to include the length of the array,
42925    // otherwise if the arrays change length but the first elements are equal the comparison,
42926    // does not works as expected.
42927    const _allowedBlocks = useShallowMemo(allowedBlocks);
42928    const _prioritizedInserterBlocks = useShallowMemo(prioritizedInserterBlocks);
42929    const _templateLock = templateLock === undefined || parentLock === 'contentOnly' ? parentLock : templateLock;
42930    (0,external_wp_element_namespaceObject.useLayoutEffect)(() => {
42931      const newSettings = {
42932        allowedBlocks: _allowedBlocks,
42933        prioritizedInserterBlocks: _prioritizedInserterBlocks,
42934        templateLock: _templateLock
42935      };
42936  
42937      // These values are not defined for RN, so only include them if they
42938      // are defined.
42939      if (captureToolbars !== undefined) {
42940        newSettings.__experimentalCaptureToolbars = captureToolbars;
42941      }
42942  
42943      // Orientation depends on layout,
42944      // ideally the separate orientation prop should be deprecated.
42945      if (orientation !== undefined) {
42946        newSettings.orientation = orientation;
42947      } else {
42948        const layoutType = getLayoutType(layout?.type);
42949        newSettings.orientation = layoutType.getOrientation(layout);
42950      }
42951      if (__experimentalDefaultBlock !== undefined) {
42952        external_wp_deprecated_default()('__experimentalDefaultBlock', {
42953          alternative: 'defaultBlock',
42954          since: '6.3',
42955          version: '6.4'
42956        });
42957        newSettings.defaultBlock = __experimentalDefaultBlock;
42958      }
42959      if (defaultBlock !== undefined) {
42960        newSettings.defaultBlock = defaultBlock;
42961      }
42962      if (__experimentalDirectInsert !== undefined) {
42963        external_wp_deprecated_default()('__experimentalDirectInsert', {
42964          alternative: 'directInsert',
42965          since: '6.3',
42966          version: '6.4'
42967        });
42968        newSettings.directInsert = __experimentalDirectInsert;
42969      }
42970      if (directInsert !== undefined) {
42971        newSettings.directInsert = directInsert;
42972      }
42973      if (newSettings.directInsert !== undefined && typeof newSettings.directInsert !== 'boolean') {
42974        external_wp_deprecated_default()('Using `Function` as a `directInsert` argument', {
42975          alternative: '`boolean` values',
42976          since: '6.5'
42977        });
42978      }
42979  
42980      // Batch updates to block list settings to avoid triggering cascading renders
42981      // for each container block included in a tree and optimize initial render.
42982      // To avoid triggering updateBlockListSettings for each container block
42983      // causing X re-renderings for X container blocks,
42984      // we batch all the updatedBlockListSettings in a single "data" batch
42985      // which results in a single re-render.
42986      if (!pendingSettingsUpdates.get(registry)) {
42987        pendingSettingsUpdates.set(registry, {});
42988      }
42989      pendingSettingsUpdates.get(registry)[clientId] = newSettings;
42990      window.queueMicrotask(() => {
42991        const settings = pendingSettingsUpdates.get(registry);
42992        if (Object.keys(settings).length) {
42993          const {
42994            updateBlockListSettings
42995          } = registry.dispatch(store);
42996          updateBlockListSettings(settings);
42997          pendingSettingsUpdates.set(registry, {});
42998        }
42999      });
43000    }, [clientId, _allowedBlocks, _prioritizedInserterBlocks, _templateLock, defaultBlock, directInsert, __experimentalDefaultBlock, __experimentalDirectInsert, captureToolbars, orientation, layout, registry]);
43001  }
43002  
43003  ;// ./node_modules/@wordpress/block-editor/build-module/components/inner-blocks/use-inner-block-template-sync.js
43004  /**
43005   * External dependencies
43006   */
43007  
43008  
43009  /**
43010   * WordPress dependencies
43011   */
43012  
43013  
43014  
43015  
43016  /**
43017   * Internal dependencies
43018   */
43019  
43020  
43021  /**
43022   * This hook makes sure that a block's inner blocks stay in sync with the given
43023   * block "template". The template is a block hierarchy to which inner blocks must
43024   * conform. If the blocks get "out of sync" with the template and the template
43025   * is meant to be locked (e.g. templateLock = "all" or templateLock = "contentOnly"),
43026   * then we replace the inner blocks with the correct value after synchronizing it with the template.
43027   *
43028   * @param {string}  clientId                       The block client ID.
43029   * @param {Object}  template                       The template to match.
43030   * @param {string}  templateLock                   The template lock state for the inner blocks. For
43031   *                                                 example, if the template lock is set to "all",
43032   *                                                 then the inner blocks will stay in sync with the
43033   *                                                 template. If not defined or set to false, then
43034   *                                                 the inner blocks will not be synchronized with
43035   *                                                 the given template.
43036   * @param {boolean} templateInsertUpdatesSelection Whether or not to update the
43037   *                                                 block-editor selection state when inner blocks
43038   *                                                 are replaced after template synchronization.
43039   */
43040  function useInnerBlockTemplateSync(clientId, template, templateLock, templateInsertUpdatesSelection) {
43041    // Instead of adding a useSelect mapping here, please add to the useSelect
43042    // mapping in InnerBlocks! Every subscription impacts performance.
43043    const registry = (0,external_wp_data_namespaceObject.useRegistry)();
43044  
43045    // Maintain a reference to the previous value so we can do a deep equality check.
43046    const existingTemplateRef = (0,external_wp_element_namespaceObject.useRef)(null);
43047    (0,external_wp_element_namespaceObject.useLayoutEffect)(() => {
43048      let isCancelled = false;
43049      const {
43050        getBlocks,
43051        getSelectedBlocksInitialCaretPosition,
43052        isBlockSelected
43053      } = registry.select(store);
43054      const {
43055        replaceInnerBlocks,
43056        __unstableMarkNextChangeAsNotPersistent
43057      } = registry.dispatch(store);
43058  
43059      // There's an implicit dependency between useInnerBlockTemplateSync and useNestedSettingsUpdate
43060      // The former needs to happen after the latter and since the latter is using microtasks to batch updates (performance optimization),
43061      // we need to schedule this one in a microtask as well.
43062      // Example: If you remove queueMicrotask here, ctrl + click to insert quote block won't close the inserter.
43063      window.queueMicrotask(() => {
43064        if (isCancelled) {
43065          return;
43066        }
43067  
43068        // Only synchronize innerBlocks with template if innerBlocks are empty
43069        // or a locking "all" or "contentOnly" exists directly on the block.
43070        const currentInnerBlocks = getBlocks(clientId);
43071        const shouldApplyTemplate = currentInnerBlocks.length === 0 || templateLock === 'all' || templateLock === 'contentOnly';
43072        const hasTemplateChanged = !es6_default()(template, existingTemplateRef.current);
43073        if (!shouldApplyTemplate || !hasTemplateChanged) {
43074          return;
43075        }
43076        existingTemplateRef.current = template;
43077        const nextBlocks = (0,external_wp_blocks_namespaceObject.synchronizeBlocksWithTemplate)(currentInnerBlocks, template);
43078        if (!es6_default()(nextBlocks, currentInnerBlocks)) {
43079          __unstableMarkNextChangeAsNotPersistent();
43080          replaceInnerBlocks(clientId, nextBlocks, currentInnerBlocks.length === 0 && templateInsertUpdatesSelection && nextBlocks.length !== 0 && isBlockSelected(clientId),
43081          // This ensures the "initialPosition" doesn't change when applying the template
43082          // If we're supposed to focus the block, we'll focus the first inner block
43083          // otherwise, we won't apply any auto-focus.
43084          // This ensures for instance that the focus stays in the inserter when inserting the "buttons" block.
43085          getSelectedBlocksInitialCaretPosition());
43086        }
43087      });
43088      return () => {
43089        isCancelled = true;
43090      };
43091    }, [template, templateLock, clientId, registry, templateInsertUpdatesSelection]);
43092  }
43093  
43094  ;// ./node_modules/@wordpress/block-editor/build-module/components/inner-blocks/use-block-context.js
43095  /**
43096   * WordPress dependencies
43097   */
43098  
43099  
43100  
43101  /**
43102   * Internal dependencies
43103   */
43104  
43105  
43106  /**
43107   * Returns a context object for a given block.
43108   *
43109   * @param {string} clientId The block client ID.
43110   *
43111   * @return {Record<string,*>} Context value.
43112   */
43113  function useBlockContext(clientId) {
43114    return (0,external_wp_data_namespaceObject.useSelect)(select => {
43115      const block = select(store).getBlock(clientId);
43116      if (!block) {
43117        return undefined;
43118      }
43119      const blockType = select(external_wp_blocks_namespaceObject.store).getBlockType(block.name);
43120      if (!blockType) {
43121        return undefined;
43122      }
43123      if (Object.keys(blockType.providesContext).length === 0) {
43124        return undefined;
43125      }
43126      return Object.fromEntries(Object.entries(blockType.providesContext).map(([contextName, attributeName]) => [contextName, block.attributes[attributeName]]));
43127    }, [clientId]);
43128  }
43129  
43130  ;// ./node_modules/@wordpress/block-editor/build-module/components/use-on-block-drop/index.js
43131  /**
43132   * WordPress dependencies
43133   */
43134  
43135  
43136  
43137  
43138  
43139  /**
43140   * Internal dependencies
43141   */
43142  
43143  
43144  /** @typedef {import('react').SyntheticEvent} SyntheticEvent */
43145  /** @typedef {import('./types').WPDropOperation} WPDropOperation */
43146  
43147  /**
43148   * Retrieve the data for a block drop event.
43149   *
43150   * @param {SyntheticEvent} event The drop event.
43151   *
43152   * @return {Object} An object with block drag and drop data.
43153   */
43154  function parseDropEvent(event) {
43155    let result = {
43156      srcRootClientId: null,
43157      srcClientIds: null,
43158      srcIndex: null,
43159      type: null,
43160      blocks: null
43161    };
43162    if (!event.dataTransfer) {
43163      return result;
43164    }
43165    try {
43166      result = Object.assign(result, JSON.parse(event.dataTransfer.getData('wp-blocks')));
43167    } catch (err) {
43168      return result;
43169    }
43170    return result;
43171  }
43172  
43173  /**
43174   * A function that returns an event handler function for block drop events.
43175   *
43176   * @param {string}   targetRootClientId        The root client id where the block(s) will be inserted.
43177   * @param {number}   targetBlockIndex          The index where the block(s) will be inserted.
43178   * @param {Function} getBlockIndex             A function that gets the index of a block.
43179   * @param {Function} getClientIdsOfDescendants A function that gets the client ids of descendant blocks.
43180   * @param {Function} moveBlocks                A function that moves blocks.
43181   * @param {Function} insertOrReplaceBlocks     A function that inserts or replaces blocks.
43182   * @param {Function} clearSelectedBlock        A function that clears block selection.
43183   * @param {string}   operation                 The type of operation to perform on drop. Could be `insert` or `replace` or `group`.
43184   * @param {Function} getBlock                  A function that returns a block given its client id.
43185   * @return {Function} The event handler for a block drop event.
43186   */
43187  function onBlockDrop(targetRootClientId, targetBlockIndex, getBlockIndex, getClientIdsOfDescendants, moveBlocks, insertOrReplaceBlocks, clearSelectedBlock, operation, getBlock) {
43188    return event => {
43189      const {
43190        srcRootClientId: sourceRootClientId,
43191        srcClientIds: sourceClientIds,
43192        type: dropType,
43193        blocks
43194      } = parseDropEvent(event);
43195  
43196      // If the user is inserting a block.
43197      if (dropType === 'inserter') {
43198        clearSelectedBlock();
43199        const blocksToInsert = blocks.map(block => (0,external_wp_blocks_namespaceObject.cloneBlock)(block));
43200        insertOrReplaceBlocks(blocksToInsert, true, null);
43201      }
43202  
43203      // If the user is moving a block.
43204      if (dropType === 'block') {
43205        const sourceBlockIndex = getBlockIndex(sourceClientIds[0]);
43206  
43207        // If the user is dropping to the same position, return early.
43208        if (sourceRootClientId === targetRootClientId && sourceBlockIndex === targetBlockIndex) {
43209          return;
43210        }
43211  
43212        // If the user is attempting to drop a block within its own
43213        // nested blocks, return early as this would create infinite
43214        // recursion.
43215        if (sourceClientIds.includes(targetRootClientId) || getClientIdsOfDescendants(sourceClientIds).some(id => id === targetRootClientId)) {
43216          return;
43217        }
43218  
43219        // If the user is dropping a block over another block, replace both blocks
43220        // with a group block containing them
43221        if (operation === 'group') {
43222          const blocksToInsert = sourceClientIds.map(clientId => getBlock(clientId));
43223          insertOrReplaceBlocks(blocksToInsert, true, null, sourceClientIds);
43224          return;
43225        }
43226        const isAtSameLevel = sourceRootClientId === targetRootClientId;
43227        const draggedBlockCount = sourceClientIds.length;
43228  
43229        // If the block is kept at the same level and moved downwards,
43230        // subtract to take into account that the blocks being dragged
43231        // were removed from the block list above the insertion point.
43232        const insertIndex = isAtSameLevel && sourceBlockIndex < targetBlockIndex ? targetBlockIndex - draggedBlockCount : targetBlockIndex;
43233        moveBlocks(sourceClientIds, sourceRootClientId, insertIndex);
43234      }
43235    };
43236  }
43237  
43238  /**
43239   * A function that returns an event handler function for block-related file drop events.
43240   *
43241   * @param {string}   targetRootClientId    The root client id where the block(s) will be inserted.
43242   * @param {Function} getSettings           A function that gets the block editor settings.
43243   * @param {Function} updateBlockAttributes A function that updates a block's attributes.
43244   * @param {Function} canInsertBlockType    A function that returns checks whether a block type can be inserted.
43245   * @param {Function} insertOrReplaceBlocks A function that inserts or replaces blocks.
43246   *
43247   * @return {Function} The event handler for a block-related file drop event.
43248   */
43249  function onFilesDrop(targetRootClientId, getSettings, updateBlockAttributes, canInsertBlockType, insertOrReplaceBlocks) {
43250    return files => {
43251      if (!getSettings().mediaUpload) {
43252        return;
43253      }
43254      const transformation = (0,external_wp_blocks_namespaceObject.findTransform)((0,external_wp_blocks_namespaceObject.getBlockTransforms)('from'), transform => transform.type === 'files' && canInsertBlockType(transform.blockName, targetRootClientId) && transform.isMatch(files));
43255      if (transformation) {
43256        const blocks = transformation.transform(files, updateBlockAttributes);
43257        insertOrReplaceBlocks(blocks);
43258      }
43259    };
43260  }
43261  
43262  /**
43263   * A function that returns an event handler function for block-related HTML drop events.
43264   *
43265   * @param {Function} insertOrReplaceBlocks A function that inserts or replaces blocks.
43266   *
43267   * @return {Function} The event handler for a block-related HTML drop event.
43268   */
43269  function onHTMLDrop(insertOrReplaceBlocks) {
43270    return HTML => {
43271      const blocks = (0,external_wp_blocks_namespaceObject.pasteHandler)({
43272        HTML,
43273        mode: 'BLOCKS'
43274      });
43275      if (blocks.length) {
43276        insertOrReplaceBlocks(blocks);
43277      }
43278    };
43279  }
43280  
43281  /**
43282   * A React hook for handling block drop events.
43283   *
43284   * @param {string}          targetRootClientId  The root client id where the block(s) will be inserted.
43285   * @param {number}          targetBlockIndex    The index where the block(s) will be inserted.
43286   * @param {Object}          options             The optional options.
43287   * @param {WPDropOperation} [options.operation] The type of operation to perform on drop. Could be `insert` or `replace` for now.
43288   *
43289   * @return {Function} A function to be passed to the onDrop handler.
43290   */
43291  function useOnBlockDrop(targetRootClientId, targetBlockIndex, options = {}) {
43292    const {
43293      operation = 'insert',
43294      nearestSide = 'right'
43295    } = options;
43296    const {
43297      canInsertBlockType,
43298      getBlockIndex,
43299      getClientIdsOfDescendants,
43300      getBlockOrder,
43301      getBlocksByClientId,
43302      getSettings,
43303      getBlock
43304    } = (0,external_wp_data_namespaceObject.useSelect)(store);
43305    const {
43306      getGroupingBlockName
43307    } = (0,external_wp_data_namespaceObject.useSelect)(external_wp_blocks_namespaceObject.store);
43308    const {
43309      insertBlocks,
43310      moveBlocksToPosition,
43311      updateBlockAttributes,
43312      clearSelectedBlock,
43313      replaceBlocks,
43314      removeBlocks
43315    } = (0,external_wp_data_namespaceObject.useDispatch)(store);
43316    const registry = (0,external_wp_data_namespaceObject.useRegistry)();
43317    const insertOrReplaceBlocks = (0,external_wp_element_namespaceObject.useCallback)((blocks, updateSelection = true, initialPosition = 0, clientIdsToReplace = []) => {
43318      if (!Array.isArray(blocks)) {
43319        blocks = [blocks];
43320      }
43321      const clientIds = getBlockOrder(targetRootClientId);
43322      const clientId = clientIds[targetBlockIndex];
43323      if (operation === 'replace') {
43324        replaceBlocks(clientId, blocks, undefined, initialPosition);
43325      } else if (operation === 'group') {
43326        const targetBlock = getBlock(clientId);
43327        if (nearestSide === 'left') {
43328          blocks.push(targetBlock);
43329        } else {
43330          blocks.unshift(targetBlock);
43331        }
43332        const groupInnerBlocks = blocks.map(block => {
43333          return (0,external_wp_blocks_namespaceObject.createBlock)(block.name, block.attributes, block.innerBlocks);
43334        });
43335        const areAllImages = blocks.every(block => {
43336          return block.name === 'core/image';
43337        });
43338        const galleryBlock = canInsertBlockType('core/gallery', targetRootClientId);
43339        const wrappedBlocks = (0,external_wp_blocks_namespaceObject.createBlock)(areAllImages && galleryBlock ? 'core/gallery' : getGroupingBlockName(), {
43340          layout: {
43341            type: 'flex',
43342            flexWrap: areAllImages && galleryBlock ? null : 'nowrap'
43343          }
43344        }, groupInnerBlocks);
43345        // Need to make sure both the target block and the block being dragged are replaced
43346        // otherwise the dragged block will be duplicated.
43347        replaceBlocks([clientId, ...clientIdsToReplace], wrappedBlocks, undefined, initialPosition);
43348      } else {
43349        insertBlocks(blocks, targetBlockIndex, targetRootClientId, updateSelection, initialPosition);
43350      }
43351    }, [getBlockOrder, targetRootClientId, targetBlockIndex, operation, replaceBlocks, getBlock, nearestSide, canInsertBlockType, getGroupingBlockName, insertBlocks]);
43352    const moveBlocks = (0,external_wp_element_namespaceObject.useCallback)((sourceClientIds, sourceRootClientId, insertIndex) => {
43353      if (operation === 'replace') {
43354        const sourceBlocks = getBlocksByClientId(sourceClientIds);
43355        const targetBlockClientIds = getBlockOrder(targetRootClientId);
43356        const targetBlockClientId = targetBlockClientIds[targetBlockIndex];
43357        registry.batch(() => {
43358          // Remove the source blocks.
43359          removeBlocks(sourceClientIds, false);
43360          // Replace the target block with the source blocks.
43361          replaceBlocks(targetBlockClientId, sourceBlocks, undefined, 0);
43362        });
43363      } else {
43364        moveBlocksToPosition(sourceClientIds, sourceRootClientId, targetRootClientId, insertIndex);
43365      }
43366    }, [operation, getBlockOrder, getBlocksByClientId, moveBlocksToPosition, registry, removeBlocks, replaceBlocks, targetBlockIndex, targetRootClientId]);
43367    const _onDrop = onBlockDrop(targetRootClientId, targetBlockIndex, getBlockIndex, getClientIdsOfDescendants, moveBlocks, insertOrReplaceBlocks, clearSelectedBlock, operation, getBlock);
43368    const _onFilesDrop = onFilesDrop(targetRootClientId, getSettings, updateBlockAttributes, canInsertBlockType, insertOrReplaceBlocks);
43369    const _onHTMLDrop = onHTMLDrop(insertOrReplaceBlocks);
43370    return event => {
43371      const files = (0,external_wp_dom_namespaceObject.getFilesFromDataTransfer)(event.dataTransfer);
43372      const html = event.dataTransfer.getData('text/html');
43373  
43374      /**
43375       * From Windows Chrome 96, the `event.dataTransfer` returns both file object and HTML.
43376       * The order of the checks is important to recognise the HTML drop.
43377       */
43378      if (html) {
43379        _onHTMLDrop(html);
43380      } else if (files.length) {
43381        _onFilesDrop(files);
43382      } else {
43383        _onDrop(event);
43384      }
43385    };
43386  }
43387  
43388  ;// ./node_modules/@wordpress/block-editor/build-module/utils/math.js
43389  /**
43390   * A string representing the name of an edge.
43391   *
43392   * @typedef {'top'|'right'|'bottom'|'left'} WPEdgeName
43393   */
43394  
43395  /**
43396   * @typedef  {Object} WPPoint
43397   * @property {number} x The horizontal position.
43398   * @property {number} y The vertical position.
43399   */
43400  
43401  /**
43402   * Given a point, a DOMRect and the name of an edge, returns the distance to
43403   * that edge of the rect.
43404   *
43405   * This function works for edges that are horizontal or vertical (e.g. not
43406   * rotated), the following terms are used so that the function works in both
43407   * orientations:
43408   *
43409   * - Forward, meaning the axis running horizontally when an edge is vertical
43410   *   and vertically when an edge is horizontal.
43411   * - Lateral, meaning the axis running vertically when an edge is vertical
43412   *   and horizontally when an edge is horizontal.
43413   *
43414   * @param {WPPoint}    point The point to measure distance from.
43415   * @param {DOMRect}    rect  A DOM Rect containing edge positions.
43416   * @param {WPEdgeName} edge  The edge to measure to.
43417   */
43418  function getDistanceFromPointToEdge(point, rect, edge) {
43419    const isHorizontal = edge === 'top' || edge === 'bottom';
43420    const {
43421      x,
43422      y
43423    } = point;
43424    const pointLateralPosition = isHorizontal ? x : y;
43425    const pointForwardPosition = isHorizontal ? y : x;
43426    const edgeStart = isHorizontal ? rect.left : rect.top;
43427    const edgeEnd = isHorizontal ? rect.right : rect.bottom;
43428    const edgeForwardPosition = rect[edge];
43429  
43430    // Measure the straight line distance to the edge of the rect, when the
43431    // point is adjacent to the edge.
43432    // Else, if the point is positioned diagonally to the edge of the rect,
43433    // measure diagonally to the nearest corner that the edge meets.
43434    let edgeLateralPosition;
43435    if (pointLateralPosition >= edgeStart && pointLateralPosition <= edgeEnd) {
43436      edgeLateralPosition = pointLateralPosition;
43437    } else if (pointLateralPosition < edgeEnd) {
43438      edgeLateralPosition = edgeStart;
43439    } else {
43440      edgeLateralPosition = edgeEnd;
43441    }
43442    return Math.sqrt((pointLateralPosition - edgeLateralPosition) ** 2 + (pointForwardPosition - edgeForwardPosition) ** 2);
43443  }
43444  
43445  /**
43446   * Given a point, a DOMRect and a list of allowed edges returns the name of and
43447   * distance to the nearest edge.
43448   *
43449   * @param {WPPoint}      point        The point to measure distance from.
43450   * @param {DOMRect}      rect         A DOM Rect containing edge positions.
43451   * @param {WPEdgeName[]} allowedEdges A list of the edges included in the
43452   *                                    calculation. Defaults to all edges.
43453   *
43454   * @return {[number, string]} An array where the first value is the distance
43455   *                              and a second is the edge name.
43456   */
43457  function getDistanceToNearestEdge(point, rect, allowedEdges = ['top', 'bottom', 'left', 'right']) {
43458    let candidateDistance;
43459    let candidateEdge;
43460    allowedEdges.forEach(edge => {
43461      const distance = getDistanceFromPointToEdge(point, rect, edge);
43462      if (candidateDistance === undefined || distance < candidateDistance) {
43463        candidateDistance = distance;
43464        candidateEdge = edge;
43465      }
43466    });
43467    return [candidateDistance, candidateEdge];
43468  }
43469  
43470  /**
43471   * Is the point contained by the rectangle.
43472   *
43473   * @param {WPPoint} point The point.
43474   * @param {DOMRect} rect  The rectangle.
43475   *
43476   * @return {boolean} True if the point is contained by the rectangle, false otherwise.
43477   */
43478  function isPointContainedByRect(point, rect) {
43479    return rect.left <= point.x && rect.right >= point.x && rect.top <= point.y && rect.bottom >= point.y;
43480  }
43481  
43482  /**
43483   * Is the point within the top and bottom boundaries of the rectangle.
43484   *
43485   * @param {WPPoint} point The point.
43486   * @param {DOMRect} rect  The rectangle.
43487   *
43488   * @return {boolean} True if the point is within top and bottom of rectangle, false otherwise.
43489   */
43490  function isPointWithinTopAndBottomBoundariesOfRect(point, rect) {
43491    return rect.top <= point.y && rect.bottom >= point.y;
43492  }
43493  
43494  ;// ./node_modules/@wordpress/block-editor/build-module/components/use-block-drop-zone/index.js
43495  /**
43496   * WordPress dependencies
43497   */
43498  
43499  
43500  
43501  
43502  
43503  
43504  /**
43505   * Internal dependencies
43506   */
43507  
43508  
43509  
43510  
43511  const THRESHOLD_DISTANCE = 30;
43512  const MINIMUM_HEIGHT_FOR_THRESHOLD = 120;
43513  const MINIMUM_WIDTH_FOR_THRESHOLD = 120;
43514  
43515  /** @typedef {import('../../utils/math').WPPoint} WPPoint */
43516  /** @typedef {import('../use-on-block-drop/types').WPDropOperation} WPDropOperation */
43517  
43518  /**
43519   * The orientation of a block list.
43520   *
43521   * @typedef {'horizontal'|'vertical'|undefined} WPBlockListOrientation
43522   */
43523  
43524  /**
43525   * The insert position when dropping a block.
43526   *
43527   * @typedef {'before'|'after'} WPInsertPosition
43528   */
43529  
43530  /**
43531   * @typedef {Object} WPBlockData
43532   * @property {boolean}       isUnmodifiedDefaultBlock Is the block unmodified default block.
43533   * @property {() => DOMRect} getBoundingClientRect    Get the bounding client rect of the block.
43534   * @property {number}        blockIndex               The index of the block.
43535   */
43536  
43537  /**
43538   * Get the drop target position from a given drop point and the orientation.
43539   *
43540   * @param {WPBlockData[]}          blocksData  The block data list.
43541   * @param {WPPoint}                position    The position of the item being dragged.
43542   * @param {WPBlockListOrientation} orientation The orientation of the block list.
43543   * @param {Object}                 options     Additional options.
43544   * @return {[number, WPDropOperation]} The drop target position.
43545   */
43546  function getDropTargetPosition(blocksData, position, orientation = 'vertical', options = {}) {
43547    const allowedEdges = orientation === 'horizontal' ? ['left', 'right'] : ['top', 'bottom'];
43548    let nearestIndex = 0;
43549    let insertPosition = 'before';
43550    let minDistance = Infinity;
43551    let targetBlockIndex = null;
43552    let nearestSide = 'right';
43553    const {
43554      dropZoneElement,
43555      parentBlockOrientation,
43556      rootBlockIndex = 0
43557    } = options;
43558  
43559    // Allow before/after when dragging over the top/bottom edges of the drop zone.
43560    if (dropZoneElement && parentBlockOrientation !== 'horizontal') {
43561      const rect = dropZoneElement.getBoundingClientRect();
43562      const [distance, edge] = getDistanceToNearestEdge(position, rect, ['top', 'bottom']);
43563  
43564      // If dragging over the top or bottom of the drop zone, insert the block
43565      // before or after the parent block. This only applies to blocks that use
43566      // a drop zone element, typically container blocks such as Group or Cover.
43567      if (rect.height > MINIMUM_HEIGHT_FOR_THRESHOLD && distance < THRESHOLD_DISTANCE) {
43568        if (edge === 'top') {
43569          return [rootBlockIndex, 'before'];
43570        }
43571        if (edge === 'bottom') {
43572          return [rootBlockIndex + 1, 'after'];
43573        }
43574      }
43575    }
43576    const isRightToLeft = (0,external_wp_i18n_namespaceObject.isRTL)();
43577  
43578    // Allow before/after when dragging over the left/right edges of the drop zone.
43579    if (dropZoneElement && parentBlockOrientation === 'horizontal') {
43580      const rect = dropZoneElement.getBoundingClientRect();
43581      const [distance, edge] = getDistanceToNearestEdge(position, rect, ['left', 'right']);
43582  
43583      // If dragging over the left or right of the drop zone, insert the block
43584      // before or after the parent block. This only applies to blocks that use
43585      // a drop zone element, typically container blocks such as Group.
43586      if (rect.width > MINIMUM_WIDTH_FOR_THRESHOLD && distance < THRESHOLD_DISTANCE) {
43587        if (isRightToLeft && edge === 'right' || !isRightToLeft && edge === 'left') {
43588          return [rootBlockIndex, 'before'];
43589        }
43590        if (isRightToLeft && edge === 'left' || !isRightToLeft && edge === 'right') {
43591          return [rootBlockIndex + 1, 'after'];
43592        }
43593      }
43594    }
43595    blocksData.forEach(({
43596      isUnmodifiedDefaultBlock,
43597      getBoundingClientRect,
43598      blockIndex,
43599      blockOrientation
43600    }) => {
43601      const rect = getBoundingClientRect();
43602      let [distance, edge] = getDistanceToNearestEdge(position, rect, allowedEdges);
43603      // If the the point is close to a side, prioritize that side.
43604      const [sideDistance, sideEdge] = getDistanceToNearestEdge(position, rect, ['left', 'right']);
43605      const isPointInsideRect = isPointContainedByRect(position, rect);
43606  
43607      // Prioritize the element if the point is inside of an unmodified default block.
43608      if (isUnmodifiedDefaultBlock && isPointInsideRect) {
43609        distance = 0;
43610      } else if (orientation === 'vertical' && blockOrientation !== 'horizontal' && (isPointInsideRect && sideDistance < THRESHOLD_DISTANCE || !isPointInsideRect && isPointWithinTopAndBottomBoundariesOfRect(position, rect))) {
43611        /**
43612         * This condition should only apply when the layout is vertical (otherwise there's
43613         * no need to create a Row) and dropzones should only activate when the block is
43614         * either within and close to the sides of the target block or on its outer sides.
43615         */
43616        targetBlockIndex = blockIndex;
43617        nearestSide = sideEdge;
43618      }
43619      if (distance < minDistance) {
43620        // Where the dropped block will be inserted on the nearest block.
43621        insertPosition = edge === 'bottom' || !isRightToLeft && edge === 'right' || isRightToLeft && edge === 'left' ? 'after' : 'before';
43622  
43623        // Update the currently known best candidate.
43624        minDistance = distance;
43625        nearestIndex = blockIndex;
43626      }
43627    });
43628    const adjacentIndex = nearestIndex + (insertPosition === 'after' ? 1 : -1);
43629    const isNearestBlockUnmodifiedDefaultBlock = !!blocksData[nearestIndex]?.isUnmodifiedDefaultBlock;
43630    const isAdjacentBlockUnmodifiedDefaultBlock = !!blocksData[adjacentIndex]?.isUnmodifiedDefaultBlock;
43631  
43632    // If the target index is set then group with the block at that index.
43633    if (targetBlockIndex !== null) {
43634      return [targetBlockIndex, 'group', nearestSide];
43635    }
43636    // If both blocks are not unmodified default blocks then just insert between them.
43637    if (!isNearestBlockUnmodifiedDefaultBlock && !isAdjacentBlockUnmodifiedDefaultBlock) {
43638      // If the user is dropping to the trailing edge of the block
43639      // add 1 to the index to represent dragging after.
43640      const insertionIndex = insertPosition === 'after' ? nearestIndex + 1 : nearestIndex;
43641      return [insertionIndex, 'insert'];
43642    }
43643  
43644    // Otherwise, replace the nearest unmodified default block.
43645    return [isNearestBlockUnmodifiedDefaultBlock ? nearestIndex : adjacentIndex, 'replace'];
43646  }
43647  
43648  /**
43649   * Check if the dragged blocks can be dropped on the target.
43650   * @param {Function} getBlockType
43651   * @param {Object[]} allowedBlocks
43652   * @param {string[]} draggedBlockNames
43653   * @param {string}   targetBlockName
43654   * @return {boolean} Whether the dragged blocks can be dropped on the target.
43655   */
43656  function isDropTargetValid(getBlockType, allowedBlocks, draggedBlockNames, targetBlockName) {
43657    // At root level allowedBlocks is undefined and all blocks are allowed.
43658    // Otherwise, check if all dragged blocks are allowed.
43659    let areBlocksAllowed = true;
43660    if (allowedBlocks) {
43661      const allowedBlockNames = allowedBlocks?.map(({
43662        name
43663      }) => name);
43664      areBlocksAllowed = draggedBlockNames.every(name => allowedBlockNames?.includes(name));
43665    }
43666  
43667    // Work out if dragged blocks have an allowed parent and if so
43668    // check target block matches the allowed parent.
43669    const draggedBlockTypes = draggedBlockNames.map(name => getBlockType(name));
43670    const targetMatchesDraggedBlockParents = draggedBlockTypes.every(block => {
43671      const [allowedParentName] = block?.parent || [];
43672      if (!allowedParentName) {
43673        return true;
43674      }
43675      return allowedParentName === targetBlockName;
43676    });
43677    return areBlocksAllowed && targetMatchesDraggedBlockParents;
43678  }
43679  
43680  /**
43681   * Checks if the given element is an insertion point.
43682   *
43683   * @param {EventTarget|null} targetToCheck - The element to check.
43684   * @param {Document}         ownerDocument - The owner document of the element.
43685   * @return {boolean} True if the element is a insertion point, false otherwise.
43686   */
43687  function isInsertionPoint(targetToCheck, ownerDocument) {
43688    const {
43689      defaultView
43690    } = ownerDocument;
43691    return !!(defaultView && targetToCheck instanceof defaultView.HTMLElement && targetToCheck.closest('[data-is-insertion-point]'));
43692  }
43693  
43694  /**
43695   * @typedef  {Object} WPBlockDropZoneConfig
43696   * @property {?HTMLElement} dropZoneElement Optional element to be used as the drop zone.
43697   * @property {string}       rootClientId    The root client id for the block list.
43698   */
43699  
43700  /**
43701   * A React hook that can be used to make a block list handle drag and drop.
43702   *
43703   * @param {WPBlockDropZoneConfig} dropZoneConfig configuration data for the drop zone.
43704   */
43705  function useBlockDropZone({
43706    dropZoneElement,
43707    // An undefined value represents a top-level block. Default to an empty
43708    // string for this so that `targetRootClientId` can be easily compared to
43709    // values returned by the `getRootBlockClientId` selector, which also uses
43710    // an empty string to represent top-level blocks.
43711    rootClientId: targetRootClientId = '',
43712    parentClientId: parentBlockClientId = '',
43713    isDisabled = false
43714  } = {}) {
43715    const registry = (0,external_wp_data_namespaceObject.useRegistry)();
43716    const [dropTarget, setDropTarget] = (0,external_wp_element_namespaceObject.useState)({
43717      index: null,
43718      operation: 'insert'
43719    });
43720    const {
43721      getBlockType,
43722      getBlockVariations,
43723      getGroupingBlockName
43724    } = (0,external_wp_data_namespaceObject.useSelect)(external_wp_blocks_namespaceObject.store);
43725    const {
43726      canInsertBlockType,
43727      getBlockListSettings,
43728      getBlocks,
43729      getBlockIndex,
43730      getDraggedBlockClientIds,
43731      getBlockNamesByClientId,
43732      getAllowedBlocks,
43733      isDragging,
43734      isGroupable,
43735      isZoomOut,
43736      getSectionRootClientId,
43737      getBlockParents
43738    } = unlock((0,external_wp_data_namespaceObject.useSelect)(store));
43739    const {
43740      showInsertionPoint,
43741      hideInsertionPoint,
43742      startDragging,
43743      stopDragging
43744    } = unlock((0,external_wp_data_namespaceObject.useDispatch)(store));
43745    const onBlockDrop = useOnBlockDrop(dropTarget.operation === 'before' || dropTarget.operation === 'after' ? parentBlockClientId : targetRootClientId, dropTarget.index, {
43746      operation: dropTarget.operation,
43747      nearestSide: dropTarget.nearestSide
43748    });
43749    const throttled = (0,external_wp_compose_namespaceObject.useThrottle)((0,external_wp_element_namespaceObject.useCallback)((event, ownerDocument) => {
43750      if (!isDragging()) {
43751        // When dragging from the desktop, no drag start event is fired.
43752        // So, ensure that the drag state is set when the user drags over a drop zone.
43753        startDragging();
43754      }
43755      const draggedBlockClientIds = getDraggedBlockClientIds();
43756      const targetParents = [targetRootClientId, ...getBlockParents(targetRootClientId, true)];
43757  
43758      // Check if the target is within any of the dragged blocks.
43759      const isTargetWithinDraggedBlocks = draggedBlockClientIds.some(clientId => targetParents.includes(clientId));
43760      if (isTargetWithinDraggedBlocks) {
43761        return;
43762      }
43763      const allowedBlocks = getAllowedBlocks(targetRootClientId);
43764      const targetBlockName = getBlockNamesByClientId([targetRootClientId])[0];
43765      const draggedBlockNames = getBlockNamesByClientId(draggedBlockClientIds);
43766      const isBlockDroppingAllowed = isDropTargetValid(getBlockType, allowedBlocks, draggedBlockNames, targetBlockName);
43767      if (!isBlockDroppingAllowed) {
43768        return;
43769      }
43770      const sectionRootClientId = getSectionRootClientId();
43771  
43772      // In Zoom Out mode, if the target is not the section root provided by settings then
43773      // do not allow dropping as the drop target is not within the root (that which is
43774      // treated as "the content" by Zoom Out Mode).
43775      if (isZoomOut() && sectionRootClientId !== targetRootClientId) {
43776        return;
43777      }
43778      const blocks = getBlocks(targetRootClientId);
43779  
43780      // The block list is empty, don't show the insertion point but still allow dropping.
43781      if (blocks.length === 0) {
43782        registry.batch(() => {
43783          setDropTarget({
43784            index: 0,
43785            operation: 'insert'
43786          });
43787          showInsertionPoint(targetRootClientId, 0, {
43788            operation: 'insert'
43789          });
43790        });
43791        return;
43792      }
43793      const blocksData = blocks.map(block => {
43794        const clientId = block.clientId;
43795        return {
43796          isUnmodifiedDefaultBlock: (0,external_wp_blocks_namespaceObject.isUnmodifiedDefaultBlock)(block),
43797          getBoundingClientRect: () => ownerDocument.getElementById(`block-$clientId}`).getBoundingClientRect(),
43798          blockIndex: getBlockIndex(clientId),
43799          blockOrientation: getBlockListSettings(clientId)?.orientation
43800        };
43801      });
43802      const dropTargetPosition = getDropTargetPosition(blocksData, {
43803        x: event.clientX,
43804        y: event.clientY
43805      }, getBlockListSettings(targetRootClientId)?.orientation, {
43806        dropZoneElement,
43807        parentBlockClientId,
43808        parentBlockOrientation: parentBlockClientId ? getBlockListSettings(parentBlockClientId)?.orientation : undefined,
43809        rootBlockIndex: getBlockIndex(targetRootClientId)
43810      });
43811      const [targetIndex, operation, nearestSide] = dropTargetPosition;
43812      const isTargetIndexEmptyDefaultBlock = blocksData[targetIndex]?.isUnmodifiedDefaultBlock;
43813      if (isZoomOut() && !isTargetIndexEmptyDefaultBlock && operation !== 'insert') {
43814        return;
43815      }
43816      if (operation === 'group') {
43817        const targetBlock = blocks[targetIndex];
43818        const areAllImages = [targetBlock.name, ...draggedBlockNames].every(name => name === 'core/image');
43819        const canInsertGalleryBlock = canInsertBlockType('core/gallery', targetRootClientId);
43820        const areGroupableBlocks = isGroupable([targetBlock.clientId, getDraggedBlockClientIds()]);
43821        const groupBlockVariations = getBlockVariations(getGroupingBlockName(), 'block');
43822        const canInsertRow = groupBlockVariations && groupBlockVariations.find(({
43823          name
43824        }) => name === 'group-row');
43825  
43826        // If the dragged blocks and the target block are all images,
43827        // check if it is creatable either a Row variation or a Gallery block.
43828        if (areAllImages && !canInsertGalleryBlock && (!areGroupableBlocks || !canInsertRow)) {
43829          return;
43830        }
43831        // If the dragged blocks and the target block are not all images,
43832        // check if it is creatable a Row variation.
43833        if (!areAllImages && (!areGroupableBlocks || !canInsertRow)) {
43834          return;
43835        }
43836      }
43837      registry.batch(() => {
43838        setDropTarget({
43839          index: targetIndex,
43840          operation,
43841          nearestSide
43842        });
43843        const insertionPointClientId = ['before', 'after'].includes(operation) ? parentBlockClientId : targetRootClientId;
43844        showInsertionPoint(insertionPointClientId, targetIndex, {
43845          operation,
43846          nearestSide
43847        });
43848      });
43849    }, [isDragging, getAllowedBlocks, targetRootClientId, getBlockNamesByClientId, getDraggedBlockClientIds, getBlockType, getSectionRootClientId, isZoomOut, getBlocks, getBlockListSettings, dropZoneElement, parentBlockClientId, getBlockIndex, registry, startDragging, showInsertionPoint, canInsertBlockType, isGroupable, getBlockVariations, getGroupingBlockName]), 200);
43850    return (0,external_wp_compose_namespaceObject.__experimentalUseDropZone)({
43851      dropZoneElement,
43852      isDisabled,
43853      onDrop: onBlockDrop,
43854      onDragOver(event) {
43855        // `currentTarget` is only available while the event is being
43856        // handled, so get it now and pass it to the thottled function.
43857        // https://developer.mozilla.org/en-US/docs/Web/API/Event/currentTarget
43858        throttled(event, event.currentTarget.ownerDocument);
43859      },
43860      onDragLeave(event) {
43861        const {
43862          ownerDocument
43863        } = event.currentTarget;
43864  
43865        // If the drag event is leaving the drop zone and entering an insertion point,
43866        // do not hide the insertion point as it is conceptually within the dropzone.
43867        if (isInsertionPoint(event.relatedTarget, ownerDocument) || isInsertionPoint(event.target, ownerDocument)) {
43868          return;
43869        }
43870        throttled.cancel();
43871        hideInsertionPoint();
43872      },
43873      onDragEnd() {
43874        throttled.cancel();
43875        stopDragging();
43876        hideInsertionPoint();
43877      }
43878    });
43879  }
43880  
43881  ;// ./node_modules/@wordpress/block-editor/build-module/components/inner-blocks/index.js
43882  /**
43883   * External dependencies
43884   */
43885  
43886  
43887  /**
43888   * WordPress dependencies
43889   */
43890  
43891  
43892  
43893  
43894  
43895  /**
43896   * Internal dependencies
43897   */
43898  
43899  
43900  
43901  
43902  
43903  
43904  
43905  
43906  
43907  
43908  
43909  
43910  
43911  const EMPTY_OBJECT = {};
43912  function BlockContext({
43913    children,
43914    clientId
43915  }) {
43916    const context = useBlockContext(clientId);
43917    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockContextProvider, {
43918      value: context,
43919      children: children
43920    });
43921  }
43922  const BlockListItemsMemo = (0,external_wp_element_namespaceObject.memo)(BlockListItems);
43923  
43924  /**
43925   * InnerBlocks is a component which allows a single block to have multiple blocks
43926   * as children. The UncontrolledInnerBlocks component is used whenever the inner
43927   * blocks are not controlled by another entity. In other words, it is normally
43928   * used for inner blocks in the post editor
43929   *
43930   * @param {Object} props The component props.
43931   */
43932  function UncontrolledInnerBlocks(props) {
43933    const {
43934      clientId,
43935      allowedBlocks,
43936      prioritizedInserterBlocks,
43937      defaultBlock,
43938      directInsert,
43939      __experimentalDefaultBlock,
43940      __experimentalDirectInsert,
43941      template,
43942      templateLock,
43943      wrapperRef,
43944      templateInsertUpdatesSelection,
43945      __experimentalCaptureToolbars: captureToolbars,
43946      __experimentalAppenderTagName,
43947      renderAppender,
43948      orientation,
43949      placeholder,
43950      layout,
43951      name,
43952      blockType,
43953      parentLock,
43954      defaultLayout
43955    } = props;
43956    useNestedSettingsUpdate(clientId, parentLock, allowedBlocks, prioritizedInserterBlocks, defaultBlock, directInsert, __experimentalDefaultBlock, __experimentalDirectInsert, templateLock, captureToolbars, orientation, layout);
43957    useInnerBlockTemplateSync(clientId, template, templateLock, templateInsertUpdatesSelection);
43958    const defaultLayoutBlockSupport = (0,external_wp_blocks_namespaceObject.getBlockSupport)(name, 'layout') || (0,external_wp_blocks_namespaceObject.getBlockSupport)(name, '__experimentalLayout') || EMPTY_OBJECT;
43959    const {
43960      allowSizingOnChildren = false
43961    } = defaultLayoutBlockSupport;
43962    const usedLayout = layout || defaultLayoutBlockSupport;
43963    const memoedLayout = (0,external_wp_element_namespaceObject.useMemo)(() => ({
43964      // Default layout will know about any content/wide size defined by the theme.
43965      ...defaultLayout,
43966      ...usedLayout,
43967      ...(allowSizingOnChildren && {
43968        allowSizingOnChildren: true
43969      })
43970    }), [defaultLayout, usedLayout, allowSizingOnChildren]);
43971  
43972    // For controlled inner blocks, we don't want a change in blocks to
43973    // re-render the blocks list.
43974    const items = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockListItemsMemo, {
43975      rootClientId: clientId,
43976      renderAppender: renderAppender,
43977      __experimentalAppenderTagName: __experimentalAppenderTagName,
43978      layout: memoedLayout,
43979      wrapperRef: wrapperRef,
43980      placeholder: placeholder
43981    });
43982    if (!blockType?.providesContext || Object.keys(blockType.providesContext).length === 0) {
43983      return items;
43984    }
43985    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockContext, {
43986      clientId: clientId,
43987      children: items
43988    });
43989  }
43990  
43991  /**
43992   * The controlled inner blocks component wraps the uncontrolled inner blocks
43993   * component with the blockSync hook. This keeps the innerBlocks of the block in
43994   * the block-editor store in sync with the blocks of the controlling entity. An
43995   * example of an inner block controller is a template part block, which provides
43996   * its own blocks from the template part entity data source.
43997   *
43998   * @param {Object} props The component props.
43999   */
44000  function ControlledInnerBlocks(props) {
44001    useBlockSync(props);
44002    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(UncontrolledInnerBlocks, {
44003      ...props
44004    });
44005  }
44006  const ForwardedInnerBlocks = (0,external_wp_element_namespaceObject.forwardRef)((props, ref) => {
44007    const innerBlocksProps = useInnerBlocksProps({
44008      ref
44009    }, props);
44010    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
44011      className: "block-editor-inner-blocks",
44012      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
44013        ...innerBlocksProps
44014      })
44015    });
44016  });
44017  
44018  /**
44019   * This hook is used to lightly mark an element as an inner blocks wrapper
44020   * element. Call this hook and pass the returned props to the element to mark as
44021   * an inner blocks wrapper, automatically rendering inner blocks as children. If
44022   * you define a ref for the element, it is important to pass the ref to this
44023   * hook, which the hook in turn will pass to the component through the props it
44024   * returns. Optionally, you can also pass any other props through this hook, and
44025   * they will be merged and returned.
44026   *
44027   * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/inner-blocks/README.md
44028   *
44029   * @param {Object} props   Optional. Props to pass to the element. Must contain
44030   *                         the ref if one is defined.
44031   * @param {Object} options Optional. Inner blocks options.
44032   */
44033  function useInnerBlocksProps(props = {}, options = {}) {
44034    const {
44035      __unstableDisableLayoutClassNames,
44036      __unstableDisableDropZone,
44037      dropZoneElement
44038    } = options;
44039    const {
44040      clientId,
44041      layout = null,
44042      __unstableLayoutClassNames: layoutClassNames = ''
44043    } = useBlockEditContext();
44044    const selected = (0,external_wp_data_namespaceObject.useSelect)(select => {
44045      const {
44046        getBlockName,
44047        isZoomOut,
44048        getTemplateLock,
44049        getBlockRootClientId,
44050        getBlockEditingMode,
44051        getBlockSettings,
44052        getSectionRootClientId
44053      } = unlock(select(store));
44054      if (!clientId) {
44055        const sectionRootClientId = getSectionRootClientId();
44056        // Disable the root drop zone when zoomed out and the section root client id
44057        // is not the root block list (represented by an empty string).
44058        // This avoids drag handling bugs caused by having two block lists acting as
44059        // drop zones - the actual 'root' block list and the section root.
44060        return {
44061          isDropZoneDisabled: isZoomOut() && sectionRootClientId !== ''
44062        };
44063      }
44064      const {
44065        hasBlockSupport,
44066        getBlockType
44067      } = select(external_wp_blocks_namespaceObject.store);
44068      const blockName = getBlockName(clientId);
44069      const blockEditingMode = getBlockEditingMode(clientId);
44070      const parentClientId = getBlockRootClientId(clientId);
44071      const [defaultLayout] = getBlockSettings(clientId, 'layout');
44072      let _isDropZoneDisabled = blockEditingMode === 'disabled';
44073      if (isZoomOut()) {
44074        // In zoom out mode, we want to disable the drop zone for the sections.
44075        // The inner blocks belonging to the section drop zone is
44076        // already disabled by the blocks themselves being disabled.
44077        const sectionRootClientId = getSectionRootClientId();
44078        _isDropZoneDisabled = clientId !== sectionRootClientId;
44079      }
44080      return {
44081        __experimentalCaptureToolbars: hasBlockSupport(blockName, '__experimentalExposeControlsToChildren', false),
44082        name: blockName,
44083        blockType: getBlockType(blockName),
44084        parentLock: getTemplateLock(parentClientId),
44085        parentClientId,
44086        isDropZoneDisabled: _isDropZoneDisabled,
44087        defaultLayout
44088      };
44089    }, [clientId]);
44090    const {
44091      __experimentalCaptureToolbars,
44092      name,
44093      blockType,
44094      parentLock,
44095      parentClientId,
44096      isDropZoneDisabled,
44097      defaultLayout
44098    } = selected;
44099    const blockDropZoneRef = useBlockDropZone({
44100      dropZoneElement,
44101      rootClientId: clientId,
44102      parentClientId
44103    });
44104    const ref = (0,external_wp_compose_namespaceObject.useMergeRefs)([props.ref, __unstableDisableDropZone || isDropZoneDisabled || layout?.isManualPlacement && window.__experimentalEnableGridInteractivity ? null : blockDropZoneRef]);
44105    const innerBlocksProps = {
44106      __experimentalCaptureToolbars,
44107      layout,
44108      name,
44109      blockType,
44110      parentLock,
44111      defaultLayout,
44112      ...options
44113    };
44114    const InnerBlocks = innerBlocksProps.value && innerBlocksProps.onChange ? ControlledInnerBlocks : UncontrolledInnerBlocks;
44115    return {
44116      ...props,
44117      ref,
44118      className: dist_clsx(props.className, 'block-editor-block-list__layout', __unstableDisableLayoutClassNames ? '' : layoutClassNames),
44119      children: clientId ? /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(InnerBlocks, {
44120        ...innerBlocksProps,
44121        clientId: clientId
44122      }) : /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockListItems, {
44123        ...options
44124      })
44125    };
44126  }
44127  useInnerBlocksProps.save = external_wp_blocks_namespaceObject.__unstableGetInnerBlocksProps;
44128  
44129  // Expose default appender placeholders as components.
44130  ForwardedInnerBlocks.DefaultBlockAppender = default_block_appender_DefaultBlockAppender;
44131  ForwardedInnerBlocks.ButtonBlockAppender = ButtonBlockAppender;
44132  ForwardedInnerBlocks.Content = () => useInnerBlocksProps.save().children;
44133  
44134  /**
44135   * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/inner-blocks/README.md
44136   */
44137  /* harmony default export */ const inner_blocks = (ForwardedInnerBlocks);
44138  
44139  ;// ./node_modules/@wordpress/block-editor/build-module/components/observe-typing/index.js
44140  /**
44141   * WordPress dependencies
44142   */
44143  
44144  
44145  
44146  
44147  
44148  /**
44149   * Internal dependencies
44150   */
44151  
44152  
44153  /**
44154   * Set of key codes upon which typing is to be initiated on a keydown event.
44155   *
44156   * @type {Set<number>}
44157   */
44158  
44159  const KEY_DOWN_ELIGIBLE_KEY_CODES = new Set([external_wp_keycodes_namespaceObject.UP, external_wp_keycodes_namespaceObject.RIGHT, external_wp_keycodes_namespaceObject.DOWN, external_wp_keycodes_namespaceObject.LEFT, external_wp_keycodes_namespaceObject.ENTER, external_wp_keycodes_namespaceObject.BACKSPACE]);
44160  
44161  /**
44162   * Returns true if a given keydown event can be inferred as intent to start
44163   * typing, or false otherwise. A keydown is considered eligible if it is a
44164   * text navigation without shift active.
44165   *
44166   * @param {KeyboardEvent} event Keydown event to test.
44167   *
44168   * @return {boolean} Whether event is eligible to start typing.
44169   */
44170  function isKeyDownEligibleForStartTyping(event) {
44171    const {
44172      keyCode,
44173      shiftKey
44174    } = event;
44175    return !shiftKey && KEY_DOWN_ELIGIBLE_KEY_CODES.has(keyCode);
44176  }
44177  
44178  /**
44179   * Removes the `isTyping` flag when the mouse moves in the document of the given
44180   * element.
44181   */
44182  function useMouseMoveTypingReset() {
44183    const isTyping = (0,external_wp_data_namespaceObject.useSelect)(select => select(store).isTyping(), []);
44184    const {
44185      stopTyping
44186    } = (0,external_wp_data_namespaceObject.useDispatch)(store);
44187    return (0,external_wp_compose_namespaceObject.useRefEffect)(node => {
44188      if (!isTyping) {
44189        return;
44190      }
44191      const {
44192        ownerDocument
44193      } = node;
44194      let lastClientX;
44195      let lastClientY;
44196  
44197      /**
44198       * On mouse move, unset typing flag if user has moved cursor.
44199       *
44200       * @param {MouseEvent} event Mousemove event.
44201       */
44202      function stopTypingOnMouseMove(event) {
44203        const {
44204          clientX,
44205          clientY
44206        } = event;
44207  
44208        // We need to check that the mouse really moved because Safari
44209        // triggers mousemove events when shift or ctrl are pressed.
44210        if (lastClientX && lastClientY && (lastClientX !== clientX || lastClientY !== clientY)) {
44211          stopTyping();
44212        }
44213        lastClientX = clientX;
44214        lastClientY = clientY;
44215      }
44216      ownerDocument.addEventListener('mousemove', stopTypingOnMouseMove);
44217      return () => {
44218        ownerDocument.removeEventListener('mousemove', stopTypingOnMouseMove);
44219      };
44220    }, [isTyping, stopTyping]);
44221  }
44222  
44223  /**
44224   * Sets and removes the `isTyping` flag based on user actions:
44225   *
44226   * - Sets the flag if the user types within the given element.
44227   * - Removes the flag when the user selects some text, focuses a non-text
44228   *   field, presses ESC or TAB, or moves the mouse in the document.
44229   */
44230  function useTypingObserver() {
44231    const {
44232      isTyping
44233    } = (0,external_wp_data_namespaceObject.useSelect)(select => {
44234      const {
44235        isTyping: _isTyping
44236      } = select(store);
44237      return {
44238        isTyping: _isTyping()
44239      };
44240    }, []);
44241    const {
44242      startTyping,
44243      stopTyping
44244    } = (0,external_wp_data_namespaceObject.useDispatch)(store);
44245    const ref1 = useMouseMoveTypingReset();
44246    const ref2 = (0,external_wp_compose_namespaceObject.useRefEffect)(node => {
44247      const {
44248        ownerDocument
44249      } = node;
44250      const {
44251        defaultView
44252      } = ownerDocument;
44253      const selection = defaultView.getSelection();
44254  
44255      // Listeners to stop typing should only be added when typing.
44256      // Listeners to start typing should only be added when not typing.
44257      if (isTyping) {
44258        let timerId;
44259  
44260        /**
44261         * Stops typing when focus transitions to a non-text field element.
44262         *
44263         * @param {FocusEvent} event Focus event.
44264         */
44265        function stopTypingOnNonTextField(event) {
44266          const {
44267            target
44268          } = event;
44269  
44270          // Since focus to a non-text field via arrow key will trigger
44271          // before the keydown event, wait until after current stack
44272          // before evaluating whether typing is to be stopped. Otherwise,
44273          // typing will re-start.
44274          timerId = defaultView.setTimeout(() => {
44275            if (!(0,external_wp_dom_namespaceObject.isTextField)(target)) {
44276              stopTyping();
44277            }
44278          });
44279        }
44280  
44281        /**
44282         * Unsets typing flag if user presses Escape while typing flag is
44283         * active.
44284         *
44285         * @param {KeyboardEvent} event Keypress or keydown event to
44286         *                              interpret.
44287         */
44288        function stopTypingOnEscapeKey(event) {
44289          const {
44290            keyCode
44291          } = event;
44292          if (keyCode === external_wp_keycodes_namespaceObject.ESCAPE || keyCode === external_wp_keycodes_namespaceObject.TAB) {
44293            stopTyping();
44294          }
44295        }
44296  
44297        /**
44298         * On selection change, unset typing flag if user has made an
44299         * uncollapsed (shift) selection.
44300         */
44301        function stopTypingOnSelectionUncollapse() {
44302          if (!selection.isCollapsed) {
44303            stopTyping();
44304          }
44305        }
44306        node.addEventListener('focus', stopTypingOnNonTextField);
44307        node.addEventListener('keydown', stopTypingOnEscapeKey);
44308        ownerDocument.addEventListener('selectionchange', stopTypingOnSelectionUncollapse);
44309        return () => {
44310          defaultView.clearTimeout(timerId);
44311          node.removeEventListener('focus', stopTypingOnNonTextField);
44312          node.removeEventListener('keydown', stopTypingOnEscapeKey);
44313          ownerDocument.removeEventListener('selectionchange', stopTypingOnSelectionUncollapse);
44314        };
44315      }
44316  
44317      /**
44318       * Handles a keypress or keydown event to infer intention to start
44319       * typing.
44320       *
44321       * @param {KeyboardEvent} event Keypress or keydown event to interpret.
44322       */
44323      function startTypingInTextField(event) {
44324        const {
44325          type,
44326          target
44327        } = event;
44328  
44329        // Abort early if already typing, or key press is incurred outside a
44330        // text field (e.g. arrow-ing through toolbar buttons).
44331        // Ignore typing if outside the current DOM container
44332        if (!(0,external_wp_dom_namespaceObject.isTextField)(target) || !node.contains(target)) {
44333          return;
44334        }
44335  
44336        // Special-case keydown because certain keys do not emit a keypress
44337        // event. Conversely avoid keydown as the canonical event since
44338        // there are many keydown which are explicitly not targeted for
44339        // typing.
44340        if (type === 'keydown' && !isKeyDownEligibleForStartTyping(event)) {
44341          return;
44342        }
44343        startTyping();
44344      }
44345      node.addEventListener('keypress', startTypingInTextField);
44346      node.addEventListener('keydown', startTypingInTextField);
44347      return () => {
44348        node.removeEventListener('keypress', startTypingInTextField);
44349        node.removeEventListener('keydown', startTypingInTextField);
44350      };
44351    }, [isTyping, startTyping, stopTyping]);
44352    return (0,external_wp_compose_namespaceObject.useMergeRefs)([ref1, ref2]);
44353  }
44354  function ObserveTyping({
44355    children
44356  }) {
44357    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
44358      ref: useTypingObserver(),
44359      children: children
44360    });
44361  }
44362  
44363  /**
44364   * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/observe-typing/README.md
44365   */
44366  /* harmony default export */ const observe_typing = (ObserveTyping);
44367  
44368  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-list/zoom-out-separator.js
44369  /**
44370   * External dependencies
44371   */
44372  
44373  
44374  /**
44375   * WordPress dependencies
44376   */
44377  
44378  
44379  
44380  
44381  
44382  
44383  /**
44384   * Internal dependencies
44385   */
44386  
44387  
44388  
44389  function ZoomOutSeparator({
44390    clientId,
44391    rootClientId = '',
44392    position = 'top'
44393  }) {
44394    const [isDraggedOver, setIsDraggedOver] = (0,external_wp_element_namespaceObject.useState)(false);
44395    const {
44396      sectionRootClientId,
44397      sectionClientIds,
44398      insertionPoint,
44399      blockInsertionPointVisible,
44400      blockInsertionPoint,
44401      blocksBeingDragged
44402    } = (0,external_wp_data_namespaceObject.useSelect)(select => {
44403      const {
44404        getInsertionPoint,
44405        getBlockOrder,
44406        getSectionRootClientId,
44407        isBlockInsertionPointVisible,
44408        getBlockInsertionPoint,
44409        getDraggedBlockClientIds
44410      } = unlock(select(store));
44411      const root = getSectionRootClientId();
44412      const sectionRootClientIds = getBlockOrder(root);
44413      return {
44414        sectionRootClientId: root,
44415        sectionClientIds: sectionRootClientIds,
44416        blockOrder: getBlockOrder(root),
44417        insertionPoint: getInsertionPoint(),
44418        blockInsertionPoint: getBlockInsertionPoint(),
44419        blockInsertionPointVisible: isBlockInsertionPointVisible(),
44420        blocksBeingDragged: getDraggedBlockClientIds()
44421      };
44422    }, []);
44423    const isReducedMotion = (0,external_wp_compose_namespaceObject.useReducedMotion)();
44424    if (!clientId) {
44425      return;
44426    }
44427    let isVisible = false;
44428    const isSectionBlock = rootClientId === sectionRootClientId && sectionClientIds && sectionClientIds.includes(clientId);
44429    if (!isSectionBlock) {
44430      return null;
44431    }
44432    const hasTopInsertionPoint = insertionPoint?.index === 0 && clientId === sectionClientIds[insertionPoint.index];
44433    const hasBottomInsertionPoint = insertionPoint && insertionPoint.hasOwnProperty('index') && clientId === sectionClientIds[insertionPoint.index - 1];
44434  
44435    // We want to show the zoom out separator in either of these conditions:
44436    // 1. If the inserter has an insertion index set
44437    // 2. We are dragging a pattern over an insertion point
44438    if (position === 'top') {
44439      isVisible = hasTopInsertionPoint || blockInsertionPointVisible && blockInsertionPoint.index === 0 && clientId === sectionClientIds[blockInsertionPoint.index];
44440    }
44441    if (position === 'bottom') {
44442      isVisible = hasBottomInsertionPoint || blockInsertionPointVisible && clientId === sectionClientIds[blockInsertionPoint.index - 1];
44443    }
44444    const blockBeingDraggedClientId = blocksBeingDragged[0];
44445    const isCurrentBlockBeingDragged = blocksBeingDragged.includes(clientId);
44446    const blockBeingDraggedIndex = sectionClientIds.indexOf(blockBeingDraggedClientId);
44447    const blockBeingDraggedPreviousSiblingClientId = blockBeingDraggedIndex > 0 ? sectionClientIds[blockBeingDraggedIndex - 1] : null;
44448    const isCurrentBlockPreviousSiblingOfBlockBeingDragged = blockBeingDraggedPreviousSiblingClientId === clientId;
44449  
44450    // The separators are visually top/bottom of the block, but in actual fact
44451    // the "top" separator is the "bottom" separator of the previous block.
44452    // Therefore, this logic hides the separator if the current block is being dragged
44453    // or if the current block is the previous sibling of the block being dragged.
44454    if (isCurrentBlockBeingDragged || isCurrentBlockPreviousSiblingOfBlockBeingDragged) {
44455      isVisible = false;
44456    }
44457    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__unstableAnimatePresence, {
44458      children: isVisible && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__unstableMotion.div, {
44459        initial: {
44460          height: 0
44461        },
44462        animate: {
44463          // Use a height equal to that of the zoom out frame size.
44464          height: 'calc(1 * var(--wp-block-editor-iframe-zoom-out-frame-size) / var(--wp-block-editor-iframe-zoom-out-scale)'
44465        },
44466        exit: {
44467          height: 0
44468        },
44469        transition: {
44470          type: 'tween',
44471          duration: isReducedMotion ? 0 : 0.2,
44472          ease: [0.6, 0, 0.4, 1]
44473        },
44474        className: dist_clsx('block-editor-block-list__zoom-out-separator', {
44475          'is-dragged-over': isDraggedOver
44476        }),
44477        "data-is-insertion-point": "true",
44478        onDragOver: () => setIsDraggedOver(true),
44479        onDragLeave: () => setIsDraggedOver(false),
44480        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__unstableMotion.div, {
44481          initial: {
44482            opacity: 0
44483          },
44484          animate: {
44485            opacity: 1
44486          },
44487          exit: {
44488            opacity: 0,
44489            transition: {
44490              delay: -0.125
44491            }
44492          },
44493          transition: {
44494            ease: 'linear',
44495            duration: 0.1,
44496            delay: 0.125
44497          },
44498          children: (0,external_wp_i18n_namespaceObject.__)('Drop pattern.')
44499        })
44500      })
44501    });
44502  }
44503  
44504  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-list/index.js
44505  /**
44506   * External dependencies
44507   */
44508  
44509  
44510  /**
44511   * WordPress dependencies
44512   */
44513  
44514  
44515  
44516  
44517  
44518  /**
44519   * Internal dependencies
44520   */
44521  
44522  
44523  
44524  
44525  
44526  
44527  
44528  
44529  
44530  
44531  
44532  
44533  const block_list_IntersectionObserver = (0,external_wp_element_namespaceObject.createContext)();
44534  const pendingBlockVisibilityUpdatesPerRegistry = new WeakMap();
44535  function Root({
44536    className,
44537    ...settings
44538  }) {
44539    const {
44540      isOutlineMode,
44541      isFocusMode,
44542      temporarilyEditingAsBlocks
44543    } = (0,external_wp_data_namespaceObject.useSelect)(select => {
44544      const {
44545        getSettings,
44546        getTemporarilyEditingAsBlocks,
44547        isTyping
44548      } = unlock(select(store));
44549      const {
44550        outlineMode,
44551        focusMode
44552      } = getSettings();
44553      return {
44554        isOutlineMode: outlineMode && !isTyping(),
44555        isFocusMode: focusMode,
44556        temporarilyEditingAsBlocks: getTemporarilyEditingAsBlocks()
44557      };
44558    }, []);
44559    const registry = (0,external_wp_data_namespaceObject.useRegistry)();
44560    const {
44561      setBlockVisibility
44562    } = (0,external_wp_data_namespaceObject.useDispatch)(store);
44563    const delayedBlockVisibilityUpdates = (0,external_wp_compose_namespaceObject.useDebounce)((0,external_wp_element_namespaceObject.useCallback)(() => {
44564      const updates = {};
44565      pendingBlockVisibilityUpdatesPerRegistry.get(registry).forEach(([id, isIntersecting]) => {
44566        updates[id] = isIntersecting;
44567      });
44568      setBlockVisibility(updates);
44569    }, [registry]), 300, {
44570      trailing: true
44571    });
44572    const intersectionObserver = (0,external_wp_element_namespaceObject.useMemo)(() => {
44573      const {
44574        IntersectionObserver: Observer
44575      } = window;
44576      if (!Observer) {
44577        return;
44578      }
44579      return new Observer(entries => {
44580        if (!pendingBlockVisibilityUpdatesPerRegistry.get(registry)) {
44581          pendingBlockVisibilityUpdatesPerRegistry.set(registry, []);
44582        }
44583        for (const entry of entries) {
44584          const clientId = entry.target.getAttribute('data-block');
44585          pendingBlockVisibilityUpdatesPerRegistry.get(registry).push([clientId, entry.isIntersecting]);
44586        }
44587        delayedBlockVisibilityUpdates();
44588      });
44589    }, []);
44590    const innerBlocksProps = useInnerBlocksProps({
44591      ref: (0,external_wp_compose_namespaceObject.useMergeRefs)([useBlockSelectionClearer(), useInBetweenInserter(), useTypingObserver()]),
44592      className: dist_clsx('is-root-container', className, {
44593        'is-outline-mode': isOutlineMode,
44594        'is-focus-mode': isFocusMode
44595      })
44596    }, settings);
44597    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(block_list_IntersectionObserver.Provider, {
44598      value: intersectionObserver,
44599      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
44600        ...innerBlocksProps
44601      }), !!temporarilyEditingAsBlocks && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(StopEditingAsBlocksOnOutsideSelect, {
44602        clientId: temporarilyEditingAsBlocks
44603      })]
44604    });
44605  }
44606  function StopEditingAsBlocksOnOutsideSelect({
44607    clientId
44608  }) {
44609    const {
44610      stopEditingAsBlocks
44611    } = unlock((0,external_wp_data_namespaceObject.useDispatch)(store));
44612    const isBlockOrDescendantSelected = (0,external_wp_data_namespaceObject.useSelect)(select => {
44613      const {
44614        isBlockSelected,
44615        hasSelectedInnerBlock
44616      } = select(store);
44617      return isBlockSelected(clientId) || hasSelectedInnerBlock(clientId, true);
44618    }, [clientId]);
44619    (0,external_wp_element_namespaceObject.useEffect)(() => {
44620      if (!isBlockOrDescendantSelected) {
44621        stopEditingAsBlocks(clientId);
44622      }
44623    }, [isBlockOrDescendantSelected, clientId, stopEditingAsBlocks]);
44624    return null;
44625  }
44626  function BlockList(settings) {
44627    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Provider, {
44628      value: DEFAULT_BLOCK_EDIT_CONTEXT,
44629      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Root, {
44630        ...settings
44631      })
44632    });
44633  }
44634  const block_list_EMPTY_ARRAY = [];
44635  const block_list_EMPTY_SET = new Set();
44636  function Items({
44637    placeholder,
44638    rootClientId,
44639    renderAppender: CustomAppender,
44640    __experimentalAppenderTagName,
44641    layout = defaultLayout
44642  }) {
44643    // Avoid passing CustomAppender to useSelect because it could be a new
44644    // function on every render.
44645    const hasAppender = CustomAppender !== false;
44646    const hasCustomAppender = !!CustomAppender;
44647    const {
44648      order,
44649      isZoomOut,
44650      selectedBlocks,
44651      visibleBlocks,
44652      shouldRenderAppender
44653    } = (0,external_wp_data_namespaceObject.useSelect)(select => {
44654      const {
44655        getSettings,
44656        getBlockOrder,
44657        getSelectedBlockClientIds,
44658        __unstableGetVisibleBlocks,
44659        getTemplateLock,
44660        getBlockEditingMode,
44661        isSectionBlock,
44662        isZoomOut: _isZoomOut,
44663        canInsertBlockType
44664      } = unlock(select(store));
44665      const _order = getBlockOrder(rootClientId);
44666      if (getSettings().isPreviewMode) {
44667        return {
44668          order: _order,
44669          selectedBlocks: block_list_EMPTY_ARRAY,
44670          visibleBlocks: block_list_EMPTY_SET
44671        };
44672      }
44673      const selectedBlockClientIds = getSelectedBlockClientIds();
44674      const selectedBlockClientId = selectedBlockClientIds[0];
44675      const showRootAppender = !rootClientId && !selectedBlockClientId && (!_order.length || !canInsertBlockType((0,external_wp_blocks_namespaceObject.getDefaultBlockName)(), rootClientId));
44676      const hasSelectedRoot = !!(rootClientId && selectedBlockClientId && rootClientId === selectedBlockClientId);
44677      return {
44678        order: _order,
44679        selectedBlocks: selectedBlockClientIds,
44680        visibleBlocks: __unstableGetVisibleBlocks(),
44681        isZoomOut: _isZoomOut(),
44682        shouldRenderAppender: !isSectionBlock(rootClientId) && getBlockEditingMode(rootClientId) !== 'disabled' && !getTemplateLock(rootClientId) && hasAppender && !_isZoomOut() && (hasCustomAppender || hasSelectedRoot || showRootAppender)
44683      };
44684    }, [rootClientId, hasAppender, hasCustomAppender]);
44685    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(LayoutProvider, {
44686      value: layout,
44687      children: [order.map(clientId => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_data_namespaceObject.AsyncModeProvider, {
44688        value:
44689        // Only provide data asynchronously if the block is
44690        // not visible and not selected.
44691        !visibleBlocks.has(clientId) && !selectedBlocks.includes(clientId),
44692        children: [isZoomOut && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ZoomOutSeparator, {
44693          clientId: clientId,
44694          rootClientId: rootClientId,
44695          position: "top"
44696        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block, {
44697          rootClientId: rootClientId,
44698          clientId: clientId
44699        }), isZoomOut && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ZoomOutSeparator, {
44700          clientId: clientId,
44701          rootClientId: rootClientId,
44702          position: "bottom"
44703        })]
44704      }, clientId)), order.length < 1 && placeholder, shouldRenderAppender && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockListAppender, {
44705        tagName: __experimentalAppenderTagName,
44706        rootClientId: rootClientId,
44707        CustomAppender: CustomAppender
44708      })]
44709    });
44710  }
44711  function BlockListItems(props) {
44712    // This component needs to always be synchronous as it's the one changing
44713    // the async mode depending on the block selection.
44714    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_data_namespaceObject.AsyncModeProvider, {
44715      value: false,
44716      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Items, {
44717        ...props
44718      })
44719    });
44720  }
44721  
44722  ;// ./node_modules/@wordpress/block-editor/build-module/components/writing-flow/use-multi-selection.js
44723  /**
44724   * WordPress dependencies
44725   */
44726  
44727  
44728  
44729  /**
44730   * Internal dependencies
44731   */
44732  
44733  function selector(select) {
44734    const {
44735      isMultiSelecting,
44736      getMultiSelectedBlockClientIds,
44737      hasMultiSelection,
44738      getSelectedBlockClientId,
44739      getSelectedBlocksInitialCaretPosition,
44740      __unstableIsFullySelected
44741    } = select(store);
44742    return {
44743      isMultiSelecting: isMultiSelecting(),
44744      multiSelectedBlockClientIds: getMultiSelectedBlockClientIds(),
44745      hasMultiSelection: hasMultiSelection(),
44746      selectedBlockClientId: getSelectedBlockClientId(),
44747      initialPosition: getSelectedBlocksInitialCaretPosition(),
44748      isFullSelection: __unstableIsFullySelected()
44749    };
44750  }
44751  function useMultiSelection() {
44752    const {
44753      initialPosition,
44754      isMultiSelecting,
44755      multiSelectedBlockClientIds,
44756      hasMultiSelection,
44757      selectedBlockClientId,
44758      isFullSelection
44759    } = (0,external_wp_data_namespaceObject.useSelect)(selector, []);
44760  
44761    /**
44762     * When the component updates, and there is multi selection, we need to
44763     * select the entire block contents.
44764     */
44765    return (0,external_wp_compose_namespaceObject.useRefEffect)(node => {
44766      const {
44767        ownerDocument
44768      } = node;
44769      const {
44770        defaultView
44771      } = ownerDocument;
44772  
44773      // Allow initialPosition to bypass focus behavior. This is useful
44774      // for the list view or other areas where we don't want to transfer
44775      // focus to the editor canvas.
44776      if (initialPosition === undefined || initialPosition === null) {
44777        return;
44778      }
44779      if (!hasMultiSelection || isMultiSelecting) {
44780        return;
44781      }
44782      const {
44783        length
44784      } = multiSelectedBlockClientIds;
44785      if (length < 2) {
44786        return;
44787      }
44788      if (!isFullSelection) {
44789        return;
44790      }
44791  
44792      // Allow cross contentEditable selection by temporarily making
44793      // all content editable. We can't rely on using the store and
44794      // React because re-rending happens too slowly. We need to be
44795      // able to select across instances immediately.
44796      node.contentEditable = true;
44797  
44798      // For some browsers, like Safari, it is important that focus
44799      // happens BEFORE selection removal.
44800      node.focus();
44801      defaultView.getSelection().removeAllRanges();
44802    }, [hasMultiSelection, isMultiSelecting, multiSelectedBlockClientIds, selectedBlockClientId, initialPosition, isFullSelection]);
44803  }
44804  
44805  ;// ./node_modules/@wordpress/block-editor/build-module/components/writing-flow/use-tab-nav.js
44806  /**
44807   * WordPress dependencies
44808   */
44809  
44810  
44811  
44812  
44813  
44814  
44815  /**
44816   * Internal dependencies
44817   */
44818  
44819  
44820  
44821  
44822  function useTabNav() {
44823    const containerRef = /** @type {typeof useRef<HTMLElement>} */(0,external_wp_element_namespaceObject.useRef)();
44824    const focusCaptureBeforeRef = (0,external_wp_element_namespaceObject.useRef)();
44825    const focusCaptureAfterRef = (0,external_wp_element_namespaceObject.useRef)();
44826    const {
44827      hasMultiSelection,
44828      getSelectedBlockClientId,
44829      getBlockCount,
44830      getBlockOrder,
44831      getLastFocus,
44832      getSectionRootClientId,
44833      isZoomOut
44834    } = unlock((0,external_wp_data_namespaceObject.useSelect)(store));
44835    const {
44836      setLastFocus
44837    } = unlock((0,external_wp_data_namespaceObject.useDispatch)(store));
44838  
44839    // Reference that holds the a flag for enabling or disabling
44840    // capturing on the focus capture elements.
44841    const noCaptureRef = (0,external_wp_element_namespaceObject.useRef)();
44842    function onFocusCapture(event) {
44843      const canvasElement = containerRef.current.ownerDocument === event.target.ownerDocument ? containerRef.current : containerRef.current.ownerDocument.defaultView.frameElement;
44844  
44845      // Do not capture incoming focus if set by us in WritingFlow.
44846      if (noCaptureRef.current) {
44847        noCaptureRef.current = null;
44848      } else if (hasMultiSelection()) {
44849        containerRef.current.focus();
44850      } else if (getSelectedBlockClientId()) {
44851        if (getLastFocus()?.current) {
44852          getLastFocus().current.focus();
44853        } else {
44854          // Handles when the last focus has not been set yet, or has been cleared by new blocks being added via the inserter.
44855          containerRef.current.querySelector(`[data-block="$getSelectedBlockClientId()}"]`).focus();
44856        }
44857      }
44858      // In "compose" mode without a selected ID, we want to place focus on the section root when tabbing to the canvas.
44859      else if (isZoomOut()) {
44860        const sectionRootClientId = getSectionRootClientId();
44861        const sectionBlocks = getBlockOrder(sectionRootClientId);
44862  
44863        // If we have section within the section root, focus the first one.
44864        if (sectionBlocks.length) {
44865          containerRef.current.querySelector(`[data-block="$sectionBlocks[0]}"]`).focus();
44866        }
44867        // If we don't have any section blocks, focus the section root.
44868        else if (sectionRootClientId) {
44869          containerRef.current.querySelector(`[data-block="$sectionRootClientId}"]`).focus();
44870        } else {
44871          // If we don't have any section root, focus the canvas.
44872          canvasElement.focus();
44873        }
44874      } else {
44875        const isBefore =
44876        // eslint-disable-next-line no-bitwise
44877        event.target.compareDocumentPosition(canvasElement) & event.target.DOCUMENT_POSITION_FOLLOWING;
44878        const tabbables = external_wp_dom_namespaceObject.focus.tabbable.find(containerRef.current);
44879        if (tabbables.length) {
44880          const next = isBefore ? tabbables[0] : tabbables[tabbables.length - 1];
44881          next.focus();
44882        }
44883      }
44884    }
44885    const before = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
44886      ref: focusCaptureBeforeRef,
44887      tabIndex: "0",
44888      onFocus: onFocusCapture
44889    });
44890    const after = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
44891      ref: focusCaptureAfterRef,
44892      tabIndex: "0",
44893      onFocus: onFocusCapture
44894    });
44895    const ref = (0,external_wp_compose_namespaceObject.useRefEffect)(node => {
44896      function onKeyDown(event) {
44897        if (event.defaultPrevented) {
44898          return;
44899        }
44900  
44901        // In Edit mode, Tab should focus the first tabbable element after
44902        // the content, which is normally the sidebar (with block controls)
44903        // and Shift+Tab should focus the first tabbable element before the
44904        // content, which is normally the block toolbar.
44905        // Arrow keys can be used, and Tab and arrow keys can be used in
44906        // Navigation mode (press Esc), to navigate through blocks.
44907        if (event.keyCode !== external_wp_keycodes_namespaceObject.TAB) {
44908          return;
44909        }
44910        if (
44911        // Bails in case the focus capture elements aren’t present. They
44912        // may be omitted to avoid silent tab stops in preview mode.
44913        // See: https://github.com/WordPress/gutenberg/pull/59317
44914        !focusCaptureAfterRef.current || !focusCaptureBeforeRef.current) {
44915          return;
44916        }
44917        const {
44918          target,
44919          shiftKey: isShift
44920        } = event;
44921        const direction = isShift ? 'findPrevious' : 'findNext';
44922        const nextTabbable = external_wp_dom_namespaceObject.focus.tabbable[direction](target);
44923  
44924        // We want to constrain the tabbing to the block and its child blocks.
44925        // If the preceding form element is within a different block,
44926        // such as two sibling image blocks in the placeholder state,
44927        // we want shift + tab from the first form element to move to the image
44928        // block toolbar and not the previous image block's form element.
44929        const currentBlock = target.closest('[data-block]');
44930        const isElementPartOfSelectedBlock = currentBlock && nextTabbable && (isInSameBlock(currentBlock, nextTabbable) || isInsideRootBlock(currentBlock, nextTabbable));
44931  
44932        // Allow tabbing from the block wrapper to a form element,
44933        // and between form elements rendered in a block and its child blocks,
44934        // such as inside a placeholder. Form elements are generally
44935        // meant to be UI rather than part of the content. Ideally
44936        // these are not rendered in the content and perhaps in the
44937        // future they can be rendered in an iframe or shadow DOM.
44938        if ((0,external_wp_dom_namespaceObject.isFormElement)(nextTabbable) && isElementPartOfSelectedBlock) {
44939          return;
44940        }
44941        const next = isShift ? focusCaptureBeforeRef : focusCaptureAfterRef;
44942  
44943        // Disable focus capturing on the focus capture element, so it
44944        // doesn't refocus this block and so it allows default behaviour
44945        // (moving focus to the next tabbable element).
44946        noCaptureRef.current = true;
44947  
44948        // Focusing the focus capture element, which is located above and
44949        // below the editor, should not scroll the page all the way up or
44950        // down.
44951        next.current.focus({
44952          preventScroll: true
44953        });
44954      }
44955      function onFocusOut(event) {
44956        setLastFocus({
44957          ...getLastFocus(),
44958          current: event.target
44959        });
44960        const {
44961          ownerDocument
44962        } = node;
44963  
44964        // If focus disappears due to there being no blocks, move focus to
44965        // the writing flow wrapper.
44966        if (!event.relatedTarget && event.target.hasAttribute('data-block') && ownerDocument.activeElement === ownerDocument.body && getBlockCount() === 0) {
44967          node.focus();
44968        }
44969      }
44970  
44971      // When tabbing back to an element in block list, this event handler prevents scrolling if the
44972      // focus capture divs (before/after) are outside of the viewport. (For example shift+tab back to a paragraph
44973      // when focus is on a sidebar element. This prevents the scrollable writing area from jumping either to the
44974      // top or bottom of the document.
44975      //
44976      // Note that it isn't possible to disable scrolling in the onFocus event. We need to intercept this
44977      // earlier in the keypress handler, and call focus( { preventScroll: true } ) instead.
44978      // https://developer.mozilla.org/en-US/docs/Web/API/HTMLOrForeignElement/focus#parameters
44979      function preventScrollOnTab(event) {
44980        if (event.keyCode !== external_wp_keycodes_namespaceObject.TAB) {
44981          return;
44982        }
44983        if (event.target?.getAttribute('role') === 'region') {
44984          return;
44985        }
44986        if (containerRef.current === event.target) {
44987          return;
44988        }
44989        const isShift = event.shiftKey;
44990        const direction = isShift ? 'findPrevious' : 'findNext';
44991        const target = external_wp_dom_namespaceObject.focus.tabbable[direction](event.target);
44992        // Only do something when the next tabbable is a focus capture div (before/after)
44993        if (target === focusCaptureBeforeRef.current || target === focusCaptureAfterRef.current) {
44994          event.preventDefault();
44995          target.focus({
44996            preventScroll: true
44997          });
44998        }
44999      }
45000      const {
45001        ownerDocument
45002      } = node;
45003      const {
45004        defaultView
45005      } = ownerDocument;
45006      defaultView.addEventListener('keydown', preventScrollOnTab);
45007      node.addEventListener('keydown', onKeyDown);
45008      node.addEventListener('focusout', onFocusOut);
45009      return () => {
45010        defaultView.removeEventListener('keydown', preventScrollOnTab);
45011        node.removeEventListener('keydown', onKeyDown);
45012        node.removeEventListener('focusout', onFocusOut);
45013      };
45014    }, []);
45015    const mergedRefs = (0,external_wp_compose_namespaceObject.useMergeRefs)([containerRef, ref]);
45016    return [before, mergedRefs, after];
45017  }
45018  
45019  ;// ./node_modules/@wordpress/block-editor/build-module/components/writing-flow/use-arrow-nav.js
45020  /**
45021   * WordPress dependencies
45022   */
45023  
45024  
45025  
45026  
45027  
45028  /**
45029   * Internal dependencies
45030   */
45031  
45032  
45033  
45034  /**
45035   * Returns true if the element should consider edge navigation upon a keyboard
45036   * event of the given directional key code, or false otherwise.
45037   *
45038   * @param {Element} element     HTML element to test.
45039   * @param {number}  keyCode     KeyboardEvent keyCode to test.
45040   * @param {boolean} hasModifier Whether a modifier is pressed.
45041   *
45042   * @return {boolean} Whether element should consider edge navigation.
45043   */
45044  function isNavigationCandidate(element, keyCode, hasModifier) {
45045    const isVertical = keyCode === external_wp_keycodes_namespaceObject.UP || keyCode === external_wp_keycodes_namespaceObject.DOWN;
45046    const {
45047      tagName
45048    } = element;
45049    const elementType = element.getAttribute('type');
45050  
45051    // Native inputs should not navigate vertically, unless they are simple types that don't need up/down arrow keys.
45052    if (isVertical && !hasModifier) {
45053      if (tagName === 'INPUT') {
45054        const verticalInputTypes = ['date', 'datetime-local', 'month', 'number', 'range', 'time', 'week'];
45055        return !verticalInputTypes.includes(elementType);
45056      }
45057      return true;
45058    }
45059  
45060    // Native inputs should not navigate horizontally, unless they are simple types that don't need left/right arrow keys.
45061    if (tagName === 'INPUT') {
45062      const simpleInputTypes = ['button', 'checkbox', 'number', 'color', 'file', 'image', 'radio', 'reset', 'submit'];
45063      return simpleInputTypes.includes(elementType);
45064    }
45065  
45066    // Native textareas should not navigate horizontally.
45067    return tagName !== 'TEXTAREA';
45068  }
45069  
45070  /**
45071   * Returns the optimal tab target from the given focused element in the desired
45072   * direction. A preference is made toward text fields, falling back to the block
45073   * focus stop if no other candidates exist for the block.
45074   *
45075   * @param {Element} target           Currently focused text field.
45076   * @param {boolean} isReverse        True if considering as the first field.
45077   * @param {Element} containerElement Element containing all blocks.
45078   * @param {boolean} onlyVertical     Whether to only consider tabbable elements
45079   *                                   that are visually above or under the
45080   *                                   target.
45081   *
45082   * @return {?Element} Optimal tab target, if one exists.
45083   */
45084  function getClosestTabbable(target, isReverse, containerElement, onlyVertical) {
45085    // Since the current focus target is not guaranteed to be a text field, find
45086    // all focusables. Tabbability is considered later.
45087    let focusableNodes = external_wp_dom_namespaceObject.focus.focusable.find(containerElement);
45088    if (isReverse) {
45089      focusableNodes.reverse();
45090    }
45091  
45092    // Consider as candidates those focusables after the current target. It's
45093    // assumed this can only be reached if the target is focusable (on its
45094    // keydown event), so no need to verify it exists in the set.
45095    focusableNodes = focusableNodes.slice(focusableNodes.indexOf(target) + 1);
45096    let targetRect;
45097    if (onlyVertical) {
45098      targetRect = target.getBoundingClientRect();
45099    }
45100    function isTabCandidate(node) {
45101      if (node.closest('[inert]')) {
45102        return;
45103      }
45104  
45105      // Skip if there's only one child that is content editable (and thus a
45106      // better candidate).
45107      if (node.children.length === 1 && isInSameBlock(node, node.firstElementChild) && node.firstElementChild.getAttribute('contenteditable') === 'true') {
45108        return;
45109      }
45110  
45111      // Not a candidate if the node is not tabbable.
45112      if (!external_wp_dom_namespaceObject.focus.tabbable.isTabbableIndex(node)) {
45113        return false;
45114      }
45115  
45116      // Skip focusable elements such as links within content editable nodes.
45117      if (node.isContentEditable && node.contentEditable !== 'true') {
45118        return false;
45119      }
45120      if (onlyVertical) {
45121        const nodeRect = node.getBoundingClientRect();
45122        if (nodeRect.left >= targetRect.right || nodeRect.right <= targetRect.left) {
45123          return false;
45124        }
45125      }
45126      return true;
45127    }
45128    return focusableNodes.find(isTabCandidate);
45129  }
45130  function useArrowNav() {
45131    const {
45132      getMultiSelectedBlocksStartClientId,
45133      getMultiSelectedBlocksEndClientId,
45134      getSettings,
45135      hasMultiSelection,
45136      __unstableIsFullySelected
45137    } = (0,external_wp_data_namespaceObject.useSelect)(store);
45138    const {
45139      selectBlock
45140    } = (0,external_wp_data_namespaceObject.useDispatch)(store);
45141    return (0,external_wp_compose_namespaceObject.useRefEffect)(node => {
45142      // Here a DOMRect is stored while moving the caret vertically so
45143      // vertical position of the start position can be restored. This is to
45144      // recreate browser behaviour across blocks.
45145      let verticalRect;
45146      function onMouseDown() {
45147        verticalRect = null;
45148      }
45149      function isClosestTabbableABlock(target, isReverse) {
45150        const closestTabbable = getClosestTabbable(target, isReverse, node);
45151        return closestTabbable && getBlockClientId(closestTabbable);
45152      }
45153      function onKeyDown(event) {
45154        // Abort if navigation has already been handled (e.g. RichText
45155        // inline boundaries).
45156        if (event.defaultPrevented) {
45157          return;
45158        }
45159        const {
45160          keyCode,
45161          target,
45162          shiftKey,
45163          ctrlKey,
45164          altKey,
45165          metaKey
45166        } = event;
45167        const isUp = keyCode === external_wp_keycodes_namespaceObject.UP;
45168        const isDown = keyCode === external_wp_keycodes_namespaceObject.DOWN;
45169        const isLeft = keyCode === external_wp_keycodes_namespaceObject.LEFT;
45170        const isRight = keyCode === external_wp_keycodes_namespaceObject.RIGHT;
45171        const isReverse = isUp || isLeft;
45172        const isHorizontal = isLeft || isRight;
45173        const isVertical = isUp || isDown;
45174        const isNav = isHorizontal || isVertical;
45175        const hasModifier = shiftKey || ctrlKey || altKey || metaKey;
45176        const isNavEdge = isVertical ? external_wp_dom_namespaceObject.isVerticalEdge : external_wp_dom_namespaceObject.isHorizontalEdge;
45177        const {
45178          ownerDocument
45179        } = node;
45180        const {
45181          defaultView
45182        } = ownerDocument;
45183        if (!isNav) {
45184          return;
45185        }
45186  
45187        // If there is a multi-selection, the arrow keys should collapse the
45188        // selection to the start or end of the selection.
45189        if (hasMultiSelection()) {
45190          if (shiftKey) {
45191            return;
45192          }
45193  
45194          // Only handle if we have a full selection (not a native partial
45195          // selection).
45196          if (!__unstableIsFullySelected()) {
45197            return;
45198          }
45199          event.preventDefault();
45200          if (isReverse) {
45201            selectBlock(getMultiSelectedBlocksStartClientId());
45202          } else {
45203            selectBlock(getMultiSelectedBlocksEndClientId(), -1);
45204          }
45205          return;
45206        }
45207  
45208        // Abort if our current target is not a candidate for navigation
45209        // (e.g. preserve native input behaviors).
45210        if (!isNavigationCandidate(target, keyCode, hasModifier)) {
45211          return;
45212        }
45213  
45214        // When presing any key other than up or down, the initial vertical
45215        // position must ALWAYS be reset. The vertical position is saved so
45216        // it can be restored as well as possible on sebsequent vertical
45217        // arrow key presses. It may not always be possible to restore the
45218        // exact same position (such as at an empty line), so it wouldn't be
45219        // good to compute the position right before any vertical arrow key
45220        // press.
45221        if (!isVertical) {
45222          verticalRect = null;
45223        } else if (!verticalRect) {
45224          verticalRect = (0,external_wp_dom_namespaceObject.computeCaretRect)(defaultView);
45225        }
45226  
45227        // In the case of RTL scripts, right means previous and left means
45228        // next, which is the exact reverse of LTR.
45229        const isReverseDir = (0,external_wp_dom_namespaceObject.isRTL)(target) ? !isReverse : isReverse;
45230        const {
45231          keepCaretInsideBlock
45232        } = getSettings();
45233        if (shiftKey) {
45234          if (isClosestTabbableABlock(target, isReverse) && isNavEdge(target, isReverse)) {
45235            node.contentEditable = true;
45236            // Firefox doesn't automatically move focus.
45237            node.focus();
45238          }
45239        } else if (isVertical && (0,external_wp_dom_namespaceObject.isVerticalEdge)(target, isReverse) && (
45240        // When Alt is pressed, only intercept if the caret is also at
45241        // the horizontal edge.
45242        altKey ? (0,external_wp_dom_namespaceObject.isHorizontalEdge)(target, isReverseDir) : true) && !keepCaretInsideBlock) {
45243          const closestTabbable = getClosestTabbable(target, isReverse, node, true);
45244          if (closestTabbable) {
45245            (0,external_wp_dom_namespaceObject.placeCaretAtVerticalEdge)(closestTabbable,
45246            // When Alt is pressed, place the caret at the furthest
45247            // horizontal edge and the furthest vertical edge.
45248            altKey ? !isReverse : isReverse, altKey ? undefined : verticalRect);
45249            event.preventDefault();
45250          }
45251        } else if (isHorizontal && defaultView.getSelection().isCollapsed && (0,external_wp_dom_namespaceObject.isHorizontalEdge)(target, isReverseDir) && !keepCaretInsideBlock) {
45252          const closestTabbable = getClosestTabbable(target, isReverseDir, node);
45253          (0,external_wp_dom_namespaceObject.placeCaretAtHorizontalEdge)(closestTabbable, isReverse);
45254          event.preventDefault();
45255        }
45256      }
45257      node.addEventListener('mousedown', onMouseDown);
45258      node.addEventListener('keydown', onKeyDown);
45259      return () => {
45260        node.removeEventListener('mousedown', onMouseDown);
45261        node.removeEventListener('keydown', onKeyDown);
45262      };
45263    }, []);
45264  }
45265  
45266  ;// ./node_modules/@wordpress/block-editor/build-module/components/writing-flow/use-select-all.js
45267  /**
45268   * WordPress dependencies
45269   */
45270  
45271  
45272  
45273  
45274  
45275  /**
45276   * Internal dependencies
45277   */
45278  
45279  function useSelectAll() {
45280    const {
45281      getBlockOrder,
45282      getSelectedBlockClientIds,
45283      getBlockRootClientId
45284    } = (0,external_wp_data_namespaceObject.useSelect)(store);
45285    const {
45286      multiSelect,
45287      selectBlock
45288    } = (0,external_wp_data_namespaceObject.useDispatch)(store);
45289    const isMatch = (0,external_wp_keyboardShortcuts_namespaceObject.__unstableUseShortcutEventMatch)();
45290    return (0,external_wp_compose_namespaceObject.useRefEffect)(node => {
45291      function onKeyDown(event) {
45292        if (!isMatch('core/block-editor/select-all', event)) {
45293          return;
45294        }
45295        const selectedClientIds = getSelectedBlockClientIds();
45296        if (selectedClientIds.length < 2 && !(0,external_wp_dom_namespaceObject.isEntirelySelected)(event.target)) {
45297          return;
45298        }
45299        event.preventDefault();
45300        const [firstSelectedClientId] = selectedClientIds;
45301        const rootClientId = getBlockRootClientId(firstSelectedClientId);
45302        const blockClientIds = getBlockOrder(rootClientId);
45303  
45304        // If we have selected all sibling nested blocks, try selecting up a
45305        // level. See: https://github.com/WordPress/gutenberg/pull/31859/
45306        if (selectedClientIds.length === blockClientIds.length) {
45307          if (rootClientId) {
45308            node.ownerDocument.defaultView.getSelection().removeAllRanges();
45309            selectBlock(rootClientId);
45310          }
45311          return;
45312        }
45313        multiSelect(blockClientIds[0], blockClientIds[blockClientIds.length - 1]);
45314      }
45315      node.addEventListener('keydown', onKeyDown);
45316      return () => {
45317        node.removeEventListener('keydown', onKeyDown);
45318      };
45319    }, []);
45320  }
45321  
45322  ;// ./node_modules/@wordpress/block-editor/build-module/components/writing-flow/use-drag-selection.js
45323  /**
45324   * WordPress dependencies
45325   */
45326  
45327  
45328  
45329  /**
45330   * Internal dependencies
45331   */
45332  
45333  
45334  /**
45335   * Sets the `contenteditable` wrapper element to `value`.
45336   *
45337   * @param {HTMLElement} node  Block element.
45338   * @param {boolean}     value `contentEditable` value (true or false)
45339   */
45340  function setContentEditableWrapper(node, value) {
45341    node.contentEditable = value;
45342    // Firefox doesn't automatically move focus.
45343    if (value) {
45344      node.focus();
45345    }
45346  }
45347  
45348  /**
45349   * Sets a multi-selection based on the native selection across blocks.
45350   */
45351  function useDragSelection() {
45352    const {
45353      startMultiSelect,
45354      stopMultiSelect
45355    } = (0,external_wp_data_namespaceObject.useDispatch)(store);
45356    const {
45357      isSelectionEnabled,
45358      hasSelectedBlock,
45359      isDraggingBlocks,
45360      isMultiSelecting
45361    } = (0,external_wp_data_namespaceObject.useSelect)(store);
45362    return (0,external_wp_compose_namespaceObject.useRefEffect)(node => {
45363      const {
45364        ownerDocument
45365      } = node;
45366      const {
45367        defaultView
45368      } = ownerDocument;
45369      let anchorElement;
45370      let rafId;
45371      function onMouseUp() {
45372        stopMultiSelect();
45373        // Equivalent to attaching the listener once.
45374        defaultView.removeEventListener('mouseup', onMouseUp);
45375        // The browser selection won't have updated yet at this point,
45376        // so wait until the next animation frame to get the browser
45377        // selection.
45378        rafId = defaultView.requestAnimationFrame(() => {
45379          if (!hasSelectedBlock()) {
45380            return;
45381          }
45382  
45383          // If the selection is complete (on mouse up), and no
45384          // multiple blocks have been selected, set focus back to the
45385          // anchor element. if the anchor element contains the
45386          // selection. Additionally, the contentEditable wrapper can
45387          // now be disabled again.
45388          setContentEditableWrapper(node, false);
45389          const selection = defaultView.getSelection();
45390          if (selection.rangeCount) {
45391            const range = selection.getRangeAt(0);
45392            const {
45393              commonAncestorContainer
45394            } = range;
45395            const clonedRange = range.cloneRange();
45396            if (anchorElement.contains(commonAncestorContainer)) {
45397              anchorElement.focus();
45398              selection.removeAllRanges();
45399              selection.addRange(clonedRange);
45400            }
45401          }
45402        });
45403      }
45404      let lastMouseDownTarget;
45405      function onMouseDown({
45406        target
45407      }) {
45408        lastMouseDownTarget = target;
45409      }
45410      function onMouseLeave({
45411        buttons,
45412        target,
45413        relatedTarget
45414      }) {
45415        if (!target.contains(lastMouseDownTarget)) {
45416          return;
45417        }
45418  
45419        // If we're moving into a child element, ignore. We're tracking
45420        // the mouse leaving the element to a parent, no a child.
45421        if (target.contains(relatedTarget)) {
45422          return;
45423        }
45424  
45425        // Avoid triggering a multi-selection if the user is already
45426        // dragging blocks.
45427        if (isDraggingBlocks()) {
45428          return;
45429        }
45430  
45431        // The primary button must be pressed to initiate selection.
45432        // See https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/buttons
45433        if (buttons !== 1) {
45434          return;
45435        }
45436  
45437        // Abort if we are already multi-selecting.
45438        if (isMultiSelecting()) {
45439          return;
45440        }
45441  
45442        // Abort if selection is leaving writing flow.
45443        if (node === target) {
45444          return;
45445        }
45446  
45447        // Check the attribute, not the contentEditable attribute. All
45448        // child elements of the content editable wrapper are editable
45449        // and return true for this property. We only want to start
45450        // multi selecting when the mouse leaves the wrapper.
45451        if (target.getAttribute('contenteditable') !== 'true') {
45452          return;
45453        }
45454        if (!isSelectionEnabled()) {
45455          return;
45456        }
45457  
45458        // Do not rely on the active element because it may change after
45459        // the mouse leaves for the first time. See
45460        // https://github.com/WordPress/gutenberg/issues/48747.
45461        anchorElement = target;
45462        startMultiSelect();
45463  
45464        // `onSelectionStart` is called after `mousedown` and
45465        // `mouseleave` (from a block). The selection ends when
45466        // `mouseup` happens anywhere in the window.
45467        defaultView.addEventListener('mouseup', onMouseUp);
45468  
45469        // Allow cross contentEditable selection by temporarily making
45470        // all content editable. We can't rely on using the store and
45471        // React because re-rending happens too slowly. We need to be
45472        // able to select across instances immediately.
45473        setContentEditableWrapper(node, true);
45474      }
45475      node.addEventListener('mouseout', onMouseLeave);
45476      node.addEventListener('mousedown', onMouseDown);
45477      return () => {
45478        node.removeEventListener('mouseout', onMouseLeave);
45479        defaultView.removeEventListener('mouseup', onMouseUp);
45480        defaultView.cancelAnimationFrame(rafId);
45481      };
45482    }, [startMultiSelect, stopMultiSelect, isSelectionEnabled, hasSelectedBlock]);
45483  }
45484  
45485  ;// ./node_modules/@wordpress/block-editor/build-module/components/writing-flow/use-selection-observer.js
45486  /**
45487   * WordPress dependencies
45488   */
45489  
45490  
45491  
45492  
45493  
45494  /**
45495   * Internal dependencies
45496   */
45497  
45498  
45499  
45500  /**
45501   * Extract the selection start node from the selection. When the anchor node is
45502   * not a text node, the selection offset is the index of a child node.
45503   *
45504   * @param {Selection} selection The selection.
45505   *
45506   * @return {Element} The selection start node.
45507   */
45508  function extractSelectionStartNode(selection) {
45509    const {
45510      anchorNode,
45511      anchorOffset
45512    } = selection;
45513    if (anchorNode.nodeType === anchorNode.TEXT_NODE) {
45514      return anchorNode;
45515    }
45516    if (anchorOffset === 0) {
45517      return anchorNode;
45518    }
45519    return anchorNode.childNodes[anchorOffset - 1];
45520  }
45521  
45522  /**
45523   * Extract the selection end node from the selection. When the focus node is not
45524   * a text node, the selection offset is the index of a child node. The selection
45525   * reaches up to but excluding that child node.
45526   *
45527   * @param {Selection} selection The selection.
45528   *
45529   * @return {Element} The selection start node.
45530   */
45531  function extractSelectionEndNode(selection) {
45532    const {
45533      focusNode,
45534      focusOffset
45535    } = selection;
45536    if (focusNode.nodeType === focusNode.TEXT_NODE) {
45537      return focusNode;
45538    }
45539    if (focusOffset === focusNode.childNodes.length) {
45540      return focusNode;
45541    }
45542  
45543    // When the selection is forward (the selection ends with the focus node),
45544    // the selection may extend into the next element with an offset of 0. This
45545    // may trigger multi selection even though the selection does not visually
45546    // end in the next block.
45547    if (focusOffset === 0 && (0,external_wp_dom_namespaceObject.isSelectionForward)(selection)) {
45548      var _focusNode$previousSi;
45549      return (_focusNode$previousSi = focusNode.previousSibling) !== null && _focusNode$previousSi !== void 0 ? _focusNode$previousSi : focusNode.parentElement;
45550    }
45551    return focusNode.childNodes[focusOffset];
45552  }
45553  function findDepth(a, b) {
45554    let depth = 0;
45555    while (a[depth] === b[depth]) {
45556      depth++;
45557    }
45558    return depth;
45559  }
45560  
45561  /**
45562   * Sets the `contenteditable` wrapper element to `value`.
45563   *
45564   * @param {HTMLElement} node  Block element.
45565   * @param {boolean}     value `contentEditable` value (true or false)
45566   */
45567  function use_selection_observer_setContentEditableWrapper(node, value) {
45568    // Since we are calling this on every selection change, check if the value
45569    // needs to be updated first because it trigger the browser to recalculate
45570    // style.
45571    if (node.contentEditable !== String(value)) {
45572      node.contentEditable = value;
45573  
45574      // Firefox doesn't automatically move focus.
45575      if (value) {
45576        node.focus();
45577      }
45578    }
45579  }
45580  function getRichTextElement(node) {
45581    const element = node.nodeType === node.ELEMENT_NODE ? node : node.parentElement;
45582    return element?.closest('[data-wp-block-attribute-key]');
45583  }
45584  
45585  /**
45586   * Sets a multi-selection based on the native selection across blocks.
45587   */
45588  function useSelectionObserver() {
45589    const {
45590      multiSelect,
45591      selectBlock,
45592      selectionChange
45593    } = (0,external_wp_data_namespaceObject.useDispatch)(store);
45594    const {
45595      getBlockParents,
45596      getBlockSelectionStart,
45597      isMultiSelecting
45598    } = (0,external_wp_data_namespaceObject.useSelect)(store);
45599    return (0,external_wp_compose_namespaceObject.useRefEffect)(node => {
45600      const {
45601        ownerDocument
45602      } = node;
45603      const {
45604        defaultView
45605      } = ownerDocument;
45606      function onSelectionChange(event) {
45607        const selection = defaultView.getSelection();
45608        if (!selection.rangeCount) {
45609          return;
45610        }
45611        const startNode = extractSelectionStartNode(selection);
45612        const endNode = extractSelectionEndNode(selection);
45613        if (!node.contains(startNode) || !node.contains(endNode)) {
45614          return;
45615        }
45616  
45617        // If selection is collapsed and we haven't used `shift+click`,
45618        // end multi selection and disable the contentEditable wrapper.
45619        // We have to check about `shift+click` case because elements
45620        // that don't support text selection might be involved, and we might
45621        // update the clientIds to multi-select blocks.
45622        // For now we check if the event is a `mouse` event.
45623        const isClickShift = event.shiftKey && event.type === 'mouseup';
45624        if (selection.isCollapsed && !isClickShift) {
45625          if (node.contentEditable === 'true' && !isMultiSelecting()) {
45626            use_selection_observer_setContentEditableWrapper(node, false);
45627            let element = startNode.nodeType === startNode.ELEMENT_NODE ? startNode : startNode.parentElement;
45628            element = element?.closest('[contenteditable]');
45629            element?.focus();
45630          }
45631          return;
45632        }
45633        let startClientId = getBlockClientId(startNode);
45634        let endClientId = getBlockClientId(endNode);
45635  
45636        // If the selection has changed and we had pressed `shift+click`,
45637        // we need to check if in an element that doesn't support
45638        // text selection has been clicked.
45639        if (isClickShift) {
45640          const selectedClientId = getBlockSelectionStart();
45641          const clickedClientId = getBlockClientId(event.target);
45642          // `endClientId` is not defined if we end the selection by clicking a non-selectable block.
45643          // We need to check if there was already a selection with a non-selectable focusNode.
45644          const focusNodeIsNonSelectable = clickedClientId !== endClientId;
45645          if (startClientId === endClientId && selection.isCollapsed || !endClientId || focusNodeIsNonSelectable) {
45646            endClientId = clickedClientId;
45647          }
45648          // Handle the case when we have a non-selectable block
45649          // selected and click another one.
45650          if (startClientId !== selectedClientId) {
45651            startClientId = selectedClientId;
45652          }
45653        }
45654  
45655        // If the selection did not involve a block, return.
45656        if (startClientId === undefined && endClientId === undefined) {
45657          use_selection_observer_setContentEditableWrapper(node, false);
45658          return;
45659        }
45660        const isSingularSelection = startClientId === endClientId;
45661        if (isSingularSelection) {
45662          if (!isMultiSelecting()) {
45663            selectBlock(startClientId);
45664          } else {
45665            multiSelect(startClientId, startClientId);
45666          }
45667        } else {
45668          const startPath = [...getBlockParents(startClientId), startClientId];
45669          const endPath = [...getBlockParents(endClientId), endClientId];
45670          const depth = findDepth(startPath, endPath);
45671          if (startPath[depth] !== startClientId || endPath[depth] !== endClientId) {
45672            multiSelect(startPath[depth], endPath[depth]);
45673            return;
45674          }
45675          const richTextElementStart = getRichTextElement(startNode);
45676          const richTextElementEnd = getRichTextElement(endNode);
45677          if (richTextElementStart && richTextElementEnd) {
45678            var _richTextDataStart$st, _richTextDataEnd$star;
45679            const range = selection.getRangeAt(0);
45680            const richTextDataStart = (0,external_wp_richText_namespaceObject.create)({
45681              element: richTextElementStart,
45682              range,
45683              __unstableIsEditableTree: true
45684            });
45685            const richTextDataEnd = (0,external_wp_richText_namespaceObject.create)({
45686              element: richTextElementEnd,
45687              range,
45688              __unstableIsEditableTree: true
45689            });
45690            const startOffset = (_richTextDataStart$st = richTextDataStart.start) !== null && _richTextDataStart$st !== void 0 ? _richTextDataStart$st : richTextDataStart.end;
45691            const endOffset = (_richTextDataEnd$star = richTextDataEnd.start) !== null && _richTextDataEnd$star !== void 0 ? _richTextDataEnd$star : richTextDataEnd.end;
45692            selectionChange({
45693              start: {
45694                clientId: startClientId,
45695                attributeKey: richTextElementStart.dataset.wpBlockAttributeKey,
45696                offset: startOffset
45697              },
45698              end: {
45699                clientId: endClientId,
45700                attributeKey: richTextElementEnd.dataset.wpBlockAttributeKey,
45701                offset: endOffset
45702              }
45703            });
45704          } else {
45705            multiSelect(startClientId, endClientId);
45706          }
45707        }
45708      }
45709      ownerDocument.addEventListener('selectionchange', onSelectionChange);
45710      defaultView.addEventListener('mouseup', onSelectionChange);
45711      return () => {
45712        ownerDocument.removeEventListener('selectionchange', onSelectionChange);
45713        defaultView.removeEventListener('mouseup', onSelectionChange);
45714      };
45715    }, [multiSelect, selectBlock, selectionChange, getBlockParents]);
45716  }
45717  
45718  ;// ./node_modules/@wordpress/block-editor/build-module/components/writing-flow/use-click-selection.js
45719  /**
45720   * WordPress dependencies
45721   */
45722  
45723  
45724  
45725  /**
45726   * Internal dependencies
45727   */
45728  
45729  
45730  function useClickSelection() {
45731    const {
45732      selectBlock
45733    } = (0,external_wp_data_namespaceObject.useDispatch)(store);
45734    const {
45735      isSelectionEnabled,
45736      getBlockSelectionStart,
45737      hasMultiSelection
45738    } = (0,external_wp_data_namespaceObject.useSelect)(store);
45739    return (0,external_wp_compose_namespaceObject.useRefEffect)(node => {
45740      function onMouseDown(event) {
45741        // The main button.
45742        // https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/button
45743        if (!isSelectionEnabled() || event.button !== 0) {
45744          return;
45745        }
45746        const startClientId = getBlockSelectionStart();
45747        const clickedClientId = getBlockClientId(event.target);
45748        if (event.shiftKey) {
45749          if (startClientId !== clickedClientId) {
45750            node.contentEditable = true;
45751            // Firefox doesn't automatically move focus.
45752            node.focus();
45753          }
45754        } else if (hasMultiSelection()) {
45755          // Allow user to escape out of a multi-selection to a
45756          // singular selection of a block via click. This is handled
45757          // here since focus handling excludes blocks when there is
45758          // multiselection, as focus can be incurred by starting a
45759          // multiselection (focus moved to first block's multi-
45760          // controls).
45761          selectBlock(clickedClientId);
45762        }
45763      }
45764      node.addEventListener('mousedown', onMouseDown);
45765      return () => {
45766        node.removeEventListener('mousedown', onMouseDown);
45767      };
45768    }, [selectBlock, isSelectionEnabled, getBlockSelectionStart, hasMultiSelection]);
45769  }
45770  
45771  ;// ./node_modules/@wordpress/block-editor/build-module/components/writing-flow/use-input.js
45772  /**
45773   * WordPress dependencies
45774   */
45775  
45776  
45777  
45778  
45779  
45780  /**
45781   * Internal dependencies
45782   */
45783  
45784  
45785  /**
45786   * Handles input for selections across blocks.
45787   */
45788  function useInput() {
45789    const {
45790      __unstableIsFullySelected,
45791      getSelectedBlockClientIds,
45792      getSelectedBlockClientId,
45793      __unstableIsSelectionMergeable,
45794      hasMultiSelection,
45795      getBlockName,
45796      canInsertBlockType,
45797      getBlockRootClientId,
45798      getSelectionStart,
45799      getSelectionEnd,
45800      getBlockAttributes
45801    } = (0,external_wp_data_namespaceObject.useSelect)(store);
45802    const {
45803      replaceBlocks,
45804      __unstableSplitSelection,
45805      removeBlocks,
45806      __unstableDeleteSelection,
45807      __unstableExpandSelection,
45808      __unstableMarkAutomaticChange
45809    } = (0,external_wp_data_namespaceObject.useDispatch)(store);
45810    return (0,external_wp_compose_namespaceObject.useRefEffect)(node => {
45811      function onBeforeInput(event) {
45812        // If writing flow is editable, NEVER allow the browser to alter the
45813        // DOM. This will cause React errors (and the DOM should only be
45814        // altered in a controlled fashion).
45815        if (node.contentEditable === 'true') {
45816          event.preventDefault();
45817        }
45818      }
45819      function onKeyDown(event) {
45820        if (event.defaultPrevented) {
45821          return;
45822        }
45823        if (!hasMultiSelection()) {
45824          if (event.keyCode === external_wp_keycodes_namespaceObject.ENTER) {
45825            if (event.shiftKey || __unstableIsFullySelected()) {
45826              return;
45827            }
45828            const clientId = getSelectedBlockClientId();
45829            const blockName = getBlockName(clientId);
45830            const selectionStart = getSelectionStart();
45831            const selectionEnd = getSelectionEnd();
45832            if (selectionStart.attributeKey === selectionEnd.attributeKey) {
45833              const selectedAttributeValue = getBlockAttributes(clientId)[selectionStart.attributeKey];
45834              const transforms = (0,external_wp_blocks_namespaceObject.getBlockTransforms)('from').filter(({
45835                type
45836              }) => type === 'enter');
45837              const transformation = (0,external_wp_blocks_namespaceObject.findTransform)(transforms, item => {
45838                return item.regExp.test(selectedAttributeValue);
45839              });
45840              if (transformation) {
45841                replaceBlocks(clientId, transformation.transform({
45842                  content: selectedAttributeValue
45843                }));
45844                __unstableMarkAutomaticChange();
45845                return;
45846              }
45847            }
45848            if (!(0,external_wp_blocks_namespaceObject.hasBlockSupport)(blockName, 'splitting', false) && !event.__deprecatedOnSplit) {
45849              return;
45850            }
45851  
45852            // Ensure template is not locked.
45853            if (canInsertBlockType(blockName, getBlockRootClientId(clientId))) {
45854              __unstableSplitSelection();
45855              event.preventDefault();
45856            }
45857          }
45858          return;
45859        }
45860        if (event.keyCode === external_wp_keycodes_namespaceObject.ENTER) {
45861          node.contentEditable = false;
45862          event.preventDefault();
45863          if (__unstableIsFullySelected()) {
45864            replaceBlocks(getSelectedBlockClientIds(), (0,external_wp_blocks_namespaceObject.createBlock)((0,external_wp_blocks_namespaceObject.getDefaultBlockName)()));
45865          } else {
45866            __unstableSplitSelection();
45867          }
45868        } else if (event.keyCode === external_wp_keycodes_namespaceObject.BACKSPACE || event.keyCode === external_wp_keycodes_namespaceObject.DELETE) {
45869          node.contentEditable = false;
45870          event.preventDefault();
45871          if (__unstableIsFullySelected()) {
45872            removeBlocks(getSelectedBlockClientIds());
45873          } else if (__unstableIsSelectionMergeable()) {
45874            __unstableDeleteSelection(event.keyCode === external_wp_keycodes_namespaceObject.DELETE);
45875          } else {
45876            __unstableExpandSelection();
45877          }
45878        } else if (
45879        // If key.length is longer than 1, it's a control key that doesn't
45880        // input anything.
45881        event.key.length === 1 && !(event.metaKey || event.ctrlKey)) {
45882          node.contentEditable = false;
45883          if (__unstableIsSelectionMergeable()) {
45884            __unstableDeleteSelection(event.keyCode === external_wp_keycodes_namespaceObject.DELETE);
45885          } else {
45886            event.preventDefault();
45887            // Safari does not stop default behaviour with either
45888            // event.preventDefault() or node.contentEditable = false, so
45889            // remove the selection to stop browser manipulation.
45890            node.ownerDocument.defaultView.getSelection().removeAllRanges();
45891          }
45892        }
45893      }
45894      function onCompositionStart(event) {
45895        if (!hasMultiSelection()) {
45896          return;
45897        }
45898        node.contentEditable = false;
45899        if (__unstableIsSelectionMergeable()) {
45900          __unstableDeleteSelection();
45901        } else {
45902          event.preventDefault();
45903          // Safari does not stop default behaviour with either
45904          // event.preventDefault() or node.contentEditable = false, so
45905          // remove the selection to stop browser manipulation.
45906          node.ownerDocument.defaultView.getSelection().removeAllRanges();
45907        }
45908      }
45909      node.addEventListener('beforeinput', onBeforeInput);
45910      node.addEventListener('keydown', onKeyDown);
45911      node.addEventListener('compositionstart', onCompositionStart);
45912      return () => {
45913        node.removeEventListener('beforeinput', onBeforeInput);
45914        node.removeEventListener('keydown', onKeyDown);
45915        node.removeEventListener('compositionstart', onCompositionStart);
45916      };
45917    }, []);
45918  }
45919  
45920  ;// ./node_modules/@wordpress/block-editor/build-module/utils/use-notify-copy.js
45921  /**
45922   * WordPress dependencies
45923   */
45924  
45925  
45926  
45927  
45928  
45929  
45930  /**
45931   * Internal dependencies
45932   */
45933  
45934  function useNotifyCopy() {
45935    const {
45936      getBlockName
45937    } = (0,external_wp_data_namespaceObject.useSelect)(store);
45938    const {
45939      getBlockType
45940    } = (0,external_wp_data_namespaceObject.useSelect)(external_wp_blocks_namespaceObject.store);
45941    const {
45942      createSuccessNotice
45943    } = (0,external_wp_data_namespaceObject.useDispatch)(external_wp_notices_namespaceObject.store);
45944    return (0,external_wp_element_namespaceObject.useCallback)((eventType, selectedBlockClientIds) => {
45945      let notice = '';
45946      if (eventType === 'copyStyles') {
45947        notice = (0,external_wp_i18n_namespaceObject.__)('Styles copied to clipboard.');
45948      } else if (selectedBlockClientIds.length === 1) {
45949        const clientId = selectedBlockClientIds[0];
45950        const title = getBlockType(getBlockName(clientId))?.title;
45951        if (eventType === 'copy') {
45952          notice = (0,external_wp_i18n_namespaceObject.sprintf)(
45953          // Translators: Name of the block being copied, e.g. "Paragraph".
45954          (0,external_wp_i18n_namespaceObject.__)('Copied "%s" to clipboard.'), title);
45955        } else {
45956          notice = (0,external_wp_i18n_namespaceObject.sprintf)(
45957          // Translators: Name of the block being cut, e.g. "Paragraph".
45958          (0,external_wp_i18n_namespaceObject.__)('Moved "%s" to clipboard.'), title);
45959        }
45960      } else if (eventType === 'copy') {
45961        notice = (0,external_wp_i18n_namespaceObject.sprintf)(
45962        // Translators: %d: Number of blocks being copied.
45963        (0,external_wp_i18n_namespaceObject._n)('Copied %d block to clipboard.', 'Copied %d blocks to clipboard.', selectedBlockClientIds.length), selectedBlockClientIds.length);
45964      } else {
45965        notice = (0,external_wp_i18n_namespaceObject.sprintf)(
45966        // Translators: %d: Number of blocks being moved.
45967        (0,external_wp_i18n_namespaceObject._n)('Moved %d block to clipboard.', 'Moved %d blocks to clipboard.', selectedBlockClientIds.length), selectedBlockClientIds.length);
45968      }
45969      createSuccessNotice(notice, {
45970        type: 'snackbar'
45971      });
45972    }, [createSuccessNotice, getBlockName, getBlockType]);
45973  }
45974  
45975  ;// ./node_modules/@wordpress/block-editor/build-module/utils/pasting.js
45976  /**
45977   * WordPress dependencies
45978   */
45979  
45980  
45981  /**
45982   * Normalizes a given string of HTML to remove the Windows-specific "Fragment"
45983   * comments and any preceding and trailing content.
45984   *
45985   * @param {string} html the html to be normalized
45986   * @return {string} the normalized html
45987   */
45988  function removeWindowsFragments(html) {
45989    const startStr = '<!--StartFragment-->';
45990    const startIdx = html.indexOf(startStr);
45991    if (startIdx > -1) {
45992      html = html.substring(startIdx + startStr.length);
45993    } else {
45994      // No point looking for EndFragment
45995      return html;
45996    }
45997    const endStr = '<!--EndFragment-->';
45998    const endIdx = html.indexOf(endStr);
45999    if (endIdx > -1) {
46000      html = html.substring(0, endIdx);
46001    }
46002    return html;
46003  }
46004  
46005  /**
46006   * Removes the charset meta tag inserted by Chromium.
46007   * See:
46008   * - https://github.com/WordPress/gutenberg/issues/33585
46009   * - https://bugs.chromium.org/p/chromium/issues/detail?id=1264616#c4
46010   *
46011   * @param {string} html the html to be stripped of the meta tag.
46012   * @return {string} the cleaned html
46013   */
46014  function removeCharsetMetaTag(html) {
46015    const metaTag = `<meta charset='utf-8'>`;
46016    if (html.startsWith(metaTag)) {
46017      return html.slice(metaTag.length);
46018    }
46019    return html;
46020  }
46021  function getPasteEventData({
46022    clipboardData
46023  }) {
46024    let plainText = '';
46025    let html = '';
46026    try {
46027      plainText = clipboardData.getData('text/plain');
46028      html = clipboardData.getData('text/html');
46029    } catch (error) {
46030      // Some browsers like UC Browser paste plain text by default and
46031      // don't support clipboardData at all, so allow default
46032      // behaviour.
46033      return;
46034    }
46035  
46036    // Remove Windows-specific metadata appended within copied HTML text.
46037    html = removeWindowsFragments(html);
46038  
46039    // Strip meta tag.
46040    html = removeCharsetMetaTag(html);
46041    const files = (0,external_wp_dom_namespaceObject.getFilesFromDataTransfer)(clipboardData);
46042    if (files.length && !shouldDismissPastedFiles(files, html)) {
46043      return {
46044        files
46045      };
46046    }
46047    return {
46048      html,
46049      plainText,
46050      files: []
46051    };
46052  }
46053  
46054  /**
46055   * Given a collection of DataTransfer files and HTML and plain text strings,
46056   * determine whether the files are to be dismissed in favor of the HTML.
46057   *
46058   * Certain office-type programs, like Microsoft Word or Apple Numbers,
46059   * will, upon copy, generate a screenshot of the content being copied and
46060   * attach it to the clipboard alongside the actual rich text that the user
46061   * sought to copy. In those cases, we should let Gutenberg handle the rich text
46062   * content and not the screenshot, since this allows Gutenberg to insert
46063   * meaningful blocks, like paragraphs, lists or even tables.
46064   *
46065   * @param {File[]} files File objects obtained from a paste event
46066   * @param {string} html  HTML content obtained from a paste event
46067   * @return {boolean}     True if the files should be dismissed
46068   */
46069  function shouldDismissPastedFiles(files, html /*, plainText */) {
46070    // The question is only relevant when there is actual HTML content and when
46071    // there is exactly one image file.
46072    if (html && files?.length === 1 && files[0].type.indexOf('image/') === 0) {
46073      // A single <img> tag found in the HTML source suggests that the
46074      // content being pasted revolves around an image. Sometimes there are
46075      // other elements found, like <figure>, but we assume that the user's
46076      // intention is to paste the actual image file.
46077      const IMAGE_TAG = /<\s*img\b/gi;
46078      if (html.match(IMAGE_TAG)?.length !== 1) {
46079        return true;
46080      }
46081  
46082      // Even when there is exactly one <img> tag in the HTML payload, we
46083      // choose to weed out local images, i.e. those whose source starts with
46084      // "file://". These payloads occur in specific configurations, such as
46085      // when copying an entire document from Microsoft Word, that contains
46086      // text and exactly one image, and pasting that content using Google
46087      // Chrome.
46088      const IMG_WITH_LOCAL_SRC = /<\s*img\b[^>]*\bsrc="file:\/\//i;
46089      if (html.match(IMG_WITH_LOCAL_SRC)) {
46090        return true;
46091      }
46092    }
46093    return false;
46094  }
46095  
46096  ;// ./node_modules/@wordpress/block-editor/build-module/components/writing-flow/utils.js
46097  /**
46098   * WordPress dependencies
46099   */
46100  
46101  
46102  
46103  /**
46104   * Internal dependencies
46105   */
46106  
46107  
46108  const requiresWrapperOnCopy = Symbol('requiresWrapperOnCopy');
46109  
46110  /**
46111   * Sets the clipboard data for the provided blocks, with both HTML and plain
46112   * text representations.
46113   *
46114   * @param {ClipboardEvent} event    Clipboard event.
46115   * @param {WPBlock[]}      blocks   Blocks to set as clipboard data.
46116   * @param {Object}         registry The registry to select from.
46117   */
46118  function setClipboardBlocks(event, blocks, registry) {
46119    let _blocks = blocks;
46120    const [firstBlock] = blocks;
46121    if (firstBlock) {
46122      const firstBlockType = registry.select(external_wp_blocks_namespaceObject.store).getBlockType(firstBlock.name);
46123      if (firstBlockType[requiresWrapperOnCopy]) {
46124        const {
46125          getBlockRootClientId,
46126          getBlockName,
46127          getBlockAttributes
46128        } = registry.select(store);
46129        const wrapperBlockClientId = getBlockRootClientId(firstBlock.clientId);
46130        const wrapperBlockName = getBlockName(wrapperBlockClientId);
46131        if (wrapperBlockName) {
46132          _blocks = (0,external_wp_blocks_namespaceObject.createBlock)(wrapperBlockName, getBlockAttributes(wrapperBlockClientId), _blocks);
46133        }
46134      }
46135    }
46136    const serialized = (0,external_wp_blocks_namespaceObject.serialize)(_blocks);
46137    event.clipboardData.setData('text/plain', toPlainText(serialized));
46138    event.clipboardData.setData('text/html', serialized);
46139  }
46140  
46141  /**
46142   * Returns the blocks to be pasted from the clipboard event.
46143   *
46144   * @param {ClipboardEvent} event                    The clipboard event.
46145   * @param {boolean}        canUserUseUnfilteredHTML Whether the user can or can't post unfiltered HTML.
46146   * @return {Array|string} A list of blocks or a string, depending on `handlerMode`.
46147   */
46148  function getPasteBlocks(event, canUserUseUnfilteredHTML) {
46149    const {
46150      plainText,
46151      html,
46152      files
46153    } = getPasteEventData(event);
46154    let blocks = [];
46155    if (files.length) {
46156      const fromTransforms = (0,external_wp_blocks_namespaceObject.getBlockTransforms)('from');
46157      blocks = files.reduce((accumulator, file) => {
46158        const transformation = (0,external_wp_blocks_namespaceObject.findTransform)(fromTransforms, transform => transform.type === 'files' && transform.isMatch([file]));
46159        if (transformation) {
46160          accumulator.push(transformation.transform([file]));
46161        }
46162        return accumulator;
46163      }, []).flat();
46164    } else {
46165      blocks = (0,external_wp_blocks_namespaceObject.pasteHandler)({
46166        HTML: html,
46167        plainText,
46168        mode: 'BLOCKS',
46169        canUserUseUnfilteredHTML
46170      });
46171    }
46172    return blocks;
46173  }
46174  
46175  /**
46176   * Given a string of HTML representing serialized blocks, returns the plain
46177   * text extracted after stripping the HTML of any tags and fixing line breaks.
46178   *
46179   * @param {string} html Serialized blocks.
46180   * @return {string} The plain-text content with any html removed.
46181   */
46182  function toPlainText(html) {
46183    // Manually handle BR tags as line breaks prior to `stripHTML` call
46184    html = html.replace(/<br>/g, '\n');
46185    const plainText = (0,external_wp_dom_namespaceObject.__unstableStripHTML)(html).trim();
46186  
46187    // Merge any consecutive line breaks
46188    return plainText.replace(/\n\n+/g, '\n\n');
46189  }
46190  
46191  ;// ./node_modules/@wordpress/block-editor/build-module/components/writing-flow/use-clipboard-handler.js
46192  /**
46193   * WordPress dependencies
46194   */
46195  
46196  
46197  
46198  
46199  
46200  /**
46201   * Internal dependencies
46202   */
46203  
46204  
46205  
46206  
46207  function useClipboardHandler() {
46208    const registry = (0,external_wp_data_namespaceObject.useRegistry)();
46209    const {
46210      getBlocksByClientId,
46211      getSelectedBlockClientIds,
46212      hasMultiSelection,
46213      getSettings,
46214      getBlockName,
46215      __unstableIsFullySelected,
46216      __unstableIsSelectionCollapsed,
46217      __unstableIsSelectionMergeable,
46218      __unstableGetSelectedBlocksWithPartialSelection,
46219      canInsertBlockType,
46220      getBlockRootClientId
46221    } = (0,external_wp_data_namespaceObject.useSelect)(store);
46222    const {
46223      flashBlock,
46224      removeBlocks,
46225      replaceBlocks,
46226      __unstableDeleteSelection,
46227      __unstableExpandSelection,
46228      __unstableSplitSelection
46229    } = (0,external_wp_data_namespaceObject.useDispatch)(store);
46230    const notifyCopy = useNotifyCopy();
46231    return (0,external_wp_compose_namespaceObject.useRefEffect)(node => {
46232      function handler(event) {
46233        if (event.defaultPrevented) {
46234          // This was likely already handled in rich-text/use-paste-handler.js.
46235          return;
46236        }
46237        const selectedBlockClientIds = getSelectedBlockClientIds();
46238        if (selectedBlockClientIds.length === 0) {
46239          return;
46240        }
46241  
46242        // Let native copy/paste behaviour take over in input fields.
46243        // But always handle multiple selected blocks.
46244        if (!hasMultiSelection()) {
46245          const {
46246            target
46247          } = event;
46248          const {
46249            ownerDocument
46250          } = target;
46251          // If copying, only consider actual text selection as selection.
46252          // Otherwise, any focus on an input field is considered.
46253          const hasSelection = event.type === 'copy' || event.type === 'cut' ? (0,external_wp_dom_namespaceObject.documentHasUncollapsedSelection)(ownerDocument) : (0,external_wp_dom_namespaceObject.documentHasSelection)(ownerDocument) && !ownerDocument.activeElement.isContentEditable;
46254  
46255          // Let native copy behaviour take over in input fields.
46256          if (hasSelection) {
46257            return;
46258          }
46259        }
46260        const {
46261          activeElement
46262        } = event.target.ownerDocument;
46263        if (!node.contains(activeElement)) {
46264          return;
46265        }
46266        const isSelectionMergeable = __unstableIsSelectionMergeable();
46267        const shouldHandleWholeBlocks = __unstableIsSelectionCollapsed() || __unstableIsFullySelected();
46268        const expandSelectionIsNeeded = !shouldHandleWholeBlocks && !isSelectionMergeable;
46269        if (event.type === 'copy' || event.type === 'cut') {
46270          event.preventDefault();
46271          if (selectedBlockClientIds.length === 1) {
46272            flashBlock(selectedBlockClientIds[0]);
46273          }
46274          // If we have a partial selection that is not mergeable, just
46275          // expand the selection to the whole blocks.
46276          if (expandSelectionIsNeeded) {
46277            __unstableExpandSelection();
46278          } else {
46279            notifyCopy(event.type, selectedBlockClientIds);
46280            let blocks;
46281            // Check if we have partial selection.
46282            if (shouldHandleWholeBlocks) {
46283              blocks = getBlocksByClientId(selectedBlockClientIds);
46284            } else {
46285              const [head, tail] = __unstableGetSelectedBlocksWithPartialSelection();
46286              const inBetweenBlocks = getBlocksByClientId(selectedBlockClientIds.slice(1, selectedBlockClientIds.length - 1));
46287              blocks = [head, ...inBetweenBlocks, tail];
46288            }
46289            setClipboardBlocks(event, blocks, registry);
46290          }
46291        }
46292        if (event.type === 'cut') {
46293          // We need to also check if at the start we needed to
46294          // expand the selection, as in this point we might have
46295          // programmatically fully selected the blocks above.
46296          if (shouldHandleWholeBlocks && !expandSelectionIsNeeded) {
46297            removeBlocks(selectedBlockClientIds);
46298          } else {
46299            event.target.ownerDocument.activeElement.contentEditable = false;
46300            __unstableDeleteSelection();
46301          }
46302        } else if (event.type === 'paste') {
46303          const {
46304            __experimentalCanUserUseUnfilteredHTML: canUserUseUnfilteredHTML
46305          } = getSettings();
46306          const isInternal = event.clipboardData.getData('rich-text') === 'true';
46307          if (isInternal) {
46308            return;
46309          }
46310          const {
46311            plainText,
46312            html,
46313            files
46314          } = getPasteEventData(event);
46315          const isFullySelected = __unstableIsFullySelected();
46316          let blocks = [];
46317          if (files.length) {
46318            const fromTransforms = (0,external_wp_blocks_namespaceObject.getBlockTransforms)('from');
46319            blocks = files.reduce((accumulator, file) => {
46320              const transformation = (0,external_wp_blocks_namespaceObject.findTransform)(fromTransforms, transform => transform.type === 'files' && transform.isMatch([file]));
46321              if (transformation) {
46322                accumulator.push(transformation.transform([file]));
46323              }
46324              return accumulator;
46325            }, []).flat();
46326          } else {
46327            blocks = (0,external_wp_blocks_namespaceObject.pasteHandler)({
46328              HTML: html,
46329              plainText,
46330              mode: isFullySelected ? 'BLOCKS' : 'AUTO',
46331              canUserUseUnfilteredHTML
46332            });
46333          }
46334  
46335          // Inline paste: let rich text handle it.
46336          if (typeof blocks === 'string') {
46337            return;
46338          }
46339          if (isFullySelected) {
46340            replaceBlocks(selectedBlockClientIds, blocks, blocks.length - 1, -1);
46341            event.preventDefault();
46342            return;
46343          }
46344  
46345          // If a block doesn't support splitting, let rich text paste
46346          // inline.
46347          if (!hasMultiSelection() && !(0,external_wp_blocks_namespaceObject.hasBlockSupport)(getBlockName(selectedBlockClientIds[0]), 'splitting', false) && !event.__deprecatedOnSplit) {
46348            return;
46349          }
46350          const [firstSelectedClientId] = selectedBlockClientIds;
46351          const rootClientId = getBlockRootClientId(firstSelectedClientId);
46352          const newBlocks = [];
46353          for (const block of blocks) {
46354            if (canInsertBlockType(block.name, rootClientId)) {
46355              newBlocks.push(block);
46356            } else {
46357              // If a block cannot be inserted in a root block, try
46358              // converting it to that root block type and insert the
46359              // inner blocks.
46360              // Example: paragraphs cannot be inserted into a list,
46361              // so convert the paragraphs to a list for list items.
46362              const rootBlockName = getBlockName(rootClientId);
46363              const switchedBlocks = block.name !== rootBlockName ? (0,external_wp_blocks_namespaceObject.switchToBlockType)(block, rootBlockName) : [block];
46364              if (!switchedBlocks) {
46365                return;
46366              }
46367              for (const switchedBlock of switchedBlocks) {
46368                for (const innerBlock of switchedBlock.innerBlocks) {
46369                  newBlocks.push(innerBlock);
46370                }
46371              }
46372            }
46373          }
46374          __unstableSplitSelection(newBlocks);
46375          event.preventDefault();
46376        }
46377      }
46378      node.ownerDocument.addEventListener('copy', handler);
46379      node.ownerDocument.addEventListener('cut', handler);
46380      node.ownerDocument.addEventListener('paste', handler);
46381      return () => {
46382        node.ownerDocument.removeEventListener('copy', handler);
46383        node.ownerDocument.removeEventListener('cut', handler);
46384        node.ownerDocument.removeEventListener('paste', handler);
46385      };
46386    }, []);
46387  }
46388  
46389  ;// ./node_modules/@wordpress/block-editor/build-module/components/writing-flow/index.js
46390  /**
46391   * External dependencies
46392   */
46393  
46394  
46395  /**
46396   * WordPress dependencies
46397   */
46398  
46399  
46400  
46401  
46402  
46403  /**
46404   * Internal dependencies
46405   */
46406  
46407  
46408  
46409  
46410  
46411  
46412  
46413  
46414  
46415  
46416  
46417  function useWritingFlow() {
46418    const [before, ref, after] = useTabNav();
46419    const hasMultiSelection = (0,external_wp_data_namespaceObject.useSelect)(select => select(store).hasMultiSelection(), []);
46420    return [before, (0,external_wp_compose_namespaceObject.useMergeRefs)([ref, useClipboardHandler(), useInput(), useDragSelection(), useSelectionObserver(), useClickSelection(), useMultiSelection(), useSelectAll(), useArrowNav(), (0,external_wp_compose_namespaceObject.useRefEffect)(node => {
46421      node.tabIndex = 0;
46422      node.dataset.hasMultiSelection = hasMultiSelection;
46423      if (!hasMultiSelection) {
46424        return () => {
46425          delete node.dataset.hasMultiSelection;
46426        };
46427      }
46428      node.setAttribute('aria-label', (0,external_wp_i18n_namespaceObject.__)('Multiple selected blocks'));
46429      return () => {
46430        delete node.dataset.hasMultiSelection;
46431        node.removeAttribute('aria-label');
46432      };
46433    }, [hasMultiSelection])]), after];
46434  }
46435  function WritingFlow({
46436    children,
46437    ...props
46438  }, forwardedRef) {
46439    const [before, ref, after] = useWritingFlow();
46440    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
46441      children: [before, /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
46442        ...props,
46443        ref: (0,external_wp_compose_namespaceObject.useMergeRefs)([ref, forwardedRef]),
46444        className: dist_clsx(props.className, 'block-editor-writing-flow'),
46445        children: children
46446      }), after]
46447    });
46448  }
46449  
46450  /**
46451   * Handles selection and navigation across blocks. This component should be
46452   * wrapped around BlockList.
46453   *
46454   * @param {Object}  props          Component properties.
46455   * @param {Element} props.children Children to be rendered.
46456   */
46457  /* harmony default export */ const writing_flow = ((0,external_wp_element_namespaceObject.forwardRef)(WritingFlow));
46458  
46459  ;// ./node_modules/@wordpress/block-editor/build-module/components/iframe/get-compatibility-styles.js
46460  let compatibilityStyles = null;
46461  
46462  /**
46463   * Returns a list of stylesheets that target the editor canvas. A stylesheet is
46464   * considered targeting the editor a canvas if it contains the
46465   * `editor-styles-wrapper`, `wp-block`, or `wp-block-*` class selectors.
46466   *
46467   * Ideally, this hook should be removed in the future and styles should be added
46468   * explicitly as editor styles.
46469   */
46470  function getCompatibilityStyles() {
46471    if (compatibilityStyles) {
46472      return compatibilityStyles;
46473    }
46474  
46475    // Only memoize the result once on load, since these stylesheets should not
46476    // change.
46477    compatibilityStyles = Array.from(document.styleSheets).reduce((accumulator, styleSheet) => {
46478      try {
46479        // May fail for external styles.
46480        // eslint-disable-next-line no-unused-expressions
46481        styleSheet.cssRules;
46482      } catch (e) {
46483        return accumulator;
46484      }
46485      const {
46486        ownerNode,
46487        cssRules
46488      } = styleSheet;
46489  
46490      // Stylesheet is added by another stylesheet. See
46491      // https://developer.mozilla.org/en-US/docs/Web/API/StyleSheet/ownerNode#notes.
46492      if (ownerNode === null) {
46493        return accumulator;
46494      }
46495      if (!cssRules) {
46496        return accumulator;
46497      }
46498  
46499      // Don't try to add core WP styles. We are responsible for adding
46500      // them. This compatibility layer is only meant to add styles added
46501      // by plugins or themes.
46502      if (ownerNode.id.startsWith('wp-')) {
46503        return accumulator;
46504      }
46505  
46506      // Don't try to add styles without ID. Styles enqueued via the WP dependency system will always have IDs.
46507      if (!ownerNode.id) {
46508        return accumulator;
46509      }
46510      function matchFromRules(_cssRules) {
46511        return Array.from(_cssRules).find(({
46512          selectorText,
46513          conditionText,
46514          cssRules: __cssRules
46515        }) => {
46516          // If the rule is conditional then it will not have selector text.
46517          // Recurse into child CSS ruleset to determine selector eligibility.
46518          if (conditionText) {
46519            return matchFromRules(__cssRules);
46520          }
46521          return selectorText && (selectorText.includes('.editor-styles-wrapper') || selectorText.includes('.wp-block'));
46522        });
46523      }
46524      if (matchFromRules(cssRules)) {
46525        const isInline = ownerNode.tagName === 'STYLE';
46526        if (isInline) {
46527          // If the current target is inline,
46528          // it could be a dependency of an existing stylesheet.
46529          // Look for that dependency and add it BEFORE the current target.
46530          const mainStylesCssId = ownerNode.id.replace('-inline-css', '-css');
46531          const mainStylesElement = document.getElementById(mainStylesCssId);
46532          if (mainStylesElement) {
46533            accumulator.push(mainStylesElement.cloneNode(true));
46534          }
46535        }
46536        accumulator.push(ownerNode.cloneNode(true));
46537        if (!isInline) {
46538          // If the current target is not inline,
46539          // we still look for inline styles that could be relevant for the current target.
46540          // If they exist, add them AFTER the current target.
46541          const inlineStylesCssId = ownerNode.id.replace('-css', '-inline-css');
46542          const inlineStylesElement = document.getElementById(inlineStylesCssId);
46543          if (inlineStylesElement) {
46544            accumulator.push(inlineStylesElement.cloneNode(true));
46545          }
46546        }
46547      }
46548      return accumulator;
46549    }, []);
46550    return compatibilityStyles;
46551  }
46552  
46553  ;// ./node_modules/@wordpress/block-editor/build-module/components/iframe/use-scale-canvas.js
46554  /**
46555   * WordPress dependencies
46556   */
46557  
46558  
46559  
46560  /**
46561   * @typedef {Object} TransitionState
46562   * @property {number} scaleValue      Scale of the canvas.
46563   * @property {number} frameSize       Size of the frame/offset around the canvas.
46564   * @property {number} containerHeight containerHeight of the iframe.
46565   * @property {number} scrollTop       ScrollTop of the iframe.
46566   * @property {number} scrollHeight    ScrollHeight of the iframe.
46567   */
46568  
46569  /**
46570   * Calculate the scale of the canvas.
46571   *
46572   * @param {Object} options                     Object of options
46573   * @param {number} options.frameSize           Size of the frame/offset around the canvas
46574   * @param {number} options.containerWidth      Actual width of the canvas container
46575   * @param {number} options.maxContainerWidth   Maximum width of the container to use for the scale calculation. This locks the canvas to a maximum width when zooming out.
46576   * @param {number} options.scaleContainerWidth Width the of the container wrapping the canvas container
46577   * @return {number} Scale value between 0 and/or equal to 1
46578   */
46579  function calculateScale({
46580    frameSize,
46581    containerWidth,
46582    maxContainerWidth,
46583    scaleContainerWidth
46584  }) {
46585    return (Math.min(containerWidth, maxContainerWidth) - frameSize * 2) / scaleContainerWidth;
46586  }
46587  
46588  /**
46589   * Compute the next scrollHeight based on the transition states.
46590   *
46591   * @param {TransitionState} transitionFrom Starting point of the transition
46592   * @param {TransitionState} transitionTo   Ending state of the transition
46593   * @return {number} Next scrollHeight based on scale and frame value changes.
46594   */
46595  function computeScrollHeightNext(transitionFrom, transitionTo) {
46596    const {
46597      scaleValue: prevScale,
46598      scrollHeight: prevScrollHeight
46599    } = transitionFrom;
46600    const {
46601      frameSize,
46602      scaleValue
46603    } = transitionTo;
46604    return prevScrollHeight * (scaleValue / prevScale) + frameSize * 2;
46605  }
46606  
46607  /**
46608   * Compute the next scrollTop position after scaling the iframe content.
46609   *
46610   * @param {TransitionState} transitionFrom Starting point of the transition
46611   * @param {TransitionState} transitionTo   Ending state of the transition
46612   * @return {number} Next scrollTop position after scaling the iframe content.
46613   */
46614  function computeScrollTopNext(transitionFrom, transitionTo) {
46615    const {
46616      containerHeight: prevContainerHeight,
46617      frameSize: prevFrameSize,
46618      scaleValue: prevScale,
46619      scrollTop: prevScrollTop
46620    } = transitionFrom;
46621    const {
46622      containerHeight,
46623      frameSize,
46624      scaleValue,
46625      scrollHeight
46626    } = transitionTo;
46627    // Step 0: Start with the current scrollTop.
46628    let scrollTopNext = prevScrollTop;
46629    // Step 1: Undo the effects of the previous scale and frame around the
46630    // midpoint of the visible area.
46631    scrollTopNext = (scrollTopNext + prevContainerHeight / 2 - prevFrameSize) / prevScale - prevContainerHeight / 2;
46632  
46633    // Step 2: Apply the new scale and frame around the midpoint of the
46634    // visible area.
46635    scrollTopNext = (scrollTopNext + containerHeight / 2) * scaleValue + frameSize - containerHeight / 2;
46636  
46637    // Step 3: Handle an edge case so that you scroll to the top of the
46638    // iframe if the top of the iframe content is visible in the container.
46639    // The same edge case for the bottom is skipped because changing content
46640    // makes calculating it impossible.
46641    scrollTopNext = prevScrollTop <= prevFrameSize ? 0 : scrollTopNext;
46642  
46643    // This is the scrollTop value if you are scrolled to the bottom of the
46644    // iframe. We can't just let the browser handle it because we need to
46645    // animate the scaling.
46646    const maxScrollTop = scrollHeight - containerHeight;
46647  
46648    // Step 4: Clamp the scrollTopNext between the minimum and maximum
46649    // possible scrollTop positions. Round the value to avoid subpixel
46650    // truncation by the browser which sometimes causes a 1px error.
46651    return Math.round(Math.min(Math.max(0, scrollTopNext), Math.max(0, maxScrollTop)));
46652  }
46653  
46654  /**
46655   * Generate the keyframes to use for the zoom out animation.
46656   *
46657   * @param {TransitionState} transitionFrom Starting transition state.
46658   * @param {TransitionState} transitionTo   Ending transition state.
46659   * @return {Object[]} An array of keyframes to use for the animation.
46660   */
46661  function getAnimationKeyframes(transitionFrom, transitionTo) {
46662    const {
46663      scaleValue: prevScale,
46664      frameSize: prevFrameSize,
46665      scrollTop
46666    } = transitionFrom;
46667    const {
46668      scaleValue,
46669      frameSize,
46670      scrollTop: scrollTopNext
46671    } = transitionTo;
46672    return [{
46673      translate: `0 0`,
46674      scale: prevScale,
46675      paddingTop: `$prevFrameSize / prevScale}px`,
46676      paddingBottom: `$prevFrameSize / prevScale}px`
46677    }, {
46678      translate: `0 $scrollTop - scrollTopNext}px`,
46679      scale: scaleValue,
46680      paddingTop: `$frameSize / scaleValue}px`,
46681      paddingBottom: `$frameSize / scaleValue}px`
46682    }];
46683  }
46684  
46685  /**
46686   * @typedef {Object} ScaleCanvasResult
46687   * @property {boolean} isZoomedOut             A boolean indicating if the canvas is zoomed out.
46688   * @property {number}  scaleContainerWidth     The width of the container used to calculate the scale.
46689   * @property {Object}  contentResizeListener   A resize observer for the content.
46690   * @property {Object}  containerResizeListener A resize observer for the container.
46691   */
46692  
46693  /**
46694   * Handles scaling the canvas for the zoom out mode and animating between
46695   * the states.
46696   *
46697   * @param {Object}        options                   Object of options.
46698   * @param {number}        options.frameSize         Size of the frame around the content.
46699   * @param {Document}      options.iframeDocument    Document of the iframe.
46700   * @param {number}        options.maxContainerWidth Max width of the canvas to use as the starting scale point. Defaults to 750.
46701   * @param {number|string} options.scale             Scale of the canvas. Can be an decimal between 0 and 1, 1, or 'auto-scaled'.
46702   * @return {ScaleCanvasResult} Properties of the result.
46703   */
46704  function useScaleCanvas({
46705    frameSize,
46706    iframeDocument,
46707    maxContainerWidth = 750,
46708    scale
46709  }) {
46710    const [contentResizeListener, {
46711      height: contentHeight
46712    }] = (0,external_wp_compose_namespaceObject.useResizeObserver)();
46713    const [containerResizeListener, {
46714      width: containerWidth,
46715      height: containerHeight
46716    }] = (0,external_wp_compose_namespaceObject.useResizeObserver)();
46717    const initialContainerWidthRef = (0,external_wp_element_namespaceObject.useRef)(0);
46718    const isZoomedOut = scale !== 1;
46719    const prefersReducedMotion = (0,external_wp_compose_namespaceObject.useReducedMotion)();
46720    const isAutoScaled = scale === 'auto-scaled';
46721    // Track if the animation should start when the useEffect runs.
46722    const startAnimationRef = (0,external_wp_element_namespaceObject.useRef)(false);
46723    // Track the animation so we know if we have an animation running,
46724    // and can cancel it, reverse it, call a finish event, etc.
46725    const animationRef = (0,external_wp_element_namespaceObject.useRef)(null);
46726    (0,external_wp_element_namespaceObject.useEffect)(() => {
46727      if (!isZoomedOut) {
46728        initialContainerWidthRef.current = containerWidth;
46729      }
46730    }, [containerWidth, isZoomedOut]);
46731    const scaleContainerWidth = Math.max(initialContainerWidthRef.current, containerWidth);
46732    const scaleValue = isAutoScaled ? calculateScale({
46733      frameSize,
46734      containerWidth,
46735      maxContainerWidth,
46736      scaleContainerWidth
46737    }) : scale;
46738  
46739    /**
46740     * The starting transition state for the zoom out animation.
46741     * @type {import('react').RefObject<TransitionState>}
46742     */
46743    const transitionFromRef = (0,external_wp_element_namespaceObject.useRef)({
46744      scaleValue,
46745      frameSize,
46746      containerHeight: 0,
46747      scrollTop: 0,
46748      scrollHeight: 0
46749    });
46750  
46751    /**
46752     * The ending transition state for the zoom out animation.
46753     * @type {import('react').RefObject<TransitionState>}
46754     */
46755    const transitionToRef = (0,external_wp_element_namespaceObject.useRef)({
46756      scaleValue,
46757      frameSize,
46758      containerHeight: 0,
46759      scrollTop: 0,
46760      scrollHeight: 0
46761    });
46762  
46763    /**
46764     * Start the zoom out animation. This sets the necessary CSS variables
46765     * for animating the canvas and returns the Animation object.
46766     *
46767     * @return {Animation} The animation object for the zoom out animation.
46768     */
46769    const startZoomOutAnimation = (0,external_wp_element_namespaceObject.useCallback)(() => {
46770      const {
46771        scrollTop
46772      } = transitionFromRef.current;
46773      const {
46774        scrollTop: scrollTopNext
46775      } = transitionToRef.current;
46776      iframeDocument.documentElement.style.setProperty('--wp-block-editor-iframe-zoom-out-scroll-top', `$scrollTop}px`);
46777      iframeDocument.documentElement.style.setProperty('--wp-block-editor-iframe-zoom-out-scroll-top-next', `$scrollTopNext}px`);
46778  
46779      // If the container has a scrolllbar, force a scrollbar to prevent the content from shifting while animating.
46780      iframeDocument.documentElement.style.setProperty('--wp-block-editor-iframe-zoom-out-overflow-behavior', transitionFromRef.current.scrollHeight === transitionFromRef.current.containerHeight ? 'auto' : 'scroll');
46781      iframeDocument.documentElement.classList.add('zoom-out-animation');
46782      return iframeDocument.documentElement.animate(getAnimationKeyframes(transitionFromRef.current, transitionToRef.current), {
46783        easing: 'cubic-bezier(0.46, 0.03, 0.52, 0.96)',
46784        duration: 400
46785      });
46786    }, [iframeDocument]);
46787  
46788    /**
46789     * Callback when the zoom out animation is finished.
46790     * - Cleans up animations refs.
46791     * - Adds final CSS vars for scale and frame size to preserve the state.
46792     * - Removes the 'zoom-out-animation' class (which has the fixed positioning).
46793     * - Sets the final scroll position after the canvas is no longer in fixed position.
46794     * - Removes CSS vars related to the animation.
46795     * - Sets the transitionFrom to the transitionTo state to be ready for the next animation.
46796     */
46797    const finishZoomOutAnimation = (0,external_wp_element_namespaceObject.useCallback)(() => {
46798      startAnimationRef.current = false;
46799      animationRef.current = null;
46800  
46801      // Add our final scale and frame size now that the animation is done.
46802      iframeDocument.documentElement.style.setProperty('--wp-block-editor-iframe-zoom-out-scale', transitionToRef.current.scaleValue);
46803      iframeDocument.documentElement.style.setProperty('--wp-block-editor-iframe-zoom-out-frame-size', `$transitionToRef.current.frameSize}px`);
46804      iframeDocument.documentElement.classList.remove('zoom-out-animation');
46805  
46806      // Set the final scroll position that was just animated to.
46807      // Disable reason: Eslint isn't smart enough to know that this is a
46808      // DOM element. https://github.com/facebook/react/issues/31483
46809      // eslint-disable-next-line react-compiler/react-compiler
46810      iframeDocument.documentElement.scrollTop = transitionToRef.current.scrollTop;
46811      iframeDocument.documentElement.style.removeProperty('--wp-block-editor-iframe-zoom-out-scroll-top');
46812      iframeDocument.documentElement.style.removeProperty('--wp-block-editor-iframe-zoom-out-scroll-top-next');
46813      iframeDocument.documentElement.style.removeProperty('--wp-block-editor-iframe-zoom-out-overflow-behavior');
46814  
46815      // Update previous values.
46816      transitionFromRef.current = transitionToRef.current;
46817    }, [iframeDocument]);
46818    const previousIsZoomedOut = (0,external_wp_element_namespaceObject.useRef)(false);
46819  
46820    /**
46821     * Runs when zoom out mode is toggled, and sets the startAnimation flag
46822     * so the animation will start when the next useEffect runs. We _only_
46823     * want to animate when the zoom out mode is toggled, not when the scale
46824     * changes due to the container resizing.
46825     */
46826    (0,external_wp_element_namespaceObject.useEffect)(() => {
46827      const trigger = iframeDocument && previousIsZoomedOut.current !== isZoomedOut;
46828      previousIsZoomedOut.current = isZoomedOut;
46829      if (!trigger) {
46830        return;
46831      }
46832      startAnimationRef.current = true;
46833      if (!isZoomedOut) {
46834        return;
46835      }
46836      iframeDocument.documentElement.classList.add('is-zoomed-out');
46837      return () => {
46838        iframeDocument.documentElement.classList.remove('is-zoomed-out');
46839      };
46840    }, [iframeDocument, isZoomedOut]);
46841  
46842    /**
46843     * This handles:
46844     * 1. Setting the correct scale and vars of the canvas when zoomed out
46845     * 2. If zoom out mode has been toggled, runs the animation of zooming in/out
46846     */
46847    (0,external_wp_element_namespaceObject.useEffect)(() => {
46848      if (!iframeDocument) {
46849        return;
46850      }
46851  
46852      // We need to update the appropriate scale to exit from. If sidebars have been opened since setting the
46853      // original scale, we will snap to a much smaller scale due to the scale container immediately changing sizes when exiting.
46854      if (isAutoScaled && transitionFromRef.current.scaleValue !== 1) {
46855        // We use containerWidth as the divisor, as scaleContainerWidth will always match the containerWidth when
46856        // exiting.
46857        transitionFromRef.current.scaleValue = calculateScale({
46858          frameSize: transitionFromRef.current.frameSize,
46859          containerWidth,
46860          maxContainerWidth,
46861          scaleContainerWidth: containerWidth
46862        });
46863      }
46864      if (scaleValue < 1) {
46865        // If we are not going to animate the transition, set the scale and frame size directly.
46866        // If we are animating, these values will be set when the animation is finished.
46867        // Example: Opening sidebars that reduce the scale of the canvas, but we don't want to
46868        // animate the transition.
46869        if (!startAnimationRef.current) {
46870          iframeDocument.documentElement.style.setProperty('--wp-block-editor-iframe-zoom-out-scale', scaleValue);
46871          iframeDocument.documentElement.style.setProperty('--wp-block-editor-iframe-zoom-out-frame-size', `$frameSize}px`);
46872        }
46873        iframeDocument.documentElement.style.setProperty('--wp-block-editor-iframe-zoom-out-content-height', `$contentHeight}px`);
46874        iframeDocument.documentElement.style.setProperty('--wp-block-editor-iframe-zoom-out-inner-height', `$containerHeight}px`);
46875        iframeDocument.documentElement.style.setProperty('--wp-block-editor-iframe-zoom-out-container-width', `$containerWidth}px`);
46876        iframeDocument.documentElement.style.setProperty('--wp-block-editor-iframe-zoom-out-scale-container-width', `$scaleContainerWidth}px`);
46877      }
46878  
46879      /**
46880       * Handle the zoom out animation:
46881       *
46882       * - Get the current scrollTop position.
46883       * - Calculate where the same scroll position is after scaling.
46884       * - Apply fixed positioning to the canvas with a transform offset
46885       *   to keep the canvas centered.
46886       * - Animate the scale and padding to the new scale and frame size.
46887       * - After the animation is complete, remove the fixed positioning
46888       *   and set the scroll position that keeps everything centered.
46889       */
46890      if (startAnimationRef.current) {
46891        // Don't allow a new transition to start again unless it was started by the zoom out mode changing.
46892        startAnimationRef.current = false;
46893  
46894        /**
46895         * If we already have an animation running, reverse it.
46896         */
46897        if (animationRef.current) {
46898          animationRef.current.reverse();
46899          // Swap the transition to/from refs so that we set the correct values when
46900          // finishZoomOutAnimation runs.
46901          const tempTransitionFrom = transitionFromRef.current;
46902          const tempTransitionTo = transitionToRef.current;
46903          transitionFromRef.current = tempTransitionTo;
46904          transitionToRef.current = tempTransitionFrom;
46905        } else {
46906          /**
46907           * Start a new zoom animation.
46908           */
46909  
46910          // We can't trust the set value from contentHeight, as it was measured
46911          // before the zoom out mode was changed. After zoom out mode is changed,
46912          // appenders may appear or disappear, so we need to get the height from
46913          // the iframe at this point when we're about to animate the zoom out.
46914          // The iframe scrollTop, scrollHeight, and clientHeight will all be
46915          // the most accurate.
46916          transitionFromRef.current.scrollTop = iframeDocument.documentElement.scrollTop;
46917          transitionFromRef.current.scrollHeight = iframeDocument.documentElement.scrollHeight;
46918          // Use containerHeight, as it's the previous container height before the zoom out animation starts.
46919          transitionFromRef.current.containerHeight = containerHeight;
46920          transitionToRef.current = {
46921            scaleValue,
46922            frameSize,
46923            containerHeight: iframeDocument.documentElement.clientHeight // use clientHeight to get the actual height of the new container after zoom state changes have rendered, as it will be the most up-to-date.
46924          };
46925          transitionToRef.current.scrollHeight = computeScrollHeightNext(transitionFromRef.current, transitionToRef.current);
46926          transitionToRef.current.scrollTop = computeScrollTopNext(transitionFromRef.current, transitionToRef.current);
46927          animationRef.current = startZoomOutAnimation();
46928  
46929          // If the user prefers reduced motion, finish the animation immediately and set the final state.
46930          if (prefersReducedMotion) {
46931            finishZoomOutAnimation();
46932          } else {
46933            animationRef.current.onfinish = finishZoomOutAnimation;
46934          }
46935        }
46936      }
46937    }, [startZoomOutAnimation, finishZoomOutAnimation, prefersReducedMotion, isAutoScaled, scaleValue, frameSize, iframeDocument, contentHeight, containerWidth, containerHeight, maxContainerWidth, scaleContainerWidth]);
46938    return {
46939      isZoomedOut,
46940      scaleContainerWidth,
46941      contentResizeListener,
46942      containerResizeListener
46943    };
46944  }
46945  
46946  ;// ./node_modules/@wordpress/block-editor/build-module/components/iframe/index.js
46947  /* wp:polyfill */
46948  /**
46949   * External dependencies
46950   */
46951  
46952  
46953  /**
46954   * WordPress dependencies
46955   */
46956  
46957  
46958  
46959  
46960  
46961  
46962  /**
46963   * Internal dependencies
46964   */
46965  
46966  
46967  
46968  
46969  
46970  
46971  function bubbleEvent(event, Constructor, frame) {
46972    const init = {};
46973    for (const key in event) {
46974      init[key] = event[key];
46975    }
46976  
46977    // Check if the event is a MouseEvent generated within the iframe.
46978    // If so, adjust the coordinates to be relative to the position of
46979    // the iframe. This ensures that components such as Draggable
46980    // receive coordinates relative to the window, instead of relative
46981    // to the iframe. Without this, the Draggable event handler would
46982    // result in components "jumping" position as soon as the user
46983    // drags over the iframe.
46984    if (event instanceof frame.contentDocument.defaultView.MouseEvent) {
46985      const rect = frame.getBoundingClientRect();
46986      init.clientX += rect.left;
46987      init.clientY += rect.top;
46988    }
46989    const newEvent = new Constructor(event.type, init);
46990    if (init.defaultPrevented) {
46991      newEvent.preventDefault();
46992    }
46993    const cancelled = !frame.dispatchEvent(newEvent);
46994    if (cancelled) {
46995      event.preventDefault();
46996    }
46997  }
46998  
46999  /**
47000   * Bubbles some event types (keydown, keypress, and dragover) to parent document
47001   * document to ensure that the keyboard shortcuts and drag and drop work.
47002   *
47003   * Ideally, we should remove event bubbling in the future. Keyboard shortcuts
47004   * should be context dependent, e.g. actions on blocks like Cmd+A should not
47005   * work globally outside the block editor.
47006   *
47007   * @param {Document} iframeDocument Document to attach listeners to.
47008   */
47009  function useBubbleEvents(iframeDocument) {
47010    return (0,external_wp_compose_namespaceObject.useRefEffect)(() => {
47011      const {
47012        defaultView
47013      } = iframeDocument;
47014      if (!defaultView) {
47015        return;
47016      }
47017      const {
47018        frameElement
47019      } = defaultView;
47020      const html = iframeDocument.documentElement;
47021      const eventTypes = ['dragover', 'mousemove'];
47022      const handlers = {};
47023      for (const name of eventTypes) {
47024        handlers[name] = event => {
47025          const prototype = Object.getPrototypeOf(event);
47026          const constructorName = prototype.constructor.name;
47027          const Constructor = window[constructorName];
47028          bubbleEvent(event, Constructor, frameElement);
47029        };
47030        html.addEventListener(name, handlers[name]);
47031      }
47032      return () => {
47033        for (const name of eventTypes) {
47034          html.removeEventListener(name, handlers[name]);
47035        }
47036      };
47037    });
47038  }
47039  function Iframe({
47040    contentRef,
47041    children,
47042    tabIndex = 0,
47043    scale = 1,
47044    frameSize = 0,
47045    readonly,
47046    forwardedRef: ref,
47047    title = (0,external_wp_i18n_namespaceObject.__)('Editor canvas'),
47048    ...props
47049  }) {
47050    const {
47051      resolvedAssets,
47052      isPreviewMode
47053    } = (0,external_wp_data_namespaceObject.useSelect)(select => {
47054      const {
47055        getSettings
47056      } = select(store);
47057      const settings = getSettings();
47058      return {
47059        resolvedAssets: settings.__unstableResolvedAssets,
47060        isPreviewMode: settings.isPreviewMode
47061      };
47062    }, []);
47063    const {
47064      styles = '',
47065      scripts = ''
47066    } = resolvedAssets;
47067    /** @type {[Document, import('react').Dispatch<Document>]} */
47068    const [iframeDocument, setIframeDocument] = (0,external_wp_element_namespaceObject.useState)();
47069    const [bodyClasses, setBodyClasses] = (0,external_wp_element_namespaceObject.useState)([]);
47070    const clearerRef = useBlockSelectionClearer();
47071    const [before, writingFlowRef, after] = useWritingFlow();
47072    const setRef = (0,external_wp_compose_namespaceObject.useRefEffect)(node => {
47073      node._load = () => {
47074        setIframeDocument(node.contentDocument);
47075      };
47076      let iFrameDocument;
47077      // Prevent the default browser action for files dropped outside of dropzones.
47078      function preventFileDropDefault(event) {
47079        event.preventDefault();
47080      }
47081      const {
47082        ownerDocument
47083      } = node;
47084  
47085      // Ideally ALL classes that are added through get_body_class should
47086      // be added in the editor too, which we'll somehow have to get from
47087      // the server in the future (which will run the PHP filters).
47088      setBodyClasses(Array.from(ownerDocument.body.classList).filter(name => name.startsWith('admin-color-') || name.startsWith('post-type-') || name === 'wp-embed-responsive'));
47089      function onLoad() {
47090        const {
47091          contentDocument
47092        } = node;
47093        const {
47094          documentElement
47095        } = contentDocument;
47096        iFrameDocument = contentDocument;
47097        documentElement.classList.add('block-editor-iframe__html');
47098        clearerRef(documentElement);
47099        contentDocument.dir = ownerDocument.dir;
47100        for (const compatStyle of getCompatibilityStyles()) {
47101          if (contentDocument.getElementById(compatStyle.id)) {
47102            continue;
47103          }
47104          contentDocument.head.appendChild(compatStyle.cloneNode(true));
47105          if (!isPreviewMode) {
47106            // eslint-disable-next-line no-console
47107            console.warn(`$compatStyle.id} was added to the iframe incorrectly. Please use block.json or enqueue_block_assets to add styles to the iframe.`, compatStyle);
47108          }
47109        }
47110        iFrameDocument.addEventListener('dragover', preventFileDropDefault, false);
47111        iFrameDocument.addEventListener('drop', preventFileDropDefault, false);
47112        // Prevent clicks on links from navigating away. Note that links
47113        // inside `contenteditable` are already disabled by the browser, so
47114        // this is for links in blocks outside of `contenteditable`.
47115        iFrameDocument.addEventListener('click', event => {
47116          if (event.target.tagName === 'A') {
47117            event.preventDefault();
47118  
47119            // Appending a hash to the current URL will not reload the
47120            // page. This is useful for e.g. footnotes.
47121            const href = event.target.getAttribute('href');
47122            if (href?.startsWith('#')) {
47123              iFrameDocument.defaultView.location.hash = href.slice(1);
47124            }
47125          }
47126        });
47127      }
47128      node.addEventListener('load', onLoad);
47129      return () => {
47130        delete node._load;
47131        node.removeEventListener('load', onLoad);
47132        iFrameDocument?.removeEventListener('dragover', preventFileDropDefault);
47133        iFrameDocument?.removeEventListener('drop', preventFileDropDefault);
47134      };
47135    }, []);
47136    const {
47137      contentResizeListener,
47138      containerResizeListener,
47139      isZoomedOut,
47140      scaleContainerWidth
47141    } = useScaleCanvas({
47142      scale,
47143      frameSize: parseInt(frameSize),
47144      iframeDocument
47145    });
47146    const disabledRef = (0,external_wp_compose_namespaceObject.useDisabled)({
47147      isDisabled: !readonly
47148    });
47149    const bodyRef = (0,external_wp_compose_namespaceObject.useMergeRefs)([useBubbleEvents(iframeDocument), contentRef, clearerRef, writingFlowRef, disabledRef]);
47150  
47151    // Correct doctype is required to enable rendering in standards
47152    // mode. Also preload the styles to avoid a flash of unstyled
47153    // content.
47154    const html = `<!doctype html>
47155  <html>
47156      <head>
47157          <meta charset="utf-8">
47158          <base href="$window.location.origin}">
47159          <script>window.frameElement._load()</script>
47160          <style>
47161              html{
47162                  height: auto !important;
47163                  min-height: 100%;
47164              }
47165              /* Lowest specificity to not override global styles */
47166              :where(body) {
47167                  margin: 0;
47168                  /* Default background color in case zoom out mode background
47169                  colors the html element */
47170                  background-color: white;
47171              }
47172          </style>
47173          $styles}
47174          $scripts}
47175      </head>
47176      <body>
47177          <script>document.currentScript.parentElement.remove()</script>
47178      </body>
47179  </html>`;
47180    const [src, cleanup] = (0,external_wp_element_namespaceObject.useMemo)(() => {
47181      const _src = URL.createObjectURL(new window.Blob([html], {
47182        type: 'text/html'
47183      }));
47184      return [_src, () => URL.revokeObjectURL(_src)];
47185    }, [html]);
47186    (0,external_wp_element_namespaceObject.useEffect)(() => cleanup, [cleanup]);
47187  
47188    // Make sure to not render the before and after focusable div elements in view
47189    // mode. They're only needed to capture focus in edit mode.
47190    const shouldRenderFocusCaptureElements = tabIndex >= 0 && !isPreviewMode;
47191    const iframe = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
47192      children: [shouldRenderFocusCaptureElements && before, /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("iframe", {
47193        ...props,
47194        style: {
47195          ...props.style,
47196          height: props.style?.height,
47197          border: 0
47198        },
47199        ref: (0,external_wp_compose_namespaceObject.useMergeRefs)([ref, setRef]),
47200        tabIndex: tabIndex
47201        // Correct doctype is required to enable rendering in standards
47202        // mode. Also preload the styles to avoid a flash of unstyled
47203        // content.
47204        ,
47205        src: src,
47206        title: title,
47207        onKeyDown: event => {
47208          if (props.onKeyDown) {
47209            props.onKeyDown(event);
47210          }
47211          // If the event originates from inside the iframe, it means
47212          // it bubbled through the portal, but only with React
47213          // events. We need to to bubble native events as well,
47214          // though by doing so we also trigger another React event,
47215          // so we need to stop the propagation of this event to avoid
47216          // duplication.
47217          if (event.currentTarget.ownerDocument !== event.target.ownerDocument) {
47218            // We should only stop propagation of the React event,
47219            // the native event should further bubble inside the
47220            // iframe to the document and window.
47221            // Alternatively, we could consider redispatching the
47222            // native event in the iframe.
47223            const {
47224              stopPropagation
47225            } = event.nativeEvent;
47226            event.nativeEvent.stopPropagation = () => {};
47227            event.stopPropagation();
47228            event.nativeEvent.stopPropagation = stopPropagation;
47229            bubbleEvent(event, window.KeyboardEvent, event.currentTarget);
47230          }
47231        },
47232        children: iframeDocument && (0,external_wp_element_namespaceObject.createPortal)(
47233        /*#__PURE__*/
47234        // We want to prevent React events from bubbling through the iframe
47235        // we bubble these manually.
47236        /* eslint-disable-next-line jsx-a11y/no-noninteractive-element-interactions */
47237        (0,external_ReactJSXRuntime_namespaceObject.jsxs)("body", {
47238          ref: bodyRef,
47239          className: dist_clsx('block-editor-iframe__body', 'editor-styles-wrapper', ...bodyClasses),
47240          children: [contentResizeListener, /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalStyleProvider, {
47241            document: iframeDocument,
47242            children: children
47243          })]
47244        }), iframeDocument.documentElement)
47245      }), shouldRenderFocusCaptureElements && after]
47246    });
47247    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
47248      className: "block-editor-iframe__container",
47249      children: [containerResizeListener, /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
47250        className: dist_clsx('block-editor-iframe__scale-container', isZoomedOut && 'is-zoomed-out'),
47251        style: {
47252          '--wp-block-editor-iframe-zoom-out-scale-container-width': isZoomedOut && `$scaleContainerWidth}px`
47253        },
47254        children: iframe
47255      })]
47256    });
47257  }
47258  function IframeIfReady(props, ref) {
47259    const isInitialised = (0,external_wp_data_namespaceObject.useSelect)(select => select(store).getSettings().__internalIsInitialized, []);
47260  
47261    // We shouldn't render the iframe until the editor settings are initialised.
47262    // The initial settings are needed to get the styles for the srcDoc, which
47263    // cannot be changed after the iframe is mounted. srcDoc is used to to set
47264    // the initial iframe HTML, which is required to avoid a flash of unstyled
47265    // content.
47266    if (!isInitialised) {
47267      return null;
47268    }
47269    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Iframe, {
47270      ...props,
47271      forwardedRef: ref
47272    });
47273  }
47274  /* harmony default export */ const iframe = ((0,external_wp_element_namespaceObject.forwardRef)(IframeIfReady));
47275  
47276  ;// ./node_modules/parsel-js/dist/parsel.js
47277  const TOKENS = {
47278      attribute: /\[\s*(?:(?<namespace>\*|[-\w\P{ASCII}]*)\|)?(?<name>[-\w\P{ASCII}]+)\s*(?:(?<operator>\W?=)\s*(?<value>.+?)\s*(\s(?<caseSensitive>[iIsS]))?\s*)?\]/gu,
47279      id: /#(?<name>[-\w\P{ASCII}]+)/gu,
47280      class: /\.(?<name>[-\w\P{ASCII}]+)/gu,
47281      comma: /\s*,\s*/g,
47282      combinator: /\s*[\s>+~]\s*/g,
47283      'pseudo-element': /::(?<name>[-\w\P{ASCII}]+)(?:\((?<argument>¶*)\))?/gu,
47284      'pseudo-class': /:(?<name>[-\w\P{ASCII}]+)(?:\((?<argument>¶*)\))?/gu,
47285      universal: /(?:(?<namespace>\*|[-\w\P{ASCII}]*)\|)?\*/gu,
47286      type: /(?:(?<namespace>\*|[-\w\P{ASCII}]*)\|)?(?<name>[-\w\P{ASCII}]+)/gu, // this must be last
47287  };
47288  const TRIM_TOKENS = new Set(['combinator', 'comma']);
47289  const RECURSIVE_PSEUDO_CLASSES = new Set([
47290      'not',
47291      'is',
47292      'where',
47293      'has',
47294      'matches',
47295      '-moz-any',
47296      '-webkit-any',
47297      'nth-child',
47298      'nth-last-child',
47299  ]);
47300  const nthChildRegExp = /(?<index>[\dn+-]+)\s+of\s+(?<subtree>.+)/;
47301  const RECURSIVE_PSEUDO_CLASSES_ARGS = {
47302      'nth-child': nthChildRegExp,
47303      'nth-last-child': nthChildRegExp,
47304  };
47305  const getArgumentPatternByType = (type) => {
47306      switch (type) {
47307          case 'pseudo-element':
47308          case 'pseudo-class':
47309              return new RegExp(TOKENS[type].source.replace('(?<argument>¶*)', '(?<argument>.*)'), 'gu');
47310          default:
47311              return TOKENS[type];
47312      }
47313  };
47314  function gobbleParens(text, offset) {
47315      let nesting = 0;
47316      let result = '';
47317      for (; offset < text.length; offset++) {
47318          const char = text[offset];
47319          switch (char) {
47320              case '(':
47321                  ++nesting;
47322                  break;
47323              case ')':
47324                  --nesting;
47325                  break;
47326          }
47327          result += char;
47328          if (nesting === 0) {
47329              return result;
47330          }
47331      }
47332      return result;
47333  }
47334  function tokenizeBy(text, grammar = TOKENS) {
47335      if (!text) {
47336          return [];
47337      }
47338      const tokens = [text];
47339      for (const [type, pattern] of Object.entries(grammar)) {
47340          for (let i = 0; i < tokens.length; i++) {
47341              const token = tokens[i];
47342              if (typeof token !== 'string') {
47343                  continue;
47344              }
47345              pattern.lastIndex = 0;
47346              const match = pattern.exec(token);
47347              if (!match) {
47348                  continue;
47349              }
47350              const from = match.index - 1;
47351              const args = [];
47352              const content = match[0];
47353              const before = token.slice(0, from + 1);
47354              if (before) {
47355                  args.push(before);
47356              }
47357              args.push({
47358                  ...match.groups,
47359                  type,
47360                  content,
47361              });
47362              const after = token.slice(from + content.length + 1);
47363              if (after) {
47364                  args.push(after);
47365              }
47366              tokens.splice(i, 1, ...args);
47367          }
47368      }
47369      let offset = 0;
47370      for (const token of tokens) {
47371          switch (typeof token) {
47372              case 'string':
47373                  throw new Error(`Unexpected sequence $token} found at index $offset}`);
47374              case 'object':
47375                  offset += token.content.length;
47376                  token.pos = [offset - token.content.length, offset];
47377                  if (TRIM_TOKENS.has(token.type)) {
47378                      token.content = token.content.trim() || ' ';
47379                  }
47380                  break;
47381          }
47382      }
47383      return tokens;
47384  }
47385  const STRING_PATTERN = /(['"])([^\\\n]+?)\1/g;
47386  const ESCAPE_PATTERN = /\\./g;
47387  function parsel_tokenize(selector, grammar = TOKENS) {
47388      // Prevent leading/trailing whitespaces from being interpreted as combinators
47389      selector = selector.trim();
47390      if (selector === '') {
47391          return [];
47392      }
47393      const replacements = [];
47394      // Replace escapes with placeholders.
47395      selector = selector.replace(ESCAPE_PATTERN, (value, offset) => {
47396          replacements.push({ value, offset });
47397          return '\uE000'.repeat(value.length);
47398      });
47399      // Replace strings with placeholders.
47400      selector = selector.replace(STRING_PATTERN, (value, quote, content, offset) => {
47401          replacements.push({ value, offset });
47402          return `$quote}${'\uE001'.repeat(content.length)}$quote}`;
47403      });
47404      // Replace parentheses with placeholders.
47405      {
47406          let pos = 0;
47407          let offset;
47408          while ((offset = selector.indexOf('(', pos)) > -1) {
47409              const value = gobbleParens(selector, offset);
47410              replacements.push({ value, offset });
47411              selector = `$selector.substring(0, offset)}(${'¶'.repeat(value.length - 2)})$selector.substring(offset + value.length)}`;
47412              pos = offset + value.length;
47413          }
47414      }
47415      // Now we have no nested structures and we can parse with regexes
47416      const tokens = tokenizeBy(selector, grammar);
47417      // Replace placeholders in reverse order.
47418      const changedTokens = new Set();
47419      for (const replacement of replacements.reverse()) {
47420          for (const token of tokens) {
47421              const { offset, value } = replacement;
47422              if (!(token.pos[0] <= offset &&
47423                  offset + value.length <= token.pos[1])) {
47424                  continue;
47425              }
47426              const { content } = token;
47427              const tokenOffset = offset - token.pos[0];
47428              token.content =
47429                  content.slice(0, tokenOffset) +
47430                      value +
47431                      content.slice(tokenOffset + value.length);
47432              if (token.content !== content) {
47433                  changedTokens.add(token);
47434              }
47435          }
47436      }
47437      // Update changed tokens.
47438      for (const token of changedTokens) {
47439          const pattern = getArgumentPatternByType(token.type);
47440          if (!pattern) {
47441              throw new Error(`Unknown token type: $token.type}`);
47442          }
47443          pattern.lastIndex = 0;
47444          const match = pattern.exec(token.content);
47445          if (!match) {
47446              throw new Error(`Unable to parse content for $token.type}: $token.content}`);
47447          }
47448          Object.assign(token, match.groups);
47449      }
47450      return tokens;
47451  }
47452  /**
47453   *  Convert a flat list of tokens into a tree of complex & compound selectors
47454   */
47455  function nestTokens(tokens, { list = true } = {}) {
47456      if (list && tokens.find((t) => t.type === 'comma')) {
47457          const selectors = [];
47458          const temp = [];
47459          for (let i = 0; i < tokens.length; i++) {
47460              if (tokens[i].type === 'comma') {
47461                  if (temp.length === 0) {
47462                      throw new Error('Incorrect comma at ' + i);
47463                  }
47464                  selectors.push(nestTokens(temp, { list: false }));
47465                  temp.length = 0;
47466              }
47467              else {
47468                  temp.push(tokens[i]);
47469              }
47470          }
47471          if (temp.length === 0) {
47472              throw new Error('Trailing comma');
47473          }
47474          else {
47475              selectors.push(nestTokens(temp, { list: false }));
47476          }
47477          return { type: 'list', list: selectors };
47478      }
47479      for (let i = tokens.length - 1; i >= 0; i--) {
47480          let token = tokens[i];
47481          if (token.type === 'combinator') {
47482              let left = tokens.slice(0, i);
47483              let right = tokens.slice(i + 1);
47484              return {
47485                  type: 'complex',
47486                  combinator: token.content,
47487                  left: nestTokens(left),
47488                  right: nestTokens(right),
47489              };
47490          }
47491      }
47492      switch (tokens.length) {
47493          case 0:
47494              throw new Error('Could not build AST.');
47495          case 1:
47496              // If we're here, there are no combinators, so it's just a list.
47497              return tokens[0];
47498          default:
47499              return {
47500                  type: 'compound',
47501                  list: [...tokens], // clone to avoid pointers messing up the AST
47502              };
47503      }
47504  }
47505  /**
47506   * Traverse an AST in depth-first order
47507   */
47508  function* flatten(node, 
47509  /**
47510   * @internal
47511   */
47512  parent) {
47513      switch (node.type) {
47514          case 'list':
47515              for (let child of node.list) {
47516                  yield* flatten(child, node);
47517              }
47518              break;
47519          case 'complex':
47520              yield* flatten(node.left, node);
47521              yield* flatten(node.right, node);
47522              break;
47523          case 'compound':
47524              yield* node.list.map((token) => [token, node]);
47525              break;
47526          default:
47527              yield [node, parent];
47528      }
47529  }
47530  /**
47531   * Traverse an AST (or part thereof), in depth-first order
47532   */
47533  function walk(node, visit, 
47534  /**
47535   * @internal
47536   */
47537  parent) {
47538      if (!node) {
47539          return;
47540      }
47541      for (const [token, ast] of flatten(node, parent)) {
47542          visit(token, ast);
47543      }
47544  }
47545  /**
47546   * Parse a CSS selector
47547   *
47548   * @param selector - The selector to parse
47549   * @param options.recursive - Whether to parse the arguments of pseudo-classes like :is(), :has() etc. Defaults to true.
47550   * @param options.list - Whether this can be a selector list (A, B, C etc). Defaults to true.
47551   */
47552  function parse(selector, { recursive = true, list = true } = {}) {
47553      const tokens = parsel_tokenize(selector);
47554      if (!tokens) {
47555          return;
47556      }
47557      const ast = nestTokens(tokens, { list });
47558      if (!recursive) {
47559          return ast;
47560      }
47561      for (const [token] of flatten(ast)) {
47562          if (token.type !== 'pseudo-class' || !token.argument) {
47563              continue;
47564          }
47565          if (!RECURSIVE_PSEUDO_CLASSES.has(token.name)) {
47566              continue;
47567          }
47568          let argument = token.argument;
47569          const childArg = RECURSIVE_PSEUDO_CLASSES_ARGS[token.name];
47570          if (childArg) {
47571              const match = childArg.exec(argument);
47572              if (!match) {
47573                  continue;
47574              }
47575              Object.assign(token, match.groups);
47576              argument = match.groups['subtree'];
47577          }
47578          if (!argument) {
47579              continue;
47580          }
47581          Object.assign(token, {
47582              subtree: parse(argument, {
47583                  recursive: true,
47584                  list: true,
47585              }),
47586          });
47587      }
47588      return ast;
47589  }
47590  /**
47591   * Converts the given list or (sub)tree to a string.
47592   */
47593  function parsel_stringify(listOrNode) {
47594      let tokens;
47595      if (Array.isArray(listOrNode)) {
47596          tokens = listOrNode;
47597      }
47598      else {
47599          tokens = [...flatten(listOrNode)].map(([token]) => token);
47600      }
47601      return tokens.map(token => token.content).join('');
47602  }
47603  /**
47604   * To convert the specificity array to a number
47605   */
47606  function specificityToNumber(specificity, base) {
47607      base = base || Math.max(...specificity) + 1;
47608      return (specificity[0] * (base << 1) + specificity[1] * base + specificity[2]);
47609  }
47610  /**
47611   * Calculate specificity of a selector.
47612   *
47613   * If the selector is a list, the max specificity is returned.
47614   */
47615  function specificity(selector) {
47616      let ast = selector;
47617      if (typeof ast === 'string') {
47618          ast = parse(ast, { recursive: true });
47619      }
47620      if (!ast) {
47621          return [];
47622      }
47623      if (ast.type === 'list' && 'list' in ast) {
47624          let base = 10;
47625          const specificities = ast.list.map((ast) => {
47626              const sp = specificity(ast);
47627              base = Math.max(base, ...specificity(ast));
47628              return sp;
47629          });
47630          const numbers = specificities.map((ast) => specificityToNumber(ast, base));
47631          return specificities[numbers.indexOf(Math.max(...numbers))];
47632      }
47633      const ret = [0, 0, 0];
47634      for (const [token] of flatten(ast)) {
47635          switch (token.type) {
47636              case 'id':
47637                  ret[0]++;
47638                  break;
47639              case 'class':
47640              case 'attribute':
47641                  ret[1]++;
47642                  break;
47643              case 'pseudo-element':
47644              case 'type':
47645                  ret[2]++;
47646                  break;
47647              case 'pseudo-class':
47648                  if (token.name === 'where') {
47649                      break;
47650                  }
47651                  if (!RECURSIVE_PSEUDO_CLASSES.has(token.name) ||
47652                      !token.subtree) {
47653                      ret[1]++;
47654                      break;
47655                  }
47656                  const sub = specificity(token.subtree);
47657                  sub.forEach((s, i) => (ret[i] += s));
47658                  // :nth-child() & :nth-last-child() add (0, 1, 0) to the specificity of their most complex selector
47659                  if (token.name === 'nth-child' ||
47660                      token.name === 'nth-last-child') {
47661                      ret[1]++;
47662                  }
47663          }
47664      }
47665      return ret;
47666  }
47667  
47668  
47669  
47670  // EXTERNAL MODULE: ./node_modules/postcss/lib/processor.js
47671  var processor = __webpack_require__(9656);
47672  var processor_default = /*#__PURE__*/__webpack_require__.n(processor);
47673  // EXTERNAL MODULE: ./node_modules/postcss/lib/css-syntax-error.js
47674  var css_syntax_error = __webpack_require__(356);
47675  var css_syntax_error_default = /*#__PURE__*/__webpack_require__.n(css_syntax_error);
47676  // EXTERNAL MODULE: ./node_modules/postcss-prefix-selector/index.js
47677  var postcss_prefix_selector = __webpack_require__(1443);
47678  var postcss_prefix_selector_default = /*#__PURE__*/__webpack_require__.n(postcss_prefix_selector);
47679  // EXTERNAL MODULE: ./node_modules/postcss-urlrebase/index.js
47680  var postcss_urlrebase = __webpack_require__(5404);
47681  var postcss_urlrebase_default = /*#__PURE__*/__webpack_require__.n(postcss_urlrebase);
47682  ;// ./node_modules/@wordpress/block-editor/build-module/utils/transform-styles/index.js
47683  /**
47684   * External dependencies
47685   */
47686  
47687  
47688  
47689  
47690  
47691  const cacheByWrapperSelector = new Map();
47692  const ROOT_SELECTOR_TOKENS = [{
47693    type: 'type',
47694    content: 'body'
47695  }, {
47696    type: 'type',
47697    content: 'html'
47698  }, {
47699    type: 'pseudo-class',
47700    content: ':root'
47701  }, {
47702    type: 'pseudo-class',
47703    content: ':where(body)'
47704  }, {
47705    type: 'pseudo-class',
47706    content: ':where(:root)'
47707  }, {
47708    type: 'pseudo-class',
47709    content: ':where(html)'
47710  }];
47711  
47712  /**
47713   * Prefixes root selectors in a way that ensures consistent specificity.
47714   * This requires special handling, since prefixing a classname before
47715   * html, body, or :root will generally result in an invalid selector.
47716   *
47717   * Some libraries will simply replace the root selector with the prefix
47718   * instead, but this results in inconsistent specificity.
47719   *
47720   * This function instead inserts the prefix after the root tags but before
47721   * any other part of the selector. This results in consistent specificity:
47722   * - If a `:where()` selector is used for the prefix, all selectors output
47723   *   by `transformStyles` will have no specificity increase.
47724   * - If a classname, id, or something else is used as the prefix, all selectors
47725   *   will have the same specificity bump when transformed.
47726   *
47727   * @param {string} prefix   The prefix.
47728   * @param {string} selector The selector.
47729   *
47730   * @return {string} The prefixed root selector.
47731   */
47732  function prefixRootSelector(prefix, selector) {
47733    // Use a tokenizer, since regular expressions are unreliable.
47734    const tokenized = parsel_tokenize(selector);
47735  
47736    // Find the last token that contains a root selector by walking back
47737    // through the tokens.
47738    const lastRootIndex = tokenized.findLastIndex(({
47739      content,
47740      type
47741    }) => {
47742      return ROOT_SELECTOR_TOKENS.some(rootSelector => content === rootSelector.content && type === rootSelector.type);
47743    });
47744  
47745    // Walk forwards to find the combinator after the last root.
47746    // This is where the root ends and the rest of the selector begins,
47747    // and the index to insert before.
47748    // Doing it this way takes into account that a root selector like
47749    // 'body' may have additional id/class/pseudo-class/attribute-selector
47750    // parts chained to it, which is difficult to quantify using a regex.
47751    let insertionPoint = -1;
47752    for (let i = lastRootIndex + 1; i < tokenized.length; i++) {
47753      if (tokenized[i].type === 'combinator') {
47754        insertionPoint = i;
47755        break;
47756      }
47757    }
47758  
47759    // Tokenize and insert the prefix with a ' ' combinator before it.
47760    const tokenizedPrefix = parsel_tokenize(prefix);
47761    tokenized.splice(
47762    // Insert at the insertion point, or the end.
47763    insertionPoint === -1 ? tokenized.length : insertionPoint, 0, {
47764      type: 'combinator',
47765      content: ' '
47766    }, ...tokenizedPrefix);
47767    return parsel_stringify(tokenized);
47768  }
47769  function transformStyle({
47770    css,
47771    ignoredSelectors = [],
47772    baseURL
47773  }, wrapperSelector = '', transformOptions) {
47774    // When there is no wrapper selector and no base URL, there is no need
47775    // to transform the CSS. This is most cases because in the default
47776    // iframed editor, no wrapping is needed, and not many styles
47777    // provide a base URL.
47778    if (!wrapperSelector && !baseURL) {
47779      return css;
47780    }
47781    try {
47782      var _transformOptions$ign;
47783      const excludedSelectors = [...ignoredSelectors, ...((_transformOptions$ign = transformOptions?.ignoredSelectors) !== null && _transformOptions$ign !== void 0 ? _transformOptions$ign : []), wrapperSelector];
47784      return new (processor_default())([wrapperSelector && postcss_prefix_selector_default()({
47785        prefix: wrapperSelector,
47786        transform(prefix, selector, prefixedSelector) {
47787          // For backwards compatibility, don't use the `exclude` option
47788          // of postcss-prefix-selector, instead handle it here to match
47789          // the behavior of the old library (postcss-prefix-wrap) that
47790          // `transformStyle` previously used.
47791          if (excludedSelectors.some(excludedSelector => excludedSelector instanceof RegExp ? selector.match(excludedSelector) : selector.includes(excludedSelector))) {
47792            return selector;
47793          }
47794          const hasRootSelector = ROOT_SELECTOR_TOKENS.some(rootSelector => selector.startsWith(rootSelector.content));
47795  
47796          // Reorganize root selectors such that the root part comes before the prefix,
47797          // but the prefix still comes before the remaining part of the selector.
47798          if (hasRootSelector) {
47799            return prefixRootSelector(prefix, selector);
47800          }
47801          return prefixedSelector;
47802        }
47803      }), baseURL && postcss_urlrebase_default()({
47804        rootUrl: baseURL
47805      })].filter(Boolean)).process(css, {}).css; // use sync PostCSS API
47806    } catch (error) {
47807      if (error instanceof (css_syntax_error_default())) {
47808        // eslint-disable-next-line no-console
47809        console.warn('wp.blockEditor.transformStyles Failed to transform CSS.', error.message + '\n' + error.showSourceCode(false));
47810      } else {
47811        // eslint-disable-next-line no-console
47812        console.warn('wp.blockEditor.transformStyles Failed to transform CSS.', error);
47813      }
47814      return null;
47815    }
47816  }
47817  
47818  /**
47819   * @typedef {Object} EditorStyle
47820   * @property {string}    css              the CSS block(s), as a single string.
47821   * @property {?string}   baseURL          the base URL to be used as the reference when rewriting urls.
47822   * @property {?string[]} ignoredSelectors the selectors not to wrap.
47823   */
47824  
47825  /**
47826   * @typedef {Object} TransformOptions
47827   * @property {?string[]} ignoredSelectors the selectors not to wrap.
47828   */
47829  
47830  /**
47831   * Applies a series of CSS rule transforms to wrap selectors inside a given class and/or rewrite URLs depending on the parameters passed.
47832   *
47833   * @param {EditorStyle[]}    styles           CSS rules.
47834   * @param {string}           wrapperSelector  Wrapper selector.
47835   * @param {TransformOptions} transformOptions Additional options for style transformation.
47836   * @return {Array} converted rules.
47837   */
47838  const transform_styles_transformStyles = (styles, wrapperSelector = '', transformOptions) => {
47839    let cache = cacheByWrapperSelector.get(wrapperSelector);
47840    if (!cache) {
47841      cache = new WeakMap();
47842      cacheByWrapperSelector.set(wrapperSelector, cache);
47843    }
47844    return styles.map(style => {
47845      let css = cache.get(style);
47846      if (!css) {
47847        css = transformStyle(style, wrapperSelector, transformOptions);
47848        cache.set(style, css);
47849      }
47850      return css;
47851    });
47852  };
47853  /* harmony default export */ const transform_styles = (transform_styles_transformStyles);
47854  
47855  ;// ./node_modules/@wordpress/block-editor/build-module/components/editor-styles/index.js
47856  /**
47857   * External dependencies
47858   */
47859  
47860  
47861  
47862  
47863  /**
47864   * WordPress dependencies
47865   */
47866  
47867  
47868  
47869  
47870  /**
47871   * Internal dependencies
47872   */
47873  
47874  
47875  
47876  
47877  k([names, a11y]);
47878  function useDarkThemeBodyClassName(styles, scope) {
47879    return (0,external_wp_element_namespaceObject.useCallback)(node => {
47880      if (!node) {
47881        return;
47882      }
47883      const {
47884        ownerDocument
47885      } = node;
47886      const {
47887        defaultView,
47888        body
47889      } = ownerDocument;
47890      const canvas = scope ? ownerDocument.querySelector(scope) : body;
47891      let backgroundColor;
47892      if (!canvas) {
47893        // The real .editor-styles-wrapper element might not exist in the
47894        // DOM, so calculate the background color by creating a fake
47895        // wrapper.
47896        const tempCanvas = ownerDocument.createElement('div');
47897        tempCanvas.classList.add('editor-styles-wrapper');
47898        body.appendChild(tempCanvas);
47899        backgroundColor = defaultView?.getComputedStyle(tempCanvas, null).getPropertyValue('background-color');
47900        body.removeChild(tempCanvas);
47901      } else {
47902        backgroundColor = defaultView?.getComputedStyle(canvas, null).getPropertyValue('background-color');
47903      }
47904      const colordBackgroundColor = w(backgroundColor);
47905      // If background is transparent, it should be treated as light color.
47906      if (colordBackgroundColor.luminance() > 0.5 || colordBackgroundColor.alpha() === 0) {
47907        body.classList.remove('is-dark-theme');
47908      } else {
47909        body.classList.add('is-dark-theme');
47910      }
47911    }, [styles, scope]);
47912  }
47913  function EditorStyles({
47914    styles,
47915    scope,
47916    transformOptions
47917  }) {
47918    const overrides = (0,external_wp_data_namespaceObject.useSelect)(select => unlock(select(store)).getStyleOverrides(), []);
47919    const [transformedStyles, transformedSvgs] = (0,external_wp_element_namespaceObject.useMemo)(() => {
47920      const _styles = Object.values(styles !== null && styles !== void 0 ? styles : []);
47921      for (const [id, override] of overrides) {
47922        const index = _styles.findIndex(({
47923          id: _id
47924        }) => id === _id);
47925        const overrideWithId = {
47926          ...override,
47927          id
47928        };
47929        if (index === -1) {
47930          _styles.push(overrideWithId);
47931        } else {
47932          _styles[index] = overrideWithId;
47933        }
47934      }
47935      return [transform_styles(_styles.filter(style => style?.css), scope, transformOptions), _styles.filter(style => style.__unstableType === 'svgs').map(style => style.assets).join('')];
47936    }, [styles, overrides, scope, transformOptions]);
47937    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
47938      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("style", {
47939        ref: useDarkThemeBodyClassName(transformedStyles, scope)
47940      }), transformedStyles.map((css, index) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("style", {
47941        children: css
47942      }, index)), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.SVG, {
47943        xmlns: "http://www.w3.org/2000/svg",
47944        viewBox: "0 0 0 0",
47945        width: "0",
47946        height: "0",
47947        role: "none",
47948        style: {
47949          visibility: 'hidden',
47950          position: 'absolute',
47951          left: '-9999px',
47952          overflow: 'hidden'
47953        },
47954        dangerouslySetInnerHTML: {
47955          __html: transformedSvgs
47956        }
47957      })]
47958    });
47959  }
47960  /* harmony default export */ const editor_styles = ((0,external_wp_element_namespaceObject.memo)(EditorStyles));
47961  
47962  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-preview/auto.js
47963  /**
47964   * WordPress dependencies
47965   */
47966  
47967  
47968  
47969  
47970  
47971  /**
47972   * Internal dependencies
47973   */
47974  
47975  
47976  
47977  
47978  
47979  // This is used to avoid rendering the block list if the sizes change.
47980  
47981  const MemoizedBlockList = (0,external_wp_element_namespaceObject.memo)(BlockList);
47982  const MAX_HEIGHT = 2000;
47983  const EMPTY_ADDITIONAL_STYLES = [];
47984  function ScaledBlockPreview({
47985    viewportWidth,
47986    containerWidth,
47987    minHeight,
47988    additionalStyles = EMPTY_ADDITIONAL_STYLES
47989  }) {
47990    if (!viewportWidth) {
47991      viewportWidth = containerWidth;
47992    }
47993    const [contentResizeListener, {
47994      height: contentHeight
47995    }] = (0,external_wp_compose_namespaceObject.useResizeObserver)();
47996    const {
47997      styles
47998    } = (0,external_wp_data_namespaceObject.useSelect)(select => {
47999      const settings = select(store).getSettings();
48000      return {
48001        styles: settings.styles
48002      };
48003    }, []);
48004  
48005    // Avoid scrollbars for pattern previews.
48006    const editorStyles = (0,external_wp_element_namespaceObject.useMemo)(() => {
48007      if (styles) {
48008        return [...styles, {
48009          css: 'body{height:auto;overflow:hidden;border:none;padding:0;}',
48010          __unstableType: 'presets'
48011        }, ...additionalStyles];
48012      }
48013      return styles;
48014    }, [styles, additionalStyles]);
48015    const scale = containerWidth / viewportWidth;
48016    const aspectRatio = contentHeight ? containerWidth / (contentHeight * scale) : 0;
48017    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Disabled, {
48018      className: "block-editor-block-preview__content",
48019      style: {
48020        transform: `scale($scale})`,
48021        // Using width + aspect-ratio instead of height here triggers browsers' native
48022        // handling of scrollbar's visibility. It prevents the flickering issue seen
48023        // in https://github.com/WordPress/gutenberg/issues/52027.
48024        // See https://github.com/WordPress/gutenberg/pull/52921 for more info.
48025        aspectRatio,
48026        maxHeight: contentHeight > MAX_HEIGHT ? MAX_HEIGHT * scale : undefined,
48027        minHeight
48028      },
48029      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(iframe, {
48030        contentRef: (0,external_wp_compose_namespaceObject.useRefEffect)(bodyElement => {
48031          const {
48032            ownerDocument: {
48033              documentElement
48034            }
48035          } = bodyElement;
48036          documentElement.classList.add('block-editor-block-preview__content-iframe');
48037          documentElement.style.position = 'absolute';
48038          documentElement.style.width = '100%';
48039  
48040          // Necessary for contentResizeListener to work.
48041          bodyElement.style.boxSizing = 'border-box';
48042          bodyElement.style.position = 'absolute';
48043          bodyElement.style.width = '100%';
48044        }, []),
48045        "aria-hidden": true,
48046        tabIndex: -1,
48047        style: {
48048          position: 'absolute',
48049          width: viewportWidth,
48050          height: contentHeight,
48051          pointerEvents: 'none',
48052          // This is a catch-all max-height for patterns.
48053          // See: https://github.com/WordPress/gutenberg/pull/38175.
48054          maxHeight: MAX_HEIGHT,
48055          minHeight: scale !== 0 && scale < 1 && minHeight ? minHeight / scale : minHeight
48056        },
48057        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(editor_styles, {
48058          styles: editorStyles
48059        }), contentResizeListener, /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(MemoizedBlockList, {
48060          renderAppender: false
48061        })]
48062      })
48063    });
48064  }
48065  function AutoBlockPreview(props) {
48066    const [containerResizeListener, {
48067      width: containerWidth
48068    }] = (0,external_wp_compose_namespaceObject.useResizeObserver)();
48069    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
48070      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
48071        style: {
48072          position: 'relative',
48073          width: '100%',
48074          height: 0
48075        },
48076        children: containerResizeListener
48077      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
48078        className: "block-editor-block-preview__container",
48079        children: !!containerWidth && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ScaledBlockPreview, {
48080          ...props,
48081          containerWidth: containerWidth
48082        })
48083      })]
48084    });
48085  }
48086  
48087  ;// external ["wp","priorityQueue"]
48088  const external_wp_priorityQueue_namespaceObject = window["wp"]["priorityQueue"];
48089  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-preview/async.js
48090  /**
48091   * WordPress dependencies
48092   */
48093  
48094  
48095  const blockPreviewQueue = (0,external_wp_priorityQueue_namespaceObject.createQueue)();
48096  
48097  /**
48098   * Renders a component at the next idle time.
48099   * @param {*} props
48100   */
48101  function Async({
48102    children,
48103    placeholder
48104  }) {
48105    const [shouldRender, setShouldRender] = (0,external_wp_element_namespaceObject.useState)(false);
48106  
48107    // In the future, we could try to use startTransition here, but currently
48108    // react will batch all transitions, which means all previews will be
48109    // rendered at the same time.
48110    // https://react.dev/reference/react/startTransition#caveats
48111    // > If there are multiple ongoing Transitions, React currently batches them
48112    // > together. This is a limitation that will likely be removed in a future
48113    // > release.
48114  
48115    (0,external_wp_element_namespaceObject.useEffect)(() => {
48116      const context = {};
48117      blockPreviewQueue.add(context, () => {
48118        // Synchronously run all renders so it consumes timeRemaining.
48119        // See https://github.com/WordPress/gutenberg/pull/48238
48120        (0,external_wp_element_namespaceObject.flushSync)(() => {
48121          setShouldRender(true);
48122        });
48123      });
48124      return () => {
48125        blockPreviewQueue.cancel(context);
48126      };
48127    }, []);
48128    if (!shouldRender) {
48129      return placeholder;
48130    }
48131    return children;
48132  }
48133  
48134  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-preview/index.js
48135  /**
48136   * External dependencies
48137   */
48138  
48139  
48140  /**
48141   * WordPress dependencies
48142   */
48143  
48144  
48145  
48146  
48147  
48148  /**
48149   * Internal dependencies
48150   */
48151  
48152  
48153  
48154  
48155  
48156  
48157  
48158  const block_preview_EMPTY_ADDITIONAL_STYLES = [];
48159  function BlockPreview({
48160    blocks,
48161    viewportWidth = 1200,
48162    minHeight,
48163    additionalStyles = block_preview_EMPTY_ADDITIONAL_STYLES,
48164    // Deprecated props:
48165    __experimentalMinHeight,
48166    __experimentalPadding
48167  }) {
48168    if (__experimentalMinHeight) {
48169      minHeight = __experimentalMinHeight;
48170      external_wp_deprecated_default()('The __experimentalMinHeight prop', {
48171        since: '6.2',
48172        version: '6.4',
48173        alternative: 'minHeight'
48174      });
48175    }
48176    if (__experimentalPadding) {
48177      additionalStyles = [...additionalStyles, {
48178        css: `body { padding: $__experimentalPadding}px; }`
48179      }];
48180      external_wp_deprecated_default()('The __experimentalPadding prop of BlockPreview', {
48181        since: '6.2',
48182        version: '6.4',
48183        alternative: 'additionalStyles'
48184      });
48185    }
48186    const originalSettings = (0,external_wp_data_namespaceObject.useSelect)(select => select(store).getSettings(), []);
48187    const settings = (0,external_wp_element_namespaceObject.useMemo)(() => ({
48188      ...originalSettings,
48189      focusMode: false,
48190      // Disable "Spotlight mode".
48191      isPreviewMode: true
48192    }), [originalSettings]);
48193    const renderedBlocks = (0,external_wp_element_namespaceObject.useMemo)(() => Array.isArray(blocks) ? blocks : [blocks], [blocks]);
48194    if (!blocks || blocks.length === 0) {
48195      return null;
48196    }
48197    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ExperimentalBlockEditorProvider, {
48198      value: renderedBlocks,
48199      settings: settings,
48200      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(AutoBlockPreview, {
48201        viewportWidth: viewportWidth,
48202        minHeight: minHeight,
48203        additionalStyles: additionalStyles
48204      })
48205    });
48206  }
48207  const MemoizedBlockPreview = (0,external_wp_element_namespaceObject.memo)(BlockPreview);
48208  MemoizedBlockPreview.Async = Async;
48209  
48210  /**
48211   * BlockPreview renders a preview of a block or array of blocks.
48212   *
48213   * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/block-preview/README.md
48214   *
48215   * @param {Object}       preview               options for how the preview should be shown
48216   * @param {Array|Object} preview.blocks        A block instance (object) or an array of blocks to be previewed.
48217   * @param {number}       preview.viewportWidth Width of the preview container in pixels. Controls at what size the blocks will be rendered inside the preview. Default: 700.
48218   *
48219   * @return {Component} The component to be rendered.
48220   */
48221  /* harmony default export */ const block_preview = (MemoizedBlockPreview);
48222  
48223  /**
48224   * This hook is used to lightly mark an element as a block preview wrapper
48225   * element. Call this hook and pass the returned props to the element to mark as
48226   * a block preview wrapper, automatically rendering inner blocks as children. If
48227   * you define a ref for the element, it is important to pass the ref to this
48228   * hook, which the hook in turn will pass to the component through the props it
48229   * returns. Optionally, you can also pass any other props through this hook, and
48230   * they will be merged and returned.
48231   *
48232   * @param {Object}    options        Preview options.
48233   * @param {WPBlock[]} options.blocks Block objects.
48234   * @param {Object}    options.props  Optional. Props to pass to the element. Must contain
48235   *                                   the ref if one is defined.
48236   * @param {Object}    options.layout Layout settings to be used in the preview.
48237   */
48238  function useBlockPreview({
48239    blocks,
48240    props = {},
48241    layout
48242  }) {
48243    const originalSettings = (0,external_wp_data_namespaceObject.useSelect)(select => select(store).getSettings(), []);
48244    const settings = (0,external_wp_element_namespaceObject.useMemo)(() => ({
48245      ...originalSettings,
48246      styles: undefined,
48247      // Clear styles included by the parent settings, as they are already output by the parent's EditorStyles.
48248      focusMode: false,
48249      // Disable "Spotlight mode".
48250      isPreviewMode: true
48251    }), [originalSettings]);
48252    const disabledRef = (0,external_wp_compose_namespaceObject.useDisabled)();
48253    const ref = (0,external_wp_compose_namespaceObject.useMergeRefs)([props.ref, disabledRef]);
48254    const renderedBlocks = (0,external_wp_element_namespaceObject.useMemo)(() => Array.isArray(blocks) ? blocks : [blocks], [blocks]);
48255    const children = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(ExperimentalBlockEditorProvider, {
48256      value: renderedBlocks,
48257      settings: settings,
48258      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(editor_styles, {}), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockListItems, {
48259        renderAppender: false,
48260        layout: layout
48261      })]
48262    });
48263    return {
48264      ...props,
48265      ref,
48266      className: dist_clsx(props.className, 'block-editor-block-preview__live-content', 'components-disabled'),
48267      children: blocks?.length ? children : null
48268    };
48269  }
48270  
48271  ;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/preview-panel.js
48272  /**
48273   * WordPress dependencies
48274   */
48275  
48276  
48277  
48278  
48279  /**
48280   * Internal dependencies
48281   */
48282  
48283  
48284  
48285  function InserterPreviewPanel({
48286    item
48287  }) {
48288    var _example$viewportWidt;
48289    const {
48290      name,
48291      title,
48292      icon,
48293      description,
48294      initialAttributes,
48295      example
48296    } = item;
48297    const isReusable = (0,external_wp_blocks_namespaceObject.isReusableBlock)(item);
48298    const blocks = (0,external_wp_element_namespaceObject.useMemo)(() => {
48299      if (!example) {
48300        return (0,external_wp_blocks_namespaceObject.createBlock)(name, initialAttributes);
48301      }
48302      return (0,external_wp_blocks_namespaceObject.getBlockFromExample)(name, {
48303        attributes: {
48304          ...example.attributes,
48305          ...initialAttributes
48306        },
48307        innerBlocks: example.innerBlocks
48308      });
48309    }, [name, example, initialAttributes]);
48310    // Same as height of BlockPreviewPanel.
48311    const previewHeight = 144;
48312    const sidebarWidth = 280;
48313    const viewportWidth = (_example$viewportWidt = example?.viewportWidth) !== null && _example$viewportWidt !== void 0 ? _example$viewportWidt : 500;
48314    const scale = sidebarWidth / viewportWidth;
48315    const minHeight = scale !== 0 && scale < 1 && previewHeight ? previewHeight / scale : previewHeight;
48316    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
48317      className: "block-editor-inserter__preview-container",
48318      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
48319        className: "block-editor-inserter__preview",
48320        children: isReusable || example ? /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
48321          className: "block-editor-inserter__preview-content",
48322          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_preview, {
48323            blocks: blocks,
48324            viewportWidth: viewportWidth,
48325            minHeight: previewHeight,
48326            additionalStyles:
48327            //We want this CSS to be in sync with the one in BlockPreviewPanel.
48328            [{
48329              css: `
48330                                          body { 
48331                                              padding: 24px;
48332                                              min-height:$Math.round(minHeight)}px;
48333                                              display:flex;
48334                                              align-items:center;
48335                                          }
48336                                          .is-root-container { width: 100%; }
48337                                      `
48338            }]
48339          })
48340        }) : /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
48341          className: "block-editor-inserter__preview-content-missing",
48342          children: (0,external_wp_i18n_namespaceObject.__)('No preview available.')
48343        })
48344      }), !isReusable && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_card, {
48345        title: title,
48346        icon: icon,
48347        description: description
48348      })]
48349    });
48350  }
48351  /* harmony default export */ const preview_panel = (InserterPreviewPanel);
48352  
48353  ;// ./node_modules/@wordpress/block-editor/build-module/components/inserter-listbox/item.js
48354  /**
48355   * WordPress dependencies
48356   */
48357  
48358  
48359  
48360  function InserterListboxItem({
48361    isFirst,
48362    as: Component,
48363    children,
48364    ...props
48365  }, ref) {
48366    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Composite.Item, {
48367      ref: ref,
48368      role: "option"
48369      // Use the Composite.Item `accessibleWhenDisabled` prop
48370      // over Button's `isFocusable`. The latter was shown to
48371      // cause an issue with tab order in the inserter list.
48372      ,
48373      accessibleWhenDisabled: true,
48374      ...props,
48375      render: htmlProps => {
48376        const propsWithTabIndex = {
48377          ...htmlProps,
48378          tabIndex: isFirst ? 0 : htmlProps.tabIndex
48379        };
48380        if (Component) {
48381          return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Component, {
48382            ...propsWithTabIndex,
48383            children: children
48384          });
48385        }
48386        if (typeof children === 'function') {
48387          return children(propsWithTabIndex);
48388        }
48389        return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
48390          __next40pxDefaultSize: true,
48391          ...propsWithTabIndex,
48392          children: children
48393        });
48394      }
48395    });
48396  }
48397  /* harmony default export */ const inserter_listbox_item = ((0,external_wp_element_namespaceObject.forwardRef)(InserterListboxItem));
48398  
48399  ;// ./node_modules/@wordpress/block-editor/build-module/components/inserter-draggable-blocks/index.js
48400  /**
48401   * WordPress dependencies
48402   */
48403  
48404  
48405  
48406  
48407  
48408  /**
48409   * Internal dependencies
48410   */
48411  
48412  
48413  
48414  
48415  
48416  const InserterDraggableBlocks = ({
48417    isEnabled,
48418    blocks,
48419    icon,
48420    children,
48421    pattern
48422  }) => {
48423    const blockTypeIcon = (0,external_wp_data_namespaceObject.useSelect)(select => {
48424      const {
48425        getBlockType
48426      } = select(external_wp_blocks_namespaceObject.store);
48427      return blocks.length === 1 && getBlockType(blocks[0].name)?.icon;
48428    }, [blocks]);
48429    const {
48430      startDragging,
48431      stopDragging
48432    } = unlock((0,external_wp_data_namespaceObject.useDispatch)(store));
48433    const patternBlock = (0,external_wp_element_namespaceObject.useMemo)(() => {
48434      return pattern?.type === INSERTER_PATTERN_TYPES.user && pattern?.syncStatus !== 'unsynced' ? [(0,external_wp_blocks_namespaceObject.createBlock)('core/block', {
48435        ref: pattern.id
48436      })] : undefined;
48437    }, [pattern?.type, pattern?.syncStatus, pattern?.id]);
48438    if (!isEnabled) {
48439      return children({
48440        draggable: false,
48441        onDragStart: undefined,
48442        onDragEnd: undefined
48443      });
48444    }
48445    const draggableBlocks = patternBlock !== null && patternBlock !== void 0 ? patternBlock : blocks;
48446    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Draggable, {
48447      __experimentalTransferDataType: "wp-blocks",
48448      transferData: {
48449        type: 'inserter',
48450        blocks: draggableBlocks
48451      },
48452      onDragStart: event => {
48453        startDragging();
48454        for (const block of draggableBlocks) {
48455          const type = `wp-block:$block.name}`;
48456          // This will fill in the dataTransfer.types array so that
48457          // the drop zone can check if the draggable is eligible.
48458          // Unfortuantely, on drag start, we don't have access to the
48459          // actual data, only the data keys/types.
48460          event.dataTransfer.items.add('', type);
48461        }
48462      },
48463      onDragEnd: () => {
48464        stopDragging();
48465      },
48466      __experimentalDragComponent: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockDraggableChip, {
48467        count: blocks.length,
48468        icon: icon || !pattern && blockTypeIcon,
48469        isPattern: !!pattern
48470      }),
48471      children: ({
48472        onDraggableStart,
48473        onDraggableEnd
48474      }) => {
48475        return children({
48476          draggable: true,
48477          onDragStart: onDraggableStart,
48478          onDragEnd: onDraggableEnd
48479        });
48480      }
48481    });
48482  };
48483  /* harmony default export */ const inserter_draggable_blocks = (InserterDraggableBlocks);
48484  
48485  ;// ./node_modules/@wordpress/block-editor/build-module/components/inserter-list-item/index.js
48486  /**
48487   * External dependencies
48488   */
48489  
48490  
48491  /**
48492   * WordPress dependencies
48493   */
48494  
48495  
48496  
48497  
48498  
48499  /**
48500   * Internal dependencies
48501   */
48502  
48503  
48504  
48505  
48506  function InserterListItem({
48507    className,
48508    isFirst,
48509    item,
48510    onSelect,
48511    onHover,
48512    isDraggable,
48513    ...props
48514  }) {
48515    const isDraggingRef = (0,external_wp_element_namespaceObject.useRef)(false);
48516    const itemIconStyle = item.icon ? {
48517      backgroundColor: item.icon.background,
48518      color: item.icon.foreground
48519    } : {};
48520    const blocks = (0,external_wp_element_namespaceObject.useMemo)(() => [(0,external_wp_blocks_namespaceObject.createBlock)(item.name, item.initialAttributes, (0,external_wp_blocks_namespaceObject.createBlocksFromInnerBlocksTemplate)(item.innerBlocks))], [item.name, item.initialAttributes, item.innerBlocks]);
48521    const isSynced = (0,external_wp_blocks_namespaceObject.isReusableBlock)(item) && item.syncStatus !== 'unsynced' || (0,external_wp_blocks_namespaceObject.isTemplatePart)(item);
48522    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inserter_draggable_blocks, {
48523      isEnabled: isDraggable && !item.isDisabled,
48524      blocks: blocks,
48525      icon: item.icon,
48526      children: ({
48527        draggable,
48528        onDragStart,
48529        onDragEnd
48530      }) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
48531        className: dist_clsx('block-editor-block-types-list__list-item', {
48532          'is-synced': isSynced
48533        }),
48534        draggable: draggable,
48535        onDragStart: event => {
48536          isDraggingRef.current = true;
48537          if (onDragStart) {
48538            onHover(null);
48539            onDragStart(event);
48540          }
48541        },
48542        onDragEnd: event => {
48543          isDraggingRef.current = false;
48544          if (onDragEnd) {
48545            onDragEnd(event);
48546          }
48547        },
48548        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(inserter_listbox_item, {
48549          isFirst: isFirst,
48550          className: dist_clsx('block-editor-block-types-list__item', className),
48551          disabled: item.isDisabled,
48552          onClick: event => {
48553            event.preventDefault();
48554            onSelect(item, (0,external_wp_keycodes_namespaceObject.isAppleOS)() ? event.metaKey : event.ctrlKey);
48555            onHover(null);
48556          },
48557          onKeyDown: event => {
48558            const {
48559              keyCode
48560            } = event;
48561            if (keyCode === external_wp_keycodes_namespaceObject.ENTER) {
48562              event.preventDefault();
48563              onSelect(item, (0,external_wp_keycodes_namespaceObject.isAppleOS)() ? event.metaKey : event.ctrlKey);
48564              onHover(null);
48565            }
48566          },
48567          onMouseEnter: () => {
48568            if (isDraggingRef.current) {
48569              return;
48570            }
48571            onHover(item);
48572          },
48573          onMouseLeave: () => onHover(null),
48574          ...props,
48575          children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("span", {
48576            className: "block-editor-block-types-list__item-icon",
48577            style: itemIconStyle,
48578            children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_icon, {
48579              icon: item.icon,
48580              showColors: true
48581            })
48582          }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("span", {
48583            className: "block-editor-block-types-list__item-title",
48584            children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalTruncate, {
48585              numberOfLines: 3,
48586              children: item.title
48587            })
48588          })]
48589        })
48590      })
48591    });
48592  }
48593  /* harmony default export */ const inserter_list_item = ((0,external_wp_element_namespaceObject.memo)(InserterListItem));
48594  
48595  ;// ./node_modules/@wordpress/block-editor/build-module/components/inserter-listbox/group.js
48596  /**
48597   * WordPress dependencies
48598   */
48599  
48600  
48601  
48602  
48603  function InserterListboxGroup(props, ref) {
48604    const [shouldSpeak, setShouldSpeak] = (0,external_wp_element_namespaceObject.useState)(false);
48605    (0,external_wp_element_namespaceObject.useEffect)(() => {
48606      if (shouldSpeak) {
48607        (0,external_wp_a11y_namespaceObject.speak)((0,external_wp_i18n_namespaceObject.__)('Use left and right arrow keys to move through blocks'));
48608      }
48609    }, [shouldSpeak]);
48610    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
48611      ref: ref,
48612      role: "listbox",
48613      "aria-orientation": "horizontal",
48614      onFocus: () => {
48615        setShouldSpeak(true);
48616      },
48617      onBlur: event => {
48618        const focusingOutsideGroup = !event.currentTarget.contains(event.relatedTarget);
48619        if (focusingOutsideGroup) {
48620          setShouldSpeak(false);
48621        }
48622      },
48623      ...props
48624    });
48625  }
48626  /* harmony default export */ const group = ((0,external_wp_element_namespaceObject.forwardRef)(InserterListboxGroup));
48627  
48628  ;// ./node_modules/@wordpress/block-editor/build-module/components/inserter-listbox/row.js
48629  /**
48630   * WordPress dependencies
48631   */
48632  
48633  
48634  
48635  function InserterListboxRow(props, ref) {
48636    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Composite.Group, {
48637      role: "presentation",
48638      ref: ref,
48639      ...props
48640    });
48641  }
48642  /* harmony default export */ const inserter_listbox_row = ((0,external_wp_element_namespaceObject.forwardRef)(InserterListboxRow));
48643  
48644  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-types-list/index.js
48645  /**
48646   * WordPress dependencies
48647   */
48648  
48649  
48650  
48651  /**
48652   * Internal dependencies
48653   */
48654  
48655  
48656  
48657  function chunk(array, size) {
48658    const chunks = [];
48659    for (let i = 0, j = array.length; i < j; i += size) {
48660      chunks.push(array.slice(i, i + size));
48661    }
48662    return chunks;
48663  }
48664  function BlockTypesList({
48665    items = [],
48666    onSelect,
48667    onHover = () => {},
48668    children,
48669    label,
48670    isDraggable = true
48671  }) {
48672    const className = 'block-editor-block-types-list';
48673    const listId = (0,external_wp_compose_namespaceObject.useInstanceId)(BlockTypesList, className);
48674    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(group, {
48675      className: className,
48676      "aria-label": label,
48677      children: [chunk(items, 3).map((row, i) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inserter_listbox_row, {
48678        children: row.map((item, j) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inserter_list_item, {
48679          item: item,
48680          className: (0,external_wp_blocks_namespaceObject.getBlockMenuDefaultClassName)(item.id),
48681          onSelect: onSelect,
48682          onHover: onHover,
48683          isDraggable: isDraggable && !item.isDisabled,
48684          isFirst: i === 0 && j === 0,
48685          rowId: `$listId}-$i}`
48686        }, item.id))
48687      }, i)), children]
48688    });
48689  }
48690  /* harmony default export */ const block_types_list = (BlockTypesList);
48691  
48692  ;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/panel.js
48693  /**
48694   * WordPress dependencies
48695   */
48696  
48697  
48698  function InserterPanel({
48699    title,
48700    icon,
48701    children
48702  }) {
48703    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
48704      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
48705        className: "block-editor-inserter__panel-header",
48706        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("h2", {
48707          className: "block-editor-inserter__panel-title",
48708          children: title
48709        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Icon, {
48710          icon: icon
48711        })]
48712      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
48713        className: "block-editor-inserter__panel-content",
48714        children: children
48715      })]
48716    });
48717  }
48718  /* harmony default export */ const panel = (InserterPanel);
48719  
48720  ;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/hooks/use-block-types-state.js
48721  /**
48722   * WordPress dependencies
48723   */
48724  
48725  
48726  
48727  
48728  
48729  
48730  /**
48731   * Internal dependencies
48732   */
48733  
48734  
48735  
48736  
48737  /**
48738   * Retrieves the block types inserter state.
48739   *
48740   * @param {string=}  rootClientId Insertion's root client ID.
48741   * @param {Function} onInsert     function called when inserter a list of blocks.
48742   * @param {boolean}  isQuick
48743   * @return {Array} Returns the block types state. (block types, categories, collections, onSelect handler)
48744   */
48745  const useBlockTypesState = (rootClientId, onInsert, isQuick) => {
48746    const options = (0,external_wp_element_namespaceObject.useMemo)(() => ({
48747      [isFiltered]: !!isQuick
48748    }), [isQuick]);
48749    const [items] = (0,external_wp_data_namespaceObject.useSelect)(select => [select(store).getInserterItems(rootClientId, options)], [rootClientId, options]);
48750    const {
48751      getClosestAllowedInsertionPoint
48752    } = unlock((0,external_wp_data_namespaceObject.useSelect)(store));
48753    const {
48754      createErrorNotice
48755    } = (0,external_wp_data_namespaceObject.useDispatch)(external_wp_notices_namespaceObject.store);
48756    const [categories, collections] = (0,external_wp_data_namespaceObject.useSelect)(select => {
48757      const {
48758        getCategories,
48759        getCollections
48760      } = select(external_wp_blocks_namespaceObject.store);
48761      return [getCategories(), getCollections()];
48762    }, []);
48763    const onSelectItem = (0,external_wp_element_namespaceObject.useCallback)(({
48764      name,
48765      initialAttributes,
48766      innerBlocks,
48767      syncStatus,
48768      content
48769    }, shouldFocusBlock) => {
48770      const destinationClientId = getClosestAllowedInsertionPoint(name, rootClientId);
48771      if (destinationClientId === null) {
48772        var _getBlockType$title;
48773        const title = (_getBlockType$title = (0,external_wp_blocks_namespaceObject.getBlockType)(name)?.title) !== null && _getBlockType$title !== void 0 ? _getBlockType$title : name;
48774        createErrorNotice((0,external_wp_i18n_namespaceObject.sprintf)(/* translators: %s: block pattern title. */
48775        (0,external_wp_i18n_namespaceObject.__)('Block "%s" can\'t be inserted.'), title), {
48776          type: 'snackbar',
48777          id: 'inserter-notice'
48778        });
48779        return;
48780      }
48781      const insertedBlock = syncStatus === 'unsynced' ? (0,external_wp_blocks_namespaceObject.parse)(content, {
48782        __unstableSkipMigrationLogs: true
48783      }) : (0,external_wp_blocks_namespaceObject.createBlock)(name, initialAttributes, (0,external_wp_blocks_namespaceObject.createBlocksFromInnerBlocksTemplate)(innerBlocks));
48784      onInsert(insertedBlock, undefined, shouldFocusBlock, destinationClientId);
48785    }, [getClosestAllowedInsertionPoint, rootClientId, onInsert, createErrorNotice]);
48786    return [items, categories, collections, onSelectItem];
48787  };
48788  /* harmony default export */ const use_block_types_state = (useBlockTypesState);
48789  
48790  ;// ./node_modules/@wordpress/block-editor/build-module/components/inserter-listbox/index.js
48791  /**
48792   * WordPress dependencies
48793   */
48794  
48795  
48796  /**
48797   * Internal dependencies
48798   */
48799  
48800  
48801  
48802  
48803  function InserterListbox({
48804    children
48805  }) {
48806    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Composite, {
48807      focusShift: true,
48808      focusWrap: "horizontal",
48809      render: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_ReactJSXRuntime_namespaceObject.Fragment, {}),
48810      children: children
48811    });
48812  }
48813  /* harmony default export */ const inserter_listbox = (InserterListbox);
48814  
48815  ;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/no-results.js
48816  /**
48817   * WordPress dependencies
48818   */
48819  
48820  
48821  function InserterNoResults() {
48822    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
48823      className: "block-editor-inserter__no-results",
48824      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("p", {
48825        children: (0,external_wp_i18n_namespaceObject.__)('No results found.')
48826      })
48827    });
48828  }
48829  /* harmony default export */ const no_results = (InserterNoResults);
48830  
48831  ;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/block-types-tab.js
48832  /**
48833   * WordPress dependencies
48834   */
48835  
48836  
48837  
48838  
48839  /**
48840   * Internal dependencies
48841   */
48842  
48843  
48844  
48845  
48846  
48847  
48848  
48849  const getBlockNamespace = item => item.name.split('/')[0];
48850  const MAX_SUGGESTED_ITEMS = 6;
48851  
48852  /**
48853   * Shared reference to an empty array for cases where it is important to avoid
48854   * returning a new array reference on every invocation and rerendering the component.
48855   *
48856   * @type {Array}
48857   */
48858  const block_types_tab_EMPTY_ARRAY = [];
48859  function BlockTypesTabPanel({
48860    items,
48861    collections,
48862    categories,
48863    onSelectItem,
48864    onHover,
48865    showMostUsedBlocks,
48866    className
48867  }) {
48868    const suggestedItems = (0,external_wp_element_namespaceObject.useMemo)(() => {
48869      return orderBy(items, 'frecency', 'desc').slice(0, MAX_SUGGESTED_ITEMS);
48870    }, [items]);
48871    const uncategorizedItems = (0,external_wp_element_namespaceObject.useMemo)(() => {
48872      return items.filter(item => !item.category);
48873    }, [items]);
48874    const itemsPerCollection = (0,external_wp_element_namespaceObject.useMemo)(() => {
48875      // Create a new Object to avoid mutating collection.
48876      const result = {
48877        ...collections
48878      };
48879      Object.keys(collections).forEach(namespace => {
48880        result[namespace] = items.filter(item => getBlockNamespace(item) === namespace);
48881        if (result[namespace].length === 0) {
48882          delete result[namespace];
48883        }
48884      });
48885      return result;
48886    }, [items, collections]);
48887  
48888    // Hide block preview on unmount.
48889    (0,external_wp_element_namespaceObject.useEffect)(() => () => onHover(null), []);
48890  
48891    /**
48892     * The inserter contains a big number of blocks and opening it is a costful operation.
48893     * The rendering is the most costful part of it, in order to improve the responsiveness
48894     * of the "opening" action, these lazy lists allow us to render the inserter category per category,
48895     * once all the categories are rendered, we start rendering the collections and the uncategorized block types.
48896     */
48897    const currentlyRenderedCategories = (0,external_wp_compose_namespaceObject.useAsyncList)(categories);
48898    const didRenderAllCategories = categories.length === currentlyRenderedCategories.length;
48899  
48900    // Async List requires an array.
48901    const collectionEntries = (0,external_wp_element_namespaceObject.useMemo)(() => {
48902      return Object.entries(collections);
48903    }, [collections]);
48904    const currentlyRenderedCollections = (0,external_wp_compose_namespaceObject.useAsyncList)(didRenderAllCategories ? collectionEntries : block_types_tab_EMPTY_ARRAY);
48905    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
48906      className: className,
48907      children: [showMostUsedBlocks &&
48908      // Only show the most used blocks if the total amount of block
48909      // is larger than 1 row, otherwise it is not so useful.
48910      items.length > 3 && !!suggestedItems.length && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(panel, {
48911        title: (0,external_wp_i18n_namespaceObject._x)('Most used', 'blocks'),
48912        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_types_list, {
48913          items: suggestedItems,
48914          onSelect: onSelectItem,
48915          onHover: onHover,
48916          label: (0,external_wp_i18n_namespaceObject._x)('Most used', 'blocks')
48917        })
48918      }), currentlyRenderedCategories.map(category => {
48919        const categoryItems = items.filter(item => item.category === category.slug);
48920        if (!categoryItems || !categoryItems.length) {
48921          return null;
48922        }
48923        return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(panel, {
48924          title: category.title,
48925          icon: category.icon,
48926          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_types_list, {
48927            items: categoryItems,
48928            onSelect: onSelectItem,
48929            onHover: onHover,
48930            label: category.title
48931          })
48932        }, category.slug);
48933      }), didRenderAllCategories && uncategorizedItems.length > 0 && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(panel, {
48934        className: "block-editor-inserter__uncategorized-blocks-panel",
48935        title: (0,external_wp_i18n_namespaceObject.__)('Uncategorized'),
48936        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_types_list, {
48937          items: uncategorizedItems,
48938          onSelect: onSelectItem,
48939          onHover: onHover,
48940          label: (0,external_wp_i18n_namespaceObject.__)('Uncategorized')
48941        })
48942      }), currentlyRenderedCollections.map(([namespace, collection]) => {
48943        const collectionItems = itemsPerCollection[namespace];
48944        if (!collectionItems || !collectionItems.length) {
48945          return null;
48946        }
48947        return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(panel, {
48948          title: collection.title,
48949          icon: collection.icon,
48950          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_types_list, {
48951            items: collectionItems,
48952            onSelect: onSelectItem,
48953            onHover: onHover,
48954            label: collection.title
48955          })
48956        }, namespace);
48957      })]
48958    });
48959  }
48960  function BlockTypesTab({
48961    rootClientId,
48962    onInsert,
48963    onHover,
48964    showMostUsedBlocks
48965  }, ref) {
48966    const [items, categories, collections, onSelectItem] = use_block_types_state(rootClientId, onInsert);
48967    if (!items.length) {
48968      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(no_results, {});
48969    }
48970    const itemsForCurrentRoot = [];
48971    const itemsRemaining = [];
48972    for (const item of items) {
48973      // Skip reusable blocks, they moved to the patterns tab.
48974      if (item.category === 'reusable') {
48975        continue;
48976      }
48977      if (item.isAllowedInCurrentRoot) {
48978        itemsForCurrentRoot.push(item);
48979      } else {
48980        itemsRemaining.push(item);
48981      }
48982    }
48983    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inserter_listbox, {
48984      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
48985        ref: ref,
48986        children: [!!itemsForCurrentRoot.length && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_ReactJSXRuntime_namespaceObject.Fragment, {
48987          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockTypesTabPanel, {
48988            items: itemsForCurrentRoot,
48989            categories: categories,
48990            collections: collections,
48991            onSelectItem: onSelectItem,
48992            onHover: onHover,
48993            showMostUsedBlocks: showMostUsedBlocks,
48994            className: "block-editor-inserter__insertable-blocks-at-selection"
48995          })
48996        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockTypesTabPanel, {
48997          items: itemsRemaining,
48998          categories: categories,
48999          collections: collections,
49000          onSelectItem: onSelectItem,
49001          onHover: onHover,
49002          showMostUsedBlocks: showMostUsedBlocks,
49003          className: "block-editor-inserter__all-blocks"
49004        })]
49005      })
49006    });
49007  }
49008  /* harmony default export */ const block_types_tab = ((0,external_wp_element_namespaceObject.forwardRef)(BlockTypesTab));
49009  
49010  ;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/block-patterns-explorer/pattern-explorer-sidebar.js
49011  /**
49012   * WordPress dependencies
49013   */
49014  
49015  
49016  
49017  function PatternCategoriesList({
49018    selectedCategory,
49019    patternCategories,
49020    onClickCategory
49021  }) {
49022    const baseClassName = 'block-editor-block-patterns-explorer__sidebar';
49023    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
49024      className: `$baseClassName}__categories-list`,
49025      children: patternCategories.map(({
49026        name,
49027        label
49028      }) => {
49029        return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
49030          __next40pxDefaultSize: true,
49031          label: label,
49032          className: `$baseClassName}__categories-list__item`,
49033          isPressed: selectedCategory === name,
49034          onClick: () => {
49035            onClickCategory(name);
49036          },
49037          children: label
49038        }, name);
49039      })
49040    });
49041  }
49042  function PatternsExplorerSearch({
49043    searchValue,
49044    setSearchValue
49045  }) {
49046    const baseClassName = 'block-editor-block-patterns-explorer__search';
49047    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
49048      className: baseClassName,
49049      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.SearchControl, {
49050        __nextHasNoMarginBottom: true,
49051        onChange: setSearchValue,
49052        value: searchValue,
49053        label: (0,external_wp_i18n_namespaceObject.__)('Search'),
49054        placeholder: (0,external_wp_i18n_namespaceObject.__)('Search')
49055      })
49056    });
49057  }
49058  function PatternExplorerSidebar({
49059    selectedCategory,
49060    patternCategories,
49061    onClickCategory,
49062    searchValue,
49063    setSearchValue
49064  }) {
49065    const baseClassName = 'block-editor-block-patterns-explorer__sidebar';
49066    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
49067      className: baseClassName,
49068      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PatternsExplorerSearch, {
49069        searchValue: searchValue,
49070        setSearchValue: setSearchValue
49071      }), !searchValue && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PatternCategoriesList, {
49072        selectedCategory: selectedCategory,
49073        patternCategories: patternCategories,
49074        onClickCategory: onClickCategory
49075      })]
49076    });
49077  }
49078  /* harmony default export */ const pattern_explorer_sidebar = (PatternExplorerSidebar);
49079  
49080  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-patterns-paging/index.js
49081  /**
49082   * WordPress dependencies
49083   */
49084  
49085  
49086  
49087  function Pagination({
49088    currentPage,
49089    numPages,
49090    changePage,
49091    totalItems
49092  }) {
49093    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalVStack, {
49094      className: "block-editor-patterns__grid-pagination-wrapper",
49095      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalText, {
49096        variant: "muted",
49097        children: (0,external_wp_i18n_namespaceObject.sprintf)(
49098        // translators: %s: Total number of patterns.
49099        (0,external_wp_i18n_namespaceObject._n)('%s item', '%s items', totalItems), totalItems)
49100      }), numPages > 1 && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalHStack, {
49101        expanded: false,
49102        spacing: 3,
49103        justify: "flex-start",
49104        className: "block-editor-patterns__grid-pagination",
49105        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalHStack, {
49106          expanded: false,
49107          spacing: 1,
49108          className: "block-editor-patterns__grid-pagination-previous",
49109          children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
49110            variant: "tertiary",
49111            onClick: () => changePage(1),
49112            disabled: currentPage === 1,
49113            "aria-label": (0,external_wp_i18n_namespaceObject.__)('First page'),
49114            size: "compact",
49115            accessibleWhenDisabled: true,
49116            className: "block-editor-patterns__grid-pagination-button",
49117            children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("span", {
49118              children: "\xAB"
49119            })
49120          }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
49121            variant: "tertiary",
49122            onClick: () => changePage(currentPage - 1),
49123            disabled: currentPage === 1,
49124            "aria-label": (0,external_wp_i18n_namespaceObject.__)('Previous page'),
49125            size: "compact",
49126            accessibleWhenDisabled: true,
49127            className: "block-editor-patterns__grid-pagination-button",
49128            children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("span", {
49129              children: "\u2039"
49130            })
49131          })]
49132        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalText, {
49133          variant: "muted",
49134          children: (0,external_wp_i18n_namespaceObject.sprintf)(
49135          // translators: 1: Current page number. 2: Total number of pages.
49136          (0,external_wp_i18n_namespaceObject._x)('%1$s of %2$s', 'paging'), currentPage, numPages)
49137        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalHStack, {
49138          expanded: false,
49139          spacing: 1,
49140          className: "block-editor-patterns__grid-pagination-next",
49141          children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
49142            variant: "tertiary",
49143            onClick: () => changePage(currentPage + 1),
49144            disabled: currentPage === numPages,
49145            "aria-label": (0,external_wp_i18n_namespaceObject.__)('Next page'),
49146            size: "compact",
49147            accessibleWhenDisabled: true,
49148            className: "block-editor-patterns__grid-pagination-button",
49149            children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("span", {
49150              children: "\u203A"
49151            })
49152          }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
49153            variant: "tertiary",
49154            onClick: () => changePage(numPages),
49155            disabled: currentPage === numPages,
49156            "aria-label": (0,external_wp_i18n_namespaceObject.__)('Last page'),
49157            size: "compact",
49158            accessibleWhenDisabled: true,
49159            className: "block-editor-patterns__grid-pagination-button",
49160            children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("span", {
49161              children: "\xBB"
49162            })
49163          })]
49164        })]
49165      })]
49166    });
49167  }
49168  
49169  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-patterns-list/index.js
49170  /**
49171   * External dependencies
49172   */
49173  
49174  
49175  /**
49176   * WordPress dependencies
49177   */
49178  
49179  
49180  
49181  
49182  
49183  
49184  
49185  /**
49186   * Internal dependencies
49187   */
49188  
49189  
49190  
49191  
49192  
49193  const WithToolTip = ({
49194    showTooltip,
49195    title,
49196    children
49197  }) => {
49198    if (showTooltip) {
49199      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Tooltip, {
49200        text: title,
49201        children: children
49202      });
49203    }
49204    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_ReactJSXRuntime_namespaceObject.Fragment, {
49205      children: children
49206    });
49207  };
49208  function BlockPattern({
49209    id,
49210    isDraggable,
49211    pattern,
49212    onClick,
49213    onHover,
49214    showTitlesAsTooltip,
49215    category,
49216    isSelected
49217  }) {
49218    const [isDragging, setIsDragging] = (0,external_wp_element_namespaceObject.useState)(false);
49219    const {
49220      blocks,
49221      viewportWidth
49222    } = pattern;
49223    const instanceId = (0,external_wp_compose_namespaceObject.useInstanceId)(BlockPattern);
49224    const descriptionId = `block-editor-block-patterns-list__item-description-$instanceId}`;
49225    const isUserPattern = pattern.type === INSERTER_PATTERN_TYPES.user;
49226  
49227    // When we have a selected category and the pattern is draggable, we need to update the
49228    // pattern's categories in metadata to only contain the selected category, and pass this to
49229    // InserterDraggableBlocks component. We do that because we use this information for pattern
49230    // shuffling and it makes more sense to show only the ones from the initially selected category during insertion.
49231    const patternBlocks = (0,external_wp_element_namespaceObject.useMemo)(() => {
49232      if (!category || !isDraggable) {
49233        return blocks;
49234      }
49235      return (blocks !== null && blocks !== void 0 ? blocks : []).map(block => {
49236        const clonedBlock = (0,external_wp_blocks_namespaceObject.cloneBlock)(block);
49237        if (clonedBlock.attributes.metadata?.categories?.includes(category)) {
49238          clonedBlock.attributes.metadata.categories = [category];
49239        }
49240        return clonedBlock;
49241      });
49242    }, [blocks, isDraggable, category]);
49243    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inserter_draggable_blocks, {
49244      isEnabled: isDraggable,
49245      blocks: patternBlocks,
49246      pattern: pattern,
49247      children: ({
49248        draggable,
49249        onDragStart,
49250        onDragEnd
49251      }) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
49252        className: "block-editor-block-patterns-list__list-item",
49253        draggable: draggable,
49254        onDragStart: event => {
49255          setIsDragging(true);
49256          if (onDragStart) {
49257            onHover?.(null);
49258            onDragStart(event);
49259          }
49260        },
49261        onDragEnd: event => {
49262          setIsDragging(false);
49263          if (onDragEnd) {
49264            onDragEnd(event);
49265          }
49266        },
49267        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(WithToolTip, {
49268          showTooltip: showTitlesAsTooltip && !isUserPattern,
49269          title: pattern.title,
49270          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.Composite.Item, {
49271            render: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
49272              role: "option",
49273              "aria-label": pattern.title,
49274              "aria-describedby": pattern.description ? descriptionId : undefined,
49275              className: dist_clsx('block-editor-block-patterns-list__item', {
49276                'block-editor-block-patterns-list__list-item-synced': pattern.type === INSERTER_PATTERN_TYPES.user && !pattern.syncStatus,
49277                'is-selected': isSelected
49278              })
49279            }),
49280            id: id,
49281            onClick: () => {
49282              onClick(pattern, blocks);
49283              onHover?.(null);
49284            },
49285            onMouseEnter: () => {
49286              if (isDragging) {
49287                return;
49288              }
49289              onHover?.(pattern);
49290            },
49291            onMouseLeave: () => onHover?.(null),
49292            children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_preview.Async, {
49293              placeholder: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockPatternPlaceholder, {}),
49294              children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_preview, {
49295                blocks: blocks,
49296                viewportWidth: viewportWidth
49297              })
49298            }), (!showTitlesAsTooltip || isUserPattern) && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalHStack, {
49299              className: "block-editor-patterns__pattern-details",
49300              spacing: 2,
49301              children: [isUserPattern && !pattern.syncStatus && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
49302                className: "block-editor-patterns__pattern-icon-wrapper",
49303                children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(build_module_icon, {
49304                  className: "block-editor-patterns__pattern-icon",
49305                  icon: library_symbol
49306                })
49307              }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
49308                className: "block-editor-block-patterns-list__item-title",
49309                children: pattern.title
49310              })]
49311            }), !!pattern.description && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.VisuallyHidden, {
49312              id: descriptionId,
49313              children: pattern.description
49314            })]
49315          })
49316        })
49317      })
49318    });
49319  }
49320  function BlockPatternPlaceholder() {
49321    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
49322      className: "block-editor-block-patterns-list__item is-placeholder"
49323    });
49324  }
49325  function BlockPatternsList({
49326    isDraggable,
49327    blockPatterns,
49328    onHover,
49329    onClickPattern,
49330    orientation,
49331    label = (0,external_wp_i18n_namespaceObject.__)('Block patterns'),
49332    category,
49333    showTitlesAsTooltip,
49334    pagingProps
49335  }, ref) {
49336    const [activeCompositeId, setActiveCompositeId] = (0,external_wp_element_namespaceObject.useState)(undefined);
49337    const [activePattern, setActivePattern] = (0,external_wp_element_namespaceObject.useState)(null); // State to track active pattern
49338  
49339    (0,external_wp_element_namespaceObject.useEffect)(() => {
49340      // Reset the active composite item whenever the available patterns change,
49341      // to make sure that Composite widget can receive focus correctly when its
49342      // composite items change. The first composite item will receive focus.
49343      const firstCompositeItemId = blockPatterns[0]?.name;
49344      setActiveCompositeId(firstCompositeItemId);
49345    }, [blockPatterns]);
49346    const handleClickPattern = (pattern, blocks) => {
49347      setActivePattern(pattern.name);
49348      onClickPattern(pattern, blocks);
49349    };
49350    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.Composite, {
49351      orientation: orientation,
49352      activeId: activeCompositeId,
49353      setActiveId: setActiveCompositeId,
49354      role: "listbox",
49355      className: "block-editor-block-patterns-list",
49356      "aria-label": label,
49357      ref: ref,
49358      children: [blockPatterns.map(pattern => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockPattern, {
49359        id: pattern.name,
49360        pattern: pattern,
49361        onClick: handleClickPattern,
49362        onHover: onHover,
49363        isDraggable: isDraggable,
49364        showTitlesAsTooltip: showTitlesAsTooltip,
49365        category: category,
49366        isSelected: !!activePattern && activePattern === pattern.name
49367      }, pattern.name)), pagingProps && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Pagination, {
49368        ...pagingProps
49369      })]
49370    });
49371  }
49372  /* harmony default export */ const block_patterns_list = ((0,external_wp_element_namespaceObject.forwardRef)(BlockPatternsList));
49373  
49374  ;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/hooks/use-insertion-point.js
49375  /**
49376   * WordPress dependencies
49377   */
49378  
49379  
49380  
49381  
49382  
49383  
49384  /**
49385   * Internal dependencies
49386   */
49387  
49388  
49389  function getIndex({
49390    destinationRootClientId,
49391    destinationIndex,
49392    rootClientId,
49393    registry
49394  }) {
49395    if (rootClientId === destinationRootClientId) {
49396      return destinationIndex;
49397    }
49398    const parents = ['', ...registry.select(store).getBlockParents(destinationRootClientId), destinationRootClientId];
49399    const parentIndex = parents.indexOf(rootClientId);
49400    if (parentIndex !== -1) {
49401      return registry.select(store).getBlockIndex(parents[parentIndex + 1]) + 1;
49402    }
49403    return registry.select(store).getBlockOrder(rootClientId).length;
49404  }
49405  
49406  /**
49407   * @typedef WPInserterConfig
49408   *
49409   * @property {string=}   rootClientId   If set, insertion will be into the
49410   *                                      block with this ID.
49411   * @property {number=}   insertionIndex If set, insertion will be into this
49412   *                                      explicit position.
49413   * @property {string=}   clientId       If set, insertion will be after the
49414   *                                      block with this ID.
49415   * @property {boolean=}  isAppender     Whether the inserter is an appender
49416   *                                      or not.
49417   * @property {Function=} onSelect       Called after insertion.
49418   */
49419  
49420  /**
49421   * Returns the insertion point state given the inserter config.
49422   *
49423   * @param {WPInserterConfig} config Inserter Config.
49424   * @return {Array} Insertion Point State (rootClientID, onInsertBlocks and onToggle).
49425   */
49426  function useInsertionPoint({
49427    rootClientId = '',
49428    insertionIndex,
49429    clientId,
49430    isAppender,
49431    onSelect,
49432    shouldFocusBlock = true,
49433    selectBlockOnInsert = true
49434  }) {
49435    const registry = (0,external_wp_data_namespaceObject.useRegistry)();
49436    const {
49437      getSelectedBlock,
49438      getClosestAllowedInsertionPoint,
49439      isBlockInsertionPointVisible
49440    } = unlock((0,external_wp_data_namespaceObject.useSelect)(store));
49441    const {
49442      destinationRootClientId,
49443      destinationIndex
49444    } = (0,external_wp_data_namespaceObject.useSelect)(select => {
49445      const {
49446        getSelectedBlockClientId,
49447        getBlockRootClientId,
49448        getBlockIndex,
49449        getBlockOrder,
49450        getInsertionPoint
49451      } = unlock(select(store));
49452      const selectedBlockClientId = getSelectedBlockClientId();
49453      let _destinationRootClientId = rootClientId;
49454      let _destinationIndex;
49455      const insertionPoint = getInsertionPoint();
49456      if (insertionIndex !== undefined) {
49457        // Insert into a specific index.
49458        _destinationIndex = insertionIndex;
49459      } else if (insertionPoint && insertionPoint.hasOwnProperty('index')) {
49460        _destinationRootClientId = insertionPoint?.rootClientId ? insertionPoint.rootClientId : rootClientId;
49461        _destinationIndex = insertionPoint.index;
49462      } else if (clientId) {
49463        // Insert after a specific client ID.
49464        _destinationIndex = getBlockIndex(clientId);
49465      } else if (!isAppender && selectedBlockClientId) {
49466        _destinationRootClientId = getBlockRootClientId(selectedBlockClientId);
49467        _destinationIndex = getBlockIndex(selectedBlockClientId) + 1;
49468      } else {
49469        // Insert at the end of the list.
49470        _destinationIndex = getBlockOrder(_destinationRootClientId).length;
49471      }
49472      return {
49473        destinationRootClientId: _destinationRootClientId,
49474        destinationIndex: _destinationIndex
49475      };
49476    }, [rootClientId, insertionIndex, clientId, isAppender]);
49477    const {
49478      replaceBlocks,
49479      insertBlocks,
49480      showInsertionPoint,
49481      hideInsertionPoint,
49482      setLastFocus
49483    } = unlock((0,external_wp_data_namespaceObject.useDispatch)(store));
49484    const onInsertBlocks = (0,external_wp_element_namespaceObject.useCallback)((blocks, meta, shouldForceFocusBlock = false, _rootClientId) => {
49485      // When we are trying to move focus or select a new block on insert, we also
49486      // need to clear the last focus to avoid the focus being set to the wrong block
49487      // when tabbing back into the canvas if the block was added from outside the
49488      // editor canvas.
49489      if (shouldForceFocusBlock || shouldFocusBlock || selectBlockOnInsert) {
49490        setLastFocus(null);
49491      }
49492      const selectedBlock = getSelectedBlock();
49493      if (!isAppender && selectedBlock && (0,external_wp_blocks_namespaceObject.isUnmodifiedDefaultBlock)(selectedBlock)) {
49494        replaceBlocks(selectedBlock.clientId, blocks, null, shouldFocusBlock || shouldForceFocusBlock ? 0 : null, meta);
49495      } else {
49496        insertBlocks(blocks, isAppender || _rootClientId === undefined ? destinationIndex : getIndex({
49497          destinationRootClientId,
49498          destinationIndex,
49499          rootClientId: _rootClientId,
49500          registry
49501        }), isAppender || _rootClientId === undefined ? destinationRootClientId : _rootClientId, selectBlockOnInsert, shouldFocusBlock || shouldForceFocusBlock ? 0 : null, meta);
49502      }
49503      const blockLength = Array.isArray(blocks) ? blocks.length : 1;
49504      const message = (0,external_wp_i18n_namespaceObject.sprintf)(
49505      // translators: %d: the name of the block that has been added
49506      (0,external_wp_i18n_namespaceObject._n)('%d block added.', '%d blocks added.', blockLength), blockLength);
49507      (0,external_wp_a11y_namespaceObject.speak)(message);
49508      if (onSelect) {
49509        onSelect(blocks);
49510      }
49511    }, [isAppender, getSelectedBlock, replaceBlocks, insertBlocks, destinationRootClientId, destinationIndex, onSelect, shouldFocusBlock, selectBlockOnInsert]);
49512    const onToggleInsertionPoint = (0,external_wp_element_namespaceObject.useCallback)(item => {
49513      if (item && !isBlockInsertionPointVisible()) {
49514        const allowedDestinationRootClientId = getClosestAllowedInsertionPoint(item.name, destinationRootClientId);
49515        if (allowedDestinationRootClientId !== null) {
49516          showInsertionPoint(allowedDestinationRootClientId, getIndex({
49517            destinationRootClientId,
49518            destinationIndex,
49519            rootClientId: allowedDestinationRootClientId,
49520            registry
49521          }));
49522        }
49523      } else {
49524        hideInsertionPoint();
49525      }
49526    }, [getClosestAllowedInsertionPoint, isBlockInsertionPointVisible, showInsertionPoint, hideInsertionPoint, destinationRootClientId, destinationIndex]);
49527    return [destinationRootClientId, onInsertBlocks, onToggleInsertionPoint];
49528  }
49529  /* harmony default export */ const use_insertion_point = (useInsertionPoint);
49530  
49531  ;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/hooks/use-patterns-state.js
49532  /**
49533   * WordPress dependencies
49534   */
49535  
49536  
49537  
49538  
49539  
49540  
49541  /**
49542   * Internal dependencies
49543   */
49544  
49545  
49546  
49547  
49548  
49549  /**
49550   * Retrieves the block patterns inserter state.
49551   *
49552   * @param {Function} onInsert         function called when inserter a list of blocks.
49553   * @param {string=}  rootClientId     Insertion's root client ID.
49554   * @param {string}   selectedCategory The selected pattern category.
49555   * @param {boolean}  isQuick          For the quick inserter render only allowed patterns.
49556   *
49557   * @return {Array} Returns the patterns state. (patterns, categories, onSelect handler)
49558   */
49559  const usePatternsState = (onInsert, rootClientId, selectedCategory, isQuick) => {
49560    const options = (0,external_wp_element_namespaceObject.useMemo)(() => ({
49561      [isFiltered]: !!isQuick
49562    }), [isQuick]);
49563    const {
49564      patternCategories,
49565      patterns,
49566      userPatternCategories
49567    } = (0,external_wp_data_namespaceObject.useSelect)(select => {
49568      const {
49569        getSettings,
49570        __experimentalGetAllowedPatterns
49571      } = unlock(select(store));
49572      const {
49573        __experimentalUserPatternCategories,
49574        __experimentalBlockPatternCategories
49575      } = getSettings();
49576      return {
49577        patterns: __experimentalGetAllowedPatterns(rootClientId, options),
49578        userPatternCategories: __experimentalUserPatternCategories,
49579        patternCategories: __experimentalBlockPatternCategories
49580      };
49581    }, [rootClientId, options]);
49582    const {
49583      getClosestAllowedInsertionPointForPattern
49584    } = unlock((0,external_wp_data_namespaceObject.useSelect)(store));
49585    const allCategories = (0,external_wp_element_namespaceObject.useMemo)(() => {
49586      const categories = [...patternCategories];
49587      userPatternCategories?.forEach(userCategory => {
49588        if (!categories.find(existingCategory => existingCategory.name === userCategory.name)) {
49589          categories.push(userCategory);
49590        }
49591      });
49592      return categories;
49593    }, [patternCategories, userPatternCategories]);
49594    const {
49595      createSuccessNotice
49596    } = (0,external_wp_data_namespaceObject.useDispatch)(external_wp_notices_namespaceObject.store);
49597    const onClickPattern = (0,external_wp_element_namespaceObject.useCallback)((pattern, blocks) => {
49598      const destinationRootClientId = isQuick ? rootClientId : getClosestAllowedInsertionPointForPattern(pattern, rootClientId);
49599      if (destinationRootClientId === null) {
49600        return;
49601      }
49602      const patternBlocks = pattern.type === INSERTER_PATTERN_TYPES.user && pattern.syncStatus !== 'unsynced' ? [(0,external_wp_blocks_namespaceObject.createBlock)('core/block', {
49603        ref: pattern.id
49604      })] : blocks;
49605      onInsert((patternBlocks !== null && patternBlocks !== void 0 ? patternBlocks : []).map(block => {
49606        const clonedBlock = (0,external_wp_blocks_namespaceObject.cloneBlock)(block);
49607        if (clonedBlock.attributes.metadata?.categories?.includes(selectedCategory)) {
49608          clonedBlock.attributes.metadata.categories = [selectedCategory];
49609        }
49610        return clonedBlock;
49611      }), pattern.name, false, destinationRootClientId);
49612      createSuccessNotice((0,external_wp_i18n_namespaceObject.sprintf)(/* translators: %s: block pattern title. */
49613      (0,external_wp_i18n_namespaceObject.__)('Block pattern "%s" inserted.'), pattern.title), {
49614        type: 'snackbar',
49615        id: 'inserter-notice'
49616      });
49617    }, [createSuccessNotice, onInsert, selectedCategory, rootClientId, getClosestAllowedInsertionPointForPattern, isQuick]);
49618    return [patterns, allCategories, onClickPattern];
49619  };
49620  /* harmony default export */ const use_patterns_state = (usePatternsState);
49621  
49622  // EXTERNAL MODULE: ./node_modules/remove-accents/index.js
49623  var remove_accents = __webpack_require__(9681);
49624  var remove_accents_default = /*#__PURE__*/__webpack_require__.n(remove_accents);
49625  ;// ./node_modules/lower-case/dist.es2015/index.js
49626  /**
49627   * Source: ftp://ftp.unicode.org/Public/UCD/latest/ucd/SpecialCasing.txt
49628   */
49629  var SUPPORTED_LOCALE = {
49630      tr: {
49631          regexp: /\u0130|\u0049|\u0049\u0307/g,
49632          map: {
49633              İ: "\u0069",
49634              I: "\u0131",
49635              İ: "\u0069",
49636          },
49637      },
49638      az: {
49639          regexp: /\u0130/g,
49640          map: {
49641              İ: "\u0069",
49642              I: "\u0131",
49643              İ: "\u0069",
49644          },
49645      },
49646      lt: {
49647          regexp: /\u0049|\u004A|\u012E|\u00CC|\u00CD|\u0128/g,
49648          map: {
49649              I: "\u0069\u0307",
49650              J: "\u006A\u0307",
49651              Į: "\u012F\u0307",
49652              Ì: "\u0069\u0307\u0300",
49653              Í: "\u0069\u0307\u0301",
49654              Ĩ: "\u0069\u0307\u0303",
49655          },
49656      },
49657  };
49658  /**
49659   * Localized lower case.
49660   */
49661  function localeLowerCase(str, locale) {
49662      var lang = SUPPORTED_LOCALE[locale.toLowerCase()];
49663      if (lang)
49664          return lowerCase(str.replace(lang.regexp, function (m) { return lang.map[m]; }));
49665      return lowerCase(str);
49666  }
49667  /**
49668   * Lower case as a function.
49669   */
49670  function lowerCase(str) {
49671      return str.toLowerCase();
49672  }
49673  
49674  ;// ./node_modules/no-case/dist.es2015/index.js
49675  
49676  // Support camel case ("camelCase" -> "camel Case" and "CAMELCase" -> "CAMEL Case").
49677  var DEFAULT_SPLIT_REGEXP = [/([a-z0-9])([A-Z])/g, /([A-Z])([A-Z][a-z])/g];
49678  // Remove all non-word characters.
49679  var DEFAULT_STRIP_REGEXP = /[^A-Z0-9]+/gi;
49680  /**
49681   * Normalize the string into something other libraries can manipulate easier.
49682   */
49683  function noCase(input, options) {
49684      if (options === void 0) { options = {}; }
49685      var _a = options.splitRegexp, splitRegexp = _a === void 0 ? DEFAULT_SPLIT_REGEXP : _a, _b = options.stripRegexp, stripRegexp = _b === void 0 ? DEFAULT_STRIP_REGEXP : _b, _c = options.transform, transform = _c === void 0 ? lowerCase : _c, _d = options.delimiter, delimiter = _d === void 0 ? " " : _d;
49686      var result = dist_es2015_replace(dist_es2015_replace(input, splitRegexp, "$1\0$2"), stripRegexp, "\0");
49687      var start = 0;
49688      var end = result.length;
49689      // Trim the delimiter from around the output string.
49690      while (result.charAt(start) === "\0")
49691          start++;
49692      while (result.charAt(end - 1) === "\0")
49693          end--;
49694      // Transform each token independently.
49695      return result.slice(start, end).split("\0").map(transform).join(delimiter);
49696  }
49697  /**
49698   * Replace `re` in the input string with the replacement value.
49699   */
49700  function dist_es2015_replace(input, re, value) {
49701      if (re instanceof RegExp)
49702          return input.replace(re, value);
49703      return re.reduce(function (input, re) { return input.replace(re, value); }, input);
49704  }
49705  
49706  ;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/search-items.js
49707  /**
49708   * External dependencies
49709   */
49710  
49711  
49712  
49713  // Default search helpers.
49714  const defaultGetName = item => item.name || '';
49715  const defaultGetTitle = item => item.title;
49716  const defaultGetDescription = item => item.description || '';
49717  const defaultGetKeywords = item => item.keywords || [];
49718  const defaultGetCategory = item => item.category;
49719  const defaultGetCollection = () => null;
49720  
49721  // Normalization regexes
49722  const splitRegexp = [/([\p{Ll}\p{Lo}\p{N}])([\p{Lu}\p{Lt}])/gu,
49723  // One lowercase or digit, followed by one uppercase.
49724  /([\p{Lu}\p{Lt}])([\p{Lu}\p{Lt}][\p{Ll}\p{Lo}])/gu // One uppercase followed by one uppercase and one lowercase.
49725  ];
49726  const stripRegexp = /(\p{C}|\p{P}|\p{S})+/giu; // Anything that's not a punctuation, symbol or control/format character.
49727  
49728  // Normalization cache
49729  const extractedWords = new Map();
49730  const normalizedStrings = new Map();
49731  
49732  /**
49733   * Extracts words from an input string.
49734   *
49735   * @param {string} input The input string.
49736   *
49737   * @return {Array} Words, extracted from the input string.
49738   */
49739  function extractWords(input = '') {
49740    if (extractedWords.has(input)) {
49741      return extractedWords.get(input);
49742    }
49743    const result = noCase(input, {
49744      splitRegexp,
49745      stripRegexp
49746    }).split(' ').filter(Boolean);
49747    extractedWords.set(input, result);
49748    return result;
49749  }
49750  
49751  /**
49752   * Sanitizes the search input string.
49753   *
49754   * @param {string} input The search input to normalize.
49755   *
49756   * @return {string} The normalized search input.
49757   */
49758  function normalizeString(input = '') {
49759    if (normalizedStrings.has(input)) {
49760      return normalizedStrings.get(input);
49761    }
49762  
49763    // Disregard diacritics.
49764    //  Input: "média"
49765    let result = remove_accents_default()(input);
49766  
49767    // Accommodate leading slash, matching autocomplete expectations.
49768    //  Input: "/media"
49769    result = result.replace(/^\//, '');
49770  
49771    // Lowercase.
49772    //  Input: "MEDIA"
49773    result = result.toLowerCase();
49774    normalizedStrings.set(input, result);
49775    return result;
49776  }
49777  
49778  /**
49779   * Converts the search term into a list of normalized terms.
49780   *
49781   * @param {string} input The search term to normalize.
49782   *
49783   * @return {string[]} The normalized list of search terms.
49784   */
49785  const getNormalizedSearchTerms = (input = '') => {
49786    return extractWords(normalizeString(input));
49787  };
49788  const removeMatchingTerms = (unmatchedTerms, unprocessedTerms) => {
49789    return unmatchedTerms.filter(term => !getNormalizedSearchTerms(unprocessedTerms).some(unprocessedTerm => unprocessedTerm.includes(term)));
49790  };
49791  const searchBlockItems = (items, categories, collections, searchInput) => {
49792    const normalizedSearchTerms = getNormalizedSearchTerms(searchInput);
49793    if (normalizedSearchTerms.length === 0) {
49794      return items;
49795    }
49796    const config = {
49797      getCategory: item => categories.find(({
49798        slug
49799      }) => slug === item.category)?.title,
49800      getCollection: item => collections[item.name.split('/')[0]]?.title
49801    };
49802    return searchItems(items, searchInput, config);
49803  };
49804  
49805  /**
49806   * Filters an item list given a search term.
49807   *
49808   * @param {Array}  items       Item list
49809   * @param {string} searchInput Search input.
49810   * @param {Object} config      Search Config.
49811   *
49812   * @return {Array} Filtered item list.
49813   */
49814  const searchItems = (items = [], searchInput = '', config = {}) => {
49815    const normalizedSearchTerms = getNormalizedSearchTerms(searchInput);
49816    if (normalizedSearchTerms.length === 0) {
49817      return items;
49818    }
49819    const rankedItems = items.map(item => {
49820      return [item, getItemSearchRank(item, searchInput, config)];
49821    }).filter(([, rank]) => rank > 0);
49822    rankedItems.sort(([, rank1], [, rank2]) => rank2 - rank1);
49823    return rankedItems.map(([item]) => item);
49824  };
49825  
49826  /**
49827   * Get the search rank for a given item and a specific search term.
49828   * The better the match, the higher the rank.
49829   * If the rank equals 0, it should be excluded from the results.
49830   *
49831   * @param {Object} item       Item to filter.
49832   * @param {string} searchTerm Search term.
49833   * @param {Object} config     Search Config.
49834   *
49835   * @return {number} Search Rank.
49836   */
49837  function getItemSearchRank(item, searchTerm, config = {}) {
49838    const {
49839      getName = defaultGetName,
49840      getTitle = defaultGetTitle,
49841      getDescription = defaultGetDescription,
49842      getKeywords = defaultGetKeywords,
49843      getCategory = defaultGetCategory,
49844      getCollection = defaultGetCollection
49845    } = config;
49846    const name = getName(item);
49847    const title = getTitle(item);
49848    const description = getDescription(item);
49849    const keywords = getKeywords(item);
49850    const category = getCategory(item);
49851    const collection = getCollection(item);
49852    const normalizedSearchInput = normalizeString(searchTerm);
49853    const normalizedTitle = normalizeString(title);
49854    let rank = 0;
49855  
49856    // Prefers exact matches
49857    // Then prefers if the beginning of the title matches the search term
49858    // name, keywords, categories, collection, variations match come later.
49859    if (normalizedSearchInput === normalizedTitle) {
49860      rank += 30;
49861    } else if (normalizedTitle.startsWith(normalizedSearchInput)) {
49862      rank += 20;
49863    } else {
49864      const terms = [name, title, description, ...keywords, category, collection].join(' ');
49865      const normalizedSearchTerms = extractWords(normalizedSearchInput);
49866      const unmatchedTerms = removeMatchingTerms(normalizedSearchTerms, terms);
49867      if (unmatchedTerms.length === 0) {
49868        rank += 10;
49869      }
49870    }
49871  
49872    // Give a better rank to "core" namespaced items.
49873    if (rank !== 0 && name.startsWith('core/')) {
49874      const isCoreBlockVariation = name !== item.id;
49875      // Give a bit better rank to "core" blocks over "core" block variations.
49876      rank += isCoreBlockVariation ? 1 : 2;
49877    }
49878    return rank;
49879  }
49880  
49881  ;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/hooks/use-patterns-paging.js
49882  /**
49883   * WordPress dependencies
49884   */
49885  
49886  
49887  
49888  const PAGE_SIZE = 20;
49889  
49890  /**
49891   * Supplies values needed to page the patterns list client side.
49892   *
49893   * @param {Array}  currentCategoryPatterns An array of the current patterns to display.
49894   * @param {string} currentCategory         The currently selected category.
49895   * @param {Object} scrollContainerRef      Ref of container to to find scroll container for when moving between pages.
49896   * @param {string} currentFilter           The currently search filter.
49897   *
49898   * @return {Object} Returns the relevant paging values. (totalItems, categoryPatternsList, numPages, changePage, currentPage)
49899   */
49900  function usePatternsPaging(currentCategoryPatterns, currentCategory, scrollContainerRef, currentFilter = '') {
49901    const [currentPage, setCurrentPage] = (0,external_wp_element_namespaceObject.useState)(1);
49902    const previousCategory = (0,external_wp_compose_namespaceObject.usePrevious)(currentCategory);
49903    const previousFilter = (0,external_wp_compose_namespaceObject.usePrevious)(currentFilter);
49904    if ((previousCategory !== currentCategory || previousFilter !== currentFilter) && currentPage !== 1) {
49905      setCurrentPage(1);
49906    }
49907    const totalItems = currentCategoryPatterns.length;
49908    const pageIndex = currentPage - 1;
49909    const categoryPatterns = (0,external_wp_element_namespaceObject.useMemo)(() => {
49910      return currentCategoryPatterns.slice(pageIndex * PAGE_SIZE, pageIndex * PAGE_SIZE + PAGE_SIZE);
49911    }, [pageIndex, currentCategoryPatterns]);
49912    const numPages = Math.ceil(currentCategoryPatterns.length / PAGE_SIZE);
49913    const changePage = page => {
49914      const scrollContainer = (0,external_wp_dom_namespaceObject.getScrollContainer)(scrollContainerRef?.current);
49915      scrollContainer?.scrollTo(0, 0);
49916      setCurrentPage(page);
49917    };
49918    (0,external_wp_element_namespaceObject.useEffect)(function scrollToTopOnCategoryChange() {
49919      const scrollContainer = (0,external_wp_dom_namespaceObject.getScrollContainer)(scrollContainerRef?.current);
49920      scrollContainer?.scrollTo(0, 0);
49921    }, [currentCategory, scrollContainerRef]);
49922    return {
49923      totalItems,
49924      categoryPatterns,
49925      numPages,
49926      changePage,
49927      currentPage
49928    };
49929  }
49930  
49931  ;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/block-patterns-explorer/pattern-list.js
49932  /**
49933   * WordPress dependencies
49934   */
49935  
49936  
49937  
49938  
49939  
49940  
49941  /**
49942   * Internal dependencies
49943   */
49944  
49945  
49946  
49947  
49948  
49949  
49950  
49951  
49952  
49953  function PatternsListHeader({
49954    filterValue,
49955    filteredBlockPatternsLength
49956  }) {
49957    if (!filterValue) {
49958      return null;
49959    }
49960    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalHeading, {
49961      level: 2,
49962      lineHeight: "48px",
49963      className: "block-editor-block-patterns-explorer__search-results-count",
49964      children: (0,external_wp_i18n_namespaceObject.sprintf)(/* translators: %d: number of patterns. */
49965      (0,external_wp_i18n_namespaceObject._n)('%d pattern found', '%d patterns found', filteredBlockPatternsLength), filteredBlockPatternsLength)
49966    });
49967  }
49968  function PatternList({
49969    searchValue,
49970    selectedCategory,
49971    patternCategories,
49972    rootClientId,
49973    onModalClose
49974  }) {
49975    const container = (0,external_wp_element_namespaceObject.useRef)();
49976    const debouncedSpeak = (0,external_wp_compose_namespaceObject.useDebounce)(external_wp_a11y_namespaceObject.speak, 500);
49977    const [destinationRootClientId, onInsertBlocks] = use_insertion_point({
49978      rootClientId,
49979      shouldFocusBlock: true
49980    });
49981    const [patterns,, onClickPattern] = use_patterns_state(onInsertBlocks, destinationRootClientId, selectedCategory);
49982    const registeredPatternCategories = (0,external_wp_element_namespaceObject.useMemo)(() => patternCategories.map(patternCategory => patternCategory.name), [patternCategories]);
49983    const filteredBlockPatterns = (0,external_wp_element_namespaceObject.useMemo)(() => {
49984      const filteredPatterns = patterns.filter(pattern => {
49985        if (selectedCategory === allPatternsCategory.name) {
49986          return true;
49987        }
49988        if (selectedCategory === myPatternsCategory.name && pattern.type === INSERTER_PATTERN_TYPES.user) {
49989          return true;
49990        }
49991        if (selectedCategory === starterPatternsCategory.name && pattern.blockTypes?.includes('core/post-content')) {
49992          return true;
49993        }
49994        if (selectedCategory === 'uncategorized') {
49995          var _pattern$categories$s;
49996          const hasKnownCategory = (_pattern$categories$s = pattern.categories?.some(category => registeredPatternCategories.includes(category))) !== null && _pattern$categories$s !== void 0 ? _pattern$categories$s : false;
49997          return !pattern.categories?.length || !hasKnownCategory;
49998        }
49999        return pattern.categories?.includes(selectedCategory);
50000      });
50001      if (!searchValue) {
50002        return filteredPatterns;
50003      }
50004      return searchItems(filteredPatterns, searchValue);
50005    }, [searchValue, patterns, selectedCategory, registeredPatternCategories]);
50006  
50007    // Announce search results on change.
50008    (0,external_wp_element_namespaceObject.useEffect)(() => {
50009      if (!searchValue) {
50010        return;
50011      }
50012      const count = filteredBlockPatterns.length;
50013      const resultsFoundMessage = (0,external_wp_i18n_namespaceObject.sprintf)(/* translators: %d: number of results. */
50014      (0,external_wp_i18n_namespaceObject._n)('%d result found.', '%d results found.', count), count);
50015      debouncedSpeak(resultsFoundMessage);
50016    }, [searchValue, debouncedSpeak, filteredBlockPatterns.length]);
50017    const pagingProps = usePatternsPaging(filteredBlockPatterns, selectedCategory, container);
50018  
50019    // Reset page when search value changes.
50020    const [previousSearchValue, setPreviousSearchValue] = (0,external_wp_element_namespaceObject.useState)(searchValue);
50021    if (searchValue !== previousSearchValue) {
50022      setPreviousSearchValue(searchValue);
50023      pagingProps.changePage(1);
50024    }
50025    const hasItems = !!filteredBlockPatterns?.length;
50026    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
50027      className: "block-editor-block-patterns-explorer__list",
50028      ref: container,
50029      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PatternsListHeader, {
50030        filterValue: searchValue,
50031        filteredBlockPatternsLength: filteredBlockPatterns.length
50032      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inserter_listbox, {
50033        children: hasItems && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
50034          children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_patterns_list, {
50035            blockPatterns: pagingProps.categoryPatterns,
50036            onClickPattern: (pattern, blocks) => {
50037              onClickPattern(pattern, blocks);
50038              onModalClose();
50039            },
50040            isDraggable: false
50041          }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Pagination, {
50042            ...pagingProps
50043          })]
50044        })
50045      })]
50046    });
50047  }
50048  /* harmony default export */ const pattern_list = (PatternList);
50049  
50050  ;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/block-patterns-tab/use-pattern-categories.js
50051  /**
50052   * WordPress dependencies
50053   */
50054  
50055  
50056  
50057  
50058  /**
50059   * Internal dependencies
50060   */
50061  
50062  
50063  function hasRegisteredCategory(pattern, allCategories) {
50064    if (!pattern.categories || !pattern.categories.length) {
50065      return false;
50066    }
50067    return pattern.categories.some(cat => allCategories.some(category => category.name === cat));
50068  }
50069  function usePatternCategories(rootClientId, sourceFilter = 'all') {
50070    const [patterns, allCategories] = use_patterns_state(undefined, rootClientId);
50071    const filteredPatterns = (0,external_wp_element_namespaceObject.useMemo)(() => sourceFilter === 'all' ? patterns : patterns.filter(pattern => !isPatternFiltered(pattern, sourceFilter)), [sourceFilter, patterns]);
50072  
50073    // Remove any empty categories.
50074    const populatedCategories = (0,external_wp_element_namespaceObject.useMemo)(() => {
50075      const categories = allCategories.filter(category => filteredPatterns.some(pattern => pattern.categories?.includes(category.name))).sort((a, b) => a.label.localeCompare(b.label));
50076      if (filteredPatterns.some(pattern => !hasRegisteredCategory(pattern, allCategories)) && !categories.find(category => category.name === 'uncategorized')) {
50077        categories.push({
50078          name: 'uncategorized',
50079          label: (0,external_wp_i18n_namespaceObject._x)('Uncategorized')
50080        });
50081      }
50082      if (filteredPatterns.some(pattern => pattern.blockTypes?.includes('core/post-content'))) {
50083        categories.unshift(starterPatternsCategory);
50084      }
50085      if (filteredPatterns.some(pattern => pattern.type === INSERTER_PATTERN_TYPES.user)) {
50086        categories.unshift(myPatternsCategory);
50087      }
50088      if (filteredPatterns.length > 0) {
50089        categories.unshift({
50090          name: allPatternsCategory.name,
50091          label: allPatternsCategory.label
50092        });
50093      }
50094      (0,external_wp_a11y_namespaceObject.speak)((0,external_wp_i18n_namespaceObject.sprintf)(/* translators: %d: number of categories . */
50095      (0,external_wp_i18n_namespaceObject._n)('%d category button displayed.', '%d category buttons displayed.', categories.length), categories.length));
50096      return categories;
50097    }, [allCategories, filteredPatterns]);
50098    return populatedCategories;
50099  }
50100  
50101  ;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/block-patterns-explorer/index.js
50102  /**
50103   * WordPress dependencies
50104   */
50105  
50106  
50107  
50108  
50109  /**
50110   * Internal dependencies
50111   */
50112  
50113  
50114  
50115  
50116  function PatternsExplorer({
50117    initialCategory,
50118    rootClientId,
50119    onModalClose
50120  }) {
50121    const [searchValue, setSearchValue] = (0,external_wp_element_namespaceObject.useState)('');
50122    const [selectedCategory, setSelectedCategory] = (0,external_wp_element_namespaceObject.useState)(initialCategory?.name);
50123    const patternCategories = usePatternCategories(rootClientId);
50124    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
50125      className: "block-editor-block-patterns-explorer",
50126      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(pattern_explorer_sidebar, {
50127        selectedCategory: selectedCategory,
50128        patternCategories: patternCategories,
50129        onClickCategory: setSelectedCategory,
50130        searchValue: searchValue,
50131        setSearchValue: setSearchValue
50132      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(pattern_list, {
50133        searchValue: searchValue,
50134        selectedCategory: selectedCategory,
50135        patternCategories: patternCategories,
50136        rootClientId: rootClientId,
50137        onModalClose: onModalClose
50138      })]
50139    });
50140  }
50141  function PatternsExplorerModal({
50142    onModalClose,
50143    ...restProps
50144  }) {
50145    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Modal, {
50146      title: (0,external_wp_i18n_namespaceObject.__)('Patterns'),
50147      onRequestClose: onModalClose,
50148      isFullScreen: true,
50149      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PatternsExplorer, {
50150        onModalClose: onModalClose,
50151        ...restProps
50152      })
50153    });
50154  }
50155  /* harmony default export */ const block_patterns_explorer = (PatternsExplorerModal);
50156  
50157  ;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/mobile-tab-navigation.js
50158  /**
50159   * WordPress dependencies
50160   */
50161  
50162  
50163  
50164  
50165  function ScreenHeader({
50166    title
50167  }) {
50168    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalVStack, {
50169      spacing: 0,
50170      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalView, {
50171        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalSpacer, {
50172          marginBottom: 0,
50173          paddingX: 4,
50174          paddingY: 3,
50175          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalHStack, {
50176            spacing: 2,
50177            children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Navigator.BackButton, {
50178              style:
50179              // TODO: This style override is also used in ToolsPanelHeader.
50180              // It should be supported out-of-the-box by Button.
50181              {
50182                minWidth: 24,
50183                padding: 0
50184              },
50185              icon: (0,external_wp_i18n_namespaceObject.isRTL)() ? chevron_right : chevron_left,
50186              size: "small",
50187              label: (0,external_wp_i18n_namespaceObject.__)('Back')
50188            }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalSpacer, {
50189              children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalHeading, {
50190                level: 5,
50191                children: title
50192              })
50193            })]
50194          })
50195        })
50196      })
50197    });
50198  }
50199  function MobileTabNavigation({
50200    categories,
50201    children
50202  }) {
50203    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.Navigator, {
50204      initialPath: "/",
50205      className: "block-editor-inserter__mobile-tab-navigation",
50206      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Navigator.Screen, {
50207        path: "/",
50208        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalItemGroup, {
50209          children: categories.map(category => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Navigator.Button, {
50210            path: `/category/$category.name}`,
50211            as: external_wp_components_namespaceObject.__experimentalItem,
50212            isAction: true,
50213            children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalHStack, {
50214              children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FlexBlock, {
50215                children: category.label
50216              }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(build_module_icon, {
50217                icon: (0,external_wp_i18n_namespaceObject.isRTL)() ? chevron_left : chevron_right
50218              })]
50219            })
50220          }, category.name))
50221        })
50222      }), categories.map(category => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.Navigator.Screen, {
50223        path: `/category/$category.name}`,
50224        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ScreenHeader, {
50225          title: (0,external_wp_i18n_namespaceObject.__)('Back')
50226        }), children(category)]
50227      }, category.name))]
50228    });
50229  }
50230  
50231  ;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/block-patterns-tab/patterns-filter.js
50232  /**
50233   * WordPress dependencies
50234   */
50235  
50236  
50237  
50238  
50239  
50240  /**
50241   * Internal dependencies
50242   */
50243  
50244  
50245  const getShouldDisableSyncFilter = sourceFilter => sourceFilter !== 'all' && sourceFilter !== 'user';
50246  const getShouldHideSourcesFilter = category => {
50247    return category.name === myPatternsCategory.name;
50248  };
50249  const PATTERN_SOURCE_MENU_OPTIONS = [{
50250    value: 'all',
50251    label: (0,external_wp_i18n_namespaceObject._x)('All', 'patterns')
50252  }, {
50253    value: INSERTER_PATTERN_TYPES.directory,
50254    label: (0,external_wp_i18n_namespaceObject.__)('Pattern Directory')
50255  }, {
50256    value: INSERTER_PATTERN_TYPES.theme,
50257    label: (0,external_wp_i18n_namespaceObject.__)('Theme & Plugins')
50258  }, {
50259    value: INSERTER_PATTERN_TYPES.user,
50260    label: (0,external_wp_i18n_namespaceObject.__)('User')
50261  }];
50262  function PatternsFilter({
50263    setPatternSyncFilter,
50264    setPatternSourceFilter,
50265    patternSyncFilter,
50266    patternSourceFilter,
50267    scrollContainerRef,
50268    category
50269  }) {
50270    // If the category is `myPatterns` then we need to set the source filter to `user`, but
50271    // we do this by deriving from props rather than calling setPatternSourceFilter otherwise
50272    // the user may be confused when switching to another category if the haven't explicitly set
50273    // this filter themselves.
50274    const currentPatternSourceFilter = category.name === myPatternsCategory.name ? INSERTER_PATTERN_TYPES.user : patternSourceFilter;
50275  
50276    // We need to disable the sync filter option if the source filter is not 'all' or 'user'
50277    // otherwise applying them will just result in no patterns being shown.
50278    const shouldDisableSyncFilter = getShouldDisableSyncFilter(currentPatternSourceFilter);
50279  
50280    // We also hide the directory and theme source filter if the category is `myPatterns`
50281    // otherwise there will only be one option available.
50282    const shouldHideSourcesFilter = getShouldHideSourcesFilter(category);
50283    const patternSyncMenuOptions = (0,external_wp_element_namespaceObject.useMemo)(() => [{
50284      value: 'all',
50285      label: (0,external_wp_i18n_namespaceObject._x)('All', 'patterns')
50286    }, {
50287      value: INSERTER_SYNC_TYPES.full,
50288      label: (0,external_wp_i18n_namespaceObject._x)('Synced', 'patterns'),
50289      disabled: shouldDisableSyncFilter
50290    }, {
50291      value: INSERTER_SYNC_TYPES.unsynced,
50292      label: (0,external_wp_i18n_namespaceObject._x)('Not synced', 'patterns'),
50293      disabled: shouldDisableSyncFilter
50294    }], [shouldDisableSyncFilter]);
50295    function handleSetSourceFilterChange(newSourceFilter) {
50296      setPatternSourceFilter(newSourceFilter);
50297      if (getShouldDisableSyncFilter(newSourceFilter)) {
50298        setPatternSyncFilter('all');
50299      }
50300    }
50301    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_ReactJSXRuntime_namespaceObject.Fragment, {
50302      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.DropdownMenu, {
50303        popoverProps: {
50304          placement: 'right-end'
50305        },
50306        label: (0,external_wp_i18n_namespaceObject.__)('Filter patterns'),
50307        toggleProps: {
50308          size: 'compact'
50309        },
50310        icon: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(build_module_icon, {
50311          icon: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.SVG, {
50312            width: "24",
50313            height: "24",
50314            viewBox: "0 0 24 24",
50315            fill: "none",
50316            xmlns: "http://www.w3.org/2000/svg",
50317            children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Path, {
50318              d: "M10 17.5H14V16H10V17.5ZM6 6V7.5H18V6H6ZM8 12.5H16V11H8V12.5Z",
50319              fill: "currentColor"
50320            })
50321          })
50322        }),
50323        children: () => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
50324          children: [!shouldHideSourcesFilter && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuGroup, {
50325            label: (0,external_wp_i18n_namespaceObject.__)('Source'),
50326            children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItemsChoice, {
50327              choices: PATTERN_SOURCE_MENU_OPTIONS,
50328              onSelect: value => {
50329                handleSetSourceFilterChange(value);
50330                scrollContainerRef.current?.scrollTo(0, 0);
50331              },
50332              value: currentPatternSourceFilter
50333            })
50334          }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuGroup, {
50335            label: (0,external_wp_i18n_namespaceObject.__)('Type'),
50336            children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItemsChoice, {
50337              choices: patternSyncMenuOptions,
50338              onSelect: value => {
50339                setPatternSyncFilter(value);
50340                scrollContainerRef.current?.scrollTo(0, 0);
50341              },
50342              value: patternSyncFilter
50343            })
50344          }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
50345            className: "block-editor-inserter__patterns-filter-help",
50346            children: (0,external_wp_element_namespaceObject.createInterpolateElement)((0,external_wp_i18n_namespaceObject.__)('Patterns are available from the <Link>WordPress.org Pattern Directory</Link>, bundled in the active theme, or created by users on this site. Only patterns created on this site can be synced.'), {
50347              Link: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ExternalLink, {
50348                href: (0,external_wp_i18n_namespaceObject.__)('https://wordpress.org/patterns/')
50349              })
50350            })
50351          })]
50352        })
50353      })
50354    });
50355  }
50356  
50357  ;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/block-patterns-tab/pattern-category-previews.js
50358  /**
50359   * WordPress dependencies
50360   */
50361  
50362  
50363  
50364  
50365  /**
50366   * Internal dependencies
50367   */
50368  
50369  
50370  
50371  
50372  
50373  
50374  
50375  const pattern_category_previews_noop = () => {};
50376  function PatternCategoryPreviews({
50377    rootClientId,
50378    onInsert,
50379    onHover = pattern_category_previews_noop,
50380    category,
50381    showTitlesAsTooltip
50382  }) {
50383    const [allPatterns,, onClickPattern] = use_patterns_state(onInsert, rootClientId, category?.name);
50384    const [patternSyncFilter, setPatternSyncFilter] = (0,external_wp_element_namespaceObject.useState)('all');
50385    const [patternSourceFilter, setPatternSourceFilter] = (0,external_wp_element_namespaceObject.useState)('all');
50386    const availableCategories = usePatternCategories(rootClientId, patternSourceFilter);
50387    const scrollContainerRef = (0,external_wp_element_namespaceObject.useRef)();
50388    const currentCategoryPatterns = (0,external_wp_element_namespaceObject.useMemo)(() => allPatterns.filter(pattern => {
50389      if (isPatternFiltered(pattern, patternSourceFilter, patternSyncFilter)) {
50390        return false;
50391      }
50392      if (category.name === allPatternsCategory.name) {
50393        return true;
50394      }
50395      if (category.name === myPatternsCategory.name && pattern.type === INSERTER_PATTERN_TYPES.user) {
50396        return true;
50397      }
50398      if (category.name === starterPatternsCategory.name && pattern.blockTypes?.includes('core/post-content')) {
50399        return true;
50400      }
50401      if (category.name === 'uncategorized') {
50402        // The uncategorized category should show all the patterns without any category...
50403        if (!pattern.categories) {
50404          return true;
50405        }
50406  
50407        // ...or with no available category.
50408        return !pattern.categories.some(catName => availableCategories.some(c => c.name === catName));
50409      }
50410      return pattern.categories?.includes(category.name);
50411    }), [allPatterns, availableCategories, category.name, patternSourceFilter, patternSyncFilter]);
50412    const pagingProps = usePatternsPaging(currentCategoryPatterns, category, scrollContainerRef);
50413    const {
50414      changePage
50415    } = pagingProps;
50416  
50417    // Hide block pattern preview on unmount.
50418    (0,external_wp_element_namespaceObject.useEffect)(() => () => onHover(null), []);
50419    const onSetPatternSyncFilter = (0,external_wp_element_namespaceObject.useCallback)(value => {
50420      setPatternSyncFilter(value);
50421      changePage(1);
50422    }, [setPatternSyncFilter, changePage]);
50423    const onSetPatternSourceFilter = (0,external_wp_element_namespaceObject.useCallback)(value => {
50424      setPatternSourceFilter(value);
50425      changePage(1);
50426    }, [setPatternSourceFilter, changePage]);
50427    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
50428      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalVStack, {
50429        spacing: 2,
50430        className: "block-editor-inserter__patterns-category-panel-header",
50431        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalHStack, {
50432          children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FlexBlock, {
50433            children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalHeading, {
50434              className: "block-editor-inserter__patterns-category-panel-title",
50435              size: 13,
50436              level: 4,
50437              as: "div",
50438              children: category.label
50439            })
50440          }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PatternsFilter, {
50441            patternSyncFilter: patternSyncFilter,
50442            patternSourceFilter: patternSourceFilter,
50443            setPatternSyncFilter: onSetPatternSyncFilter,
50444            setPatternSourceFilter: onSetPatternSourceFilter,
50445            scrollContainerRef: scrollContainerRef,
50446            category: category
50447          })]
50448        }), !currentCategoryPatterns.length && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalText, {
50449          variant: "muted",
50450          className: "block-editor-inserter__patterns-category-no-results",
50451          children: (0,external_wp_i18n_namespaceObject.__)('No results found')
50452        })]
50453      }), currentCategoryPatterns.length > 0 && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
50454        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalText, {
50455          size: "12",
50456          as: "p",
50457          className: "block-editor-inserter__help-text",
50458          children: (0,external_wp_i18n_namespaceObject.__)('Drag and drop patterns into the canvas.')
50459        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_patterns_list, {
50460          ref: scrollContainerRef,
50461          blockPatterns: pagingProps.categoryPatterns,
50462          onClickPattern: onClickPattern,
50463          onHover: onHover,
50464          label: category.label,
50465          orientation: "vertical",
50466          category: category.name,
50467          isDraggable: true,
50468          showTitlesAsTooltip: showTitlesAsTooltip,
50469          patternFilter: patternSourceFilter,
50470          pagingProps: pagingProps
50471        })]
50472      })]
50473    });
50474  }
50475  
50476  ;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/category-tabs/index.js
50477  /**
50478   * WordPress dependencies
50479   */
50480  
50481  
50482  
50483  
50484  /**
50485   * Internal dependencies
50486   */
50487  
50488  
50489  const {
50490    Tabs: category_tabs_Tabs
50491  } = unlock(external_wp_components_namespaceObject.privateApis);
50492  function CategoryTabs({
50493    categories,
50494    selectedCategory,
50495    onSelectCategory,
50496    children
50497  }) {
50498    // Copied from InterfaceSkeleton.
50499    const ANIMATION_DURATION = 0.25;
50500    const disableMotion = (0,external_wp_compose_namespaceObject.useReducedMotion)();
50501    const defaultTransition = {
50502      type: 'tween',
50503      duration: disableMotion ? 0 : ANIMATION_DURATION,
50504      ease: [0.6, 0, 0.4, 1]
50505    };
50506    const previousSelectedCategory = (0,external_wp_compose_namespaceObject.usePrevious)(selectedCategory);
50507    const selectedTabId = selectedCategory ? selectedCategory.name : null;
50508    const [activeTabId, setActiveId] = (0,external_wp_element_namespaceObject.useState)();
50509    const firstTabId = categories?.[0]?.name;
50510  
50511    // If there is no active tab, make the first tab the active tab, so that
50512    // when focus is moved to the tablist, the first tab will be focused
50513    // despite not being selected
50514    if (selectedTabId === null && !activeTabId && firstTabId) {
50515      setActiveId(firstTabId);
50516    }
50517    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(category_tabs_Tabs, {
50518      selectOnMove: false,
50519      selectedTabId: selectedTabId,
50520      orientation: "vertical",
50521      onSelect: categoryId => {
50522        // Pass the full category object
50523        onSelectCategory(categories.find(category => category.name === categoryId));
50524      },
50525      activeTabId: activeTabId,
50526      onActiveTabIdChange: setActiveId,
50527      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(category_tabs_Tabs.TabList, {
50528        className: "block-editor-inserter__category-tablist",
50529        children: categories.map(category => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(category_tabs_Tabs.Tab, {
50530          tabId: category.name,
50531          "aria-current": category === selectedCategory ? 'true' : undefined,
50532          children: category.label
50533        }, category.name))
50534      }), categories.map(category => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(category_tabs_Tabs.TabPanel, {
50535        tabId: category.name,
50536        focusable: false,
50537        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__unstableMotion.div, {
50538          className: "block-editor-inserter__category-panel",
50539          initial: !previousSelectedCategory ? 'closed' : 'open',
50540          animate: "open",
50541          variants: {
50542            open: {
50543              transform: 'translateX( 0 )',
50544              transitionEnd: {
50545                zIndex: '1'
50546              }
50547            },
50548            closed: {
50549              transform: 'translateX( -100% )',
50550              zIndex: '-1'
50551            }
50552          },
50553          transition: defaultTransition,
50554          children: children
50555        })
50556      }, category.name))]
50557    });
50558  }
50559  /* harmony default export */ const category_tabs = (CategoryTabs);
50560  
50561  ;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/block-patterns-tab/index.js
50562  /**
50563   * WordPress dependencies
50564   */
50565  
50566  
50567  
50568  
50569  
50570  /**
50571   * Internal dependencies
50572   */
50573  
50574  
50575  
50576  
50577  
50578  
50579  
50580  function BlockPatternsTab({
50581    onSelectCategory,
50582    selectedCategory,
50583    onInsert,
50584    rootClientId,
50585    children
50586  }) {
50587    const [showPatternsExplorer, setShowPatternsExplorer] = (0,external_wp_element_namespaceObject.useState)(false);
50588    const categories = usePatternCategories(rootClientId);
50589    const isMobile = (0,external_wp_compose_namespaceObject.useViewportMatch)('medium', '<');
50590    if (!categories.length) {
50591      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(no_results, {});
50592    }
50593    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
50594      children: [!isMobile && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
50595        className: "block-editor-inserter__block-patterns-tabs-container",
50596        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(category_tabs, {
50597          categories: categories,
50598          selectedCategory: selectedCategory,
50599          onSelectCategory: onSelectCategory,
50600          children: children
50601        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
50602          __next40pxDefaultSize: true,
50603          className: "block-editor-inserter__patterns-explore-button",
50604          onClick: () => setShowPatternsExplorer(true),
50605          variant: "secondary",
50606          children: (0,external_wp_i18n_namespaceObject.__)('Explore all patterns')
50607        })]
50608      }), isMobile && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(MobileTabNavigation, {
50609        categories: categories,
50610        children: category => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
50611          className: "block-editor-inserter__category-panel",
50612          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PatternCategoryPreviews, {
50613            onInsert: onInsert,
50614            rootClientId: rootClientId,
50615            category: category
50616          }, category.name)
50617        })
50618      }), showPatternsExplorer && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_patterns_explorer, {
50619        initialCategory: selectedCategory || categories[0],
50620        patternCategories: categories,
50621        onModalClose: () => setShowPatternsExplorer(false),
50622        rootClientId: rootClientId
50623      })]
50624    });
50625  }
50626  /* harmony default export */ const block_patterns_tab = (BlockPatternsTab);
50627  
50628  ;// ./node_modules/@wordpress/icons/build-module/library/external.js
50629  /**
50630   * WordPress dependencies
50631   */
50632  
50633  
50634  const external = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
50635    xmlns: "http://www.w3.org/2000/svg",
50636    viewBox: "0 0 24 24",
50637    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
50638      d: "M19.5 4.5h-7V6h4.44l-5.97 5.97 1.06 1.06L18 7.06v4.44h1.5v-7Zm-13 1a2 2 0 0 0-2 2v10a2 2 0 0 0 2 2h10a2 2 0 0 0 2-2v-3H17v3a.5.5 0 0 1-.5.5h-10a.5.5 0 0 1-.5-.5v-10a.5.5 0 0 1 .5-.5h3V5.5h-3Z"
50639    })
50640  });
50641  /* harmony default export */ const library_external = (external);
50642  
50643  ;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/media-tab/utils.js
50644  /**
50645   * WordPress dependencies
50646   */
50647  
50648  
50649  const mediaTypeTag = {
50650    image: 'img',
50651    video: 'video',
50652    audio: 'audio'
50653  };
50654  
50655  /** @typedef {import('./hooks').InserterMediaItem} InserterMediaItem */
50656  
50657  /**
50658   * Creates a block and a preview element from a media object.
50659   *
50660   * @param {InserterMediaItem}         media     The media object to create the block from.
50661   * @param {('image'|'audio'|'video')} mediaType The media type to create the block for.
50662   * @return {[WPBlock, JSX.Element]} An array containing the block and the preview element.
50663   */
50664  function getBlockAndPreviewFromMedia(media, mediaType) {
50665    // Add the common attributes between the different media types.
50666    const attributes = {
50667      id: media.id || undefined,
50668      caption: media.caption || undefined
50669    };
50670    const mediaSrc = media.url;
50671    const alt = media.alt || undefined;
50672    if (mediaType === 'image') {
50673      attributes.url = mediaSrc;
50674      attributes.alt = alt;
50675    } else if (['video', 'audio'].includes(mediaType)) {
50676      attributes.src = mediaSrc;
50677    }
50678    const PreviewTag = mediaTypeTag[mediaType];
50679    const preview = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PreviewTag, {
50680      src: media.previewUrl || mediaSrc,
50681      alt: alt,
50682      controls: mediaType === 'audio' ? true : undefined,
50683      inert: "true",
50684      onError: ({
50685        currentTarget
50686      }) => {
50687        // Fall back to the media source if the preview cannot be loaded.
50688        if (currentTarget.src === media.previewUrl) {
50689          currentTarget.src = mediaSrc;
50690        }
50691      }
50692    });
50693    return [(0,external_wp_blocks_namespaceObject.createBlock)(`core/$mediaType}`, attributes), preview];
50694  }
50695  
50696  ;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/media-tab/media-preview.js
50697  /**
50698   * External dependencies
50699   */
50700  
50701  
50702  /**
50703   * WordPress dependencies
50704   */
50705  
50706  
50707  
50708  
50709  
50710  
50711  
50712  
50713  
50714  
50715  /**
50716   * Internal dependencies
50717   */
50718  
50719  
50720  
50721  
50722  const ALLOWED_MEDIA_TYPES = ['image'];
50723  const MAXIMUM_TITLE_LENGTH = 25;
50724  const MEDIA_OPTIONS_POPOVER_PROPS = {
50725    position: 'bottom left',
50726    className: 'block-editor-inserter__media-list__item-preview-options__popover'
50727  };
50728  function MediaPreviewOptions({
50729    category,
50730    media
50731  }) {
50732    if (!category.getReportUrl) {
50733      return null;
50734    }
50735    const reportUrl = category.getReportUrl(media);
50736    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.DropdownMenu, {
50737      className: "block-editor-inserter__media-list__item-preview-options",
50738      label: (0,external_wp_i18n_namespaceObject.__)('Options'),
50739      popoverProps: MEDIA_OPTIONS_POPOVER_PROPS,
50740      icon: more_vertical,
50741      children: () => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuGroup, {
50742        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, {
50743          onClick: () => window.open(reportUrl, '_blank').focus(),
50744          icon: library_external,
50745          children: (0,external_wp_i18n_namespaceObject.sprintf)(/* translators: %s: The media type to report e.g: "image", "video", "audio" */
50746          (0,external_wp_i18n_namespaceObject.__)('Report %s'), category.mediaType)
50747        })
50748      })
50749    });
50750  }
50751  function InsertExternalImageModal({
50752    onClose,
50753    onSubmit
50754  }) {
50755    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.Modal, {
50756      title: (0,external_wp_i18n_namespaceObject.__)('Insert external image'),
50757      onRequestClose: onClose,
50758      className: "block-editor-inserter-media-tab-media-preview-inserter-external-image-modal",
50759      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalVStack, {
50760        spacing: 3,
50761        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("p", {
50762          children: (0,external_wp_i18n_namespaceObject.__)('This image cannot be uploaded to your Media Library, but it can still be inserted as an external image.')
50763        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("p", {
50764          children: (0,external_wp_i18n_namespaceObject.__)('External images can be removed by the external provider without warning and could even have legal compliance issues related to privacy legislation.')
50765        })]
50766      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.Flex, {
50767        className: "block-editor-block-lock-modal__actions",
50768        justify: "flex-end",
50769        expanded: false,
50770        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FlexItem, {
50771          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
50772            __next40pxDefaultSize: true,
50773            variant: "tertiary",
50774            onClick: onClose,
50775            children: (0,external_wp_i18n_namespaceObject.__)('Cancel')
50776          })
50777        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FlexItem, {
50778          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
50779            __next40pxDefaultSize: true,
50780            variant: "primary",
50781            onClick: onSubmit,
50782            children: (0,external_wp_i18n_namespaceObject.__)('Insert')
50783          })
50784        })]
50785      })]
50786    });
50787  }
50788  function MediaPreview({
50789    media,
50790    onClick,
50791    category
50792  }) {
50793    const [showExternalUploadModal, setShowExternalUploadModal] = (0,external_wp_element_namespaceObject.useState)(false);
50794    const [isHovered, setIsHovered] = (0,external_wp_element_namespaceObject.useState)(false);
50795    const [isInserting, setIsInserting] = (0,external_wp_element_namespaceObject.useState)(false);
50796    const [block, preview] = (0,external_wp_element_namespaceObject.useMemo)(() => getBlockAndPreviewFromMedia(media, category.mediaType), [media, category.mediaType]);
50797    const {
50798      createErrorNotice,
50799      createSuccessNotice
50800    } = (0,external_wp_data_namespaceObject.useDispatch)(external_wp_notices_namespaceObject.store);
50801    const {
50802      getSettings,
50803      getBlock
50804    } = (0,external_wp_data_namespaceObject.useSelect)(store);
50805    const {
50806      updateBlockAttributes
50807    } = (0,external_wp_data_namespaceObject.useDispatch)(store);
50808    const onMediaInsert = (0,external_wp_element_namespaceObject.useCallback)(previewBlock => {
50809      // Prevent multiple uploads when we're in the process of inserting.
50810      if (isInserting) {
50811        return;
50812      }
50813      const settings = getSettings();
50814      const clonedBlock = (0,external_wp_blocks_namespaceObject.cloneBlock)(previewBlock);
50815      const {
50816        id,
50817        url,
50818        caption
50819      } = clonedBlock.attributes;
50820  
50821      // User has no permission to upload media.
50822      if (!id && !settings.mediaUpload) {
50823        setShowExternalUploadModal(true);
50824        return;
50825      }
50826  
50827      // Media item already exists in library, so just insert it.
50828      if (!!id) {
50829        onClick(clonedBlock);
50830        return;
50831      }
50832      setIsInserting(true);
50833      // Media item does not exist in library, so try to upload it.
50834      // Fist fetch the image data. This may fail if the image host
50835      // doesn't allow CORS with the domain.
50836      // If this happens, we insert the image block using the external
50837      // URL and let the user know about the possible implications.
50838      window.fetch(url).then(response => response.blob()).then(blob => {
50839        const fileName = (0,external_wp_url_namespaceObject.getFilename)(url) || 'image.jpg';
50840        const file = new File([blob], fileName, {
50841          type: blob.type
50842        });
50843        settings.mediaUpload({
50844          filesList: [file],
50845          additionalData: {
50846            caption
50847          },
50848          onFileChange([img]) {
50849            if ((0,external_wp_blob_namespaceObject.isBlobURL)(img.url)) {
50850              return;
50851            }
50852            if (!getBlock(clonedBlock.clientId)) {
50853              // Ensure the block is only inserted once.
50854              onClick({
50855                ...clonedBlock,
50856                attributes: {
50857                  ...clonedBlock.attributes,
50858                  id: img.id,
50859                  url: img.url
50860                }
50861              });
50862              createSuccessNotice((0,external_wp_i18n_namespaceObject.__)('Image uploaded and inserted.'), {
50863                type: 'snackbar',
50864                id: 'inserter-notice'
50865              });
50866            } else {
50867              // For subsequent calls, update the existing block.
50868              updateBlockAttributes(clonedBlock.clientId, {
50869                ...clonedBlock.attributes,
50870                id: img.id,
50871                url: img.url
50872              });
50873            }
50874            setIsInserting(false);
50875          },
50876          allowedTypes: ALLOWED_MEDIA_TYPES,
50877          onError(message) {
50878            createErrorNotice(message, {
50879              type: 'snackbar',
50880              id: 'inserter-notice'
50881            });
50882            setIsInserting(false);
50883          }
50884        });
50885      }).catch(() => {
50886        setShowExternalUploadModal(true);
50887        setIsInserting(false);
50888      });
50889    }, [isInserting, getSettings, onClick, createSuccessNotice, updateBlockAttributes, createErrorNotice, getBlock]);
50890    const title = typeof media.title === 'string' ? media.title : media.title?.rendered || (0,external_wp_i18n_namespaceObject.__)('no title');
50891    let truncatedTitle;
50892    if (title.length > MAXIMUM_TITLE_LENGTH) {
50893      const omission = '...';
50894      truncatedTitle = title.slice(0, MAXIMUM_TITLE_LENGTH - omission.length) + omission;
50895    }
50896    const onMouseEnter = (0,external_wp_element_namespaceObject.useCallback)(() => setIsHovered(true), []);
50897    const onMouseLeave = (0,external_wp_element_namespaceObject.useCallback)(() => setIsHovered(false), []);
50898    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
50899      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inserter_draggable_blocks, {
50900        isEnabled: true,
50901        blocks: [block],
50902        children: ({
50903          draggable,
50904          onDragStart,
50905          onDragEnd
50906        }) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
50907          className: dist_clsx('block-editor-inserter__media-list__list-item', {
50908            'is-hovered': isHovered
50909          }),
50910          draggable: draggable,
50911          onDragStart: onDragStart,
50912          onDragEnd: onDragEnd,
50913          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
50914            onMouseEnter: onMouseEnter,
50915            onMouseLeave: onMouseLeave,
50916            children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Tooltip, {
50917              text: truncatedTitle || title,
50918              children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Composite.Item, {
50919                render: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
50920                  "aria-label": title,
50921                  role: "option",
50922                  className: "block-editor-inserter__media-list__item"
50923                }),
50924                onClick: () => onMediaInsert(block),
50925                children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
50926                  className: "block-editor-inserter__media-list__item-preview",
50927                  children: [preview, isInserting && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
50928                    className: "block-editor-inserter__media-list__item-preview-spinner",
50929                    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Spinner, {})
50930                  })]
50931                })
50932              })
50933            }), !isInserting && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(MediaPreviewOptions, {
50934              category: category,
50935              media: media
50936            })]
50937          })
50938        })
50939      }), showExternalUploadModal && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(InsertExternalImageModal, {
50940        onClose: () => setShowExternalUploadModal(false),
50941        onSubmit: () => {
50942          onClick((0,external_wp_blocks_namespaceObject.cloneBlock)(block));
50943          createSuccessNotice((0,external_wp_i18n_namespaceObject.__)('Image inserted.'), {
50944            type: 'snackbar',
50945            id: 'inserter-notice'
50946          });
50947          setShowExternalUploadModal(false);
50948        }
50949      })]
50950    });
50951  }
50952  
50953  ;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/media-tab/media-list.js
50954  /**
50955   * WordPress dependencies
50956   */
50957  
50958  
50959  
50960  /**
50961   * Internal dependencies
50962   */
50963  
50964  
50965  function MediaList({
50966    mediaList,
50967    category,
50968    onClick,
50969    label = (0,external_wp_i18n_namespaceObject.__)('Media List')
50970  }) {
50971    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Composite, {
50972      role: "listbox",
50973      className: "block-editor-inserter__media-list",
50974      "aria-label": label,
50975      children: mediaList.map((media, index) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(MediaPreview, {
50976        media: media,
50977        category: category,
50978        onClick: onClick
50979      }, media.id || media.sourceId || index))
50980    });
50981  }
50982  /* harmony default export */ const media_list = (MediaList);
50983  
50984  ;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/media-tab/hooks.js
50985  /**
50986   * WordPress dependencies
50987   */
50988  
50989  
50990  
50991  /**
50992   * Internal dependencies
50993   */
50994  
50995  
50996  
50997  /** @typedef {import('../../../store/actions').InserterMediaRequest} InserterMediaRequest */
50998  /** @typedef {import('../../../store/actions').InserterMediaItem} InserterMediaItem */
50999  
51000  /**
51001   * Fetches media items based on the provided category.
51002   * Each media category is responsible for providing a `fetch` function.
51003   *
51004   * @param {Object}               category The media category to fetch results for.
51005   * @param {InserterMediaRequest} query    The query args to use for the request.
51006   * @return {InserterMediaItem[]} The media results.
51007   */
51008  function useMediaResults(category, query = {}) {
51009    const [mediaList, setMediaList] = (0,external_wp_element_namespaceObject.useState)();
51010    const [isLoading, setIsLoading] = (0,external_wp_element_namespaceObject.useState)(false);
51011    // We need to keep track of the last request made because
51012    // multiple request can be fired without knowing the order
51013    // of resolution, and we need to ensure we are showing
51014    // the results of the last request.
51015    // In the future we could use AbortController to cancel previous
51016    // requests, but we don't for now as it involves adding support
51017    // for this to `core-data` package.
51018    const lastRequestRef = (0,external_wp_element_namespaceObject.useRef)();
51019    (0,external_wp_element_namespaceObject.useEffect)(() => {
51020      (async () => {
51021        const key = JSON.stringify({
51022          category: category.name,
51023          ...query
51024        });
51025        lastRequestRef.current = key;
51026        setIsLoading(true);
51027        setMediaList([]); // Empty the previous results.
51028        const _media = await category.fetch?.(query);
51029        if (key === lastRequestRef.current) {
51030          setMediaList(_media);
51031          setIsLoading(false);
51032        }
51033      })();
51034    }, [category.name, ...Object.values(query)]);
51035    return {
51036      mediaList,
51037      isLoading
51038    };
51039  }
51040  function useMediaCategories(rootClientId) {
51041    const [categories, setCategories] = (0,external_wp_element_namespaceObject.useState)([]);
51042    const inserterMediaCategories = (0,external_wp_data_namespaceObject.useSelect)(select => unlock(select(store)).getInserterMediaCategories(), []);
51043    const {
51044      canInsertImage,
51045      canInsertVideo,
51046      canInsertAudio
51047    } = (0,external_wp_data_namespaceObject.useSelect)(select => {
51048      const {
51049        canInsertBlockType
51050      } = select(store);
51051      return {
51052        canInsertImage: canInsertBlockType('core/image', rootClientId),
51053        canInsertVideo: canInsertBlockType('core/video', rootClientId),
51054        canInsertAudio: canInsertBlockType('core/audio', rootClientId)
51055      };
51056    }, [rootClientId]);
51057    (0,external_wp_element_namespaceObject.useEffect)(() => {
51058      (async () => {
51059        const _categories = [];
51060        // If `inserterMediaCategories` is not defined in
51061        // block editor settings, do not show any media categories.
51062        if (!inserterMediaCategories) {
51063          return;
51064        }
51065        // Loop through categories to check if they have at least one media item.
51066        const categoriesHaveMedia = new Map(await Promise.all(inserterMediaCategories.map(async category => {
51067          // Some sources are external and we don't need to make a request.
51068          if (category.isExternalResource) {
51069            return [category.name, true];
51070          }
51071          let results = [];
51072          try {
51073            results = await category.fetch({
51074              per_page: 1
51075            });
51076          } catch (e) {
51077            // If the request fails, we shallow the error and just don't show
51078            // the category, in order to not break the media tab.
51079          }
51080          return [category.name, !!results.length];
51081        })));
51082        // We need to filter out categories that don't have any media items or
51083        // whose corresponding block type is not allowed to be inserted, based
51084        // on the category's `mediaType`.
51085        const canInsertMediaType = {
51086          image: canInsertImage,
51087          video: canInsertVideo,
51088          audio: canInsertAudio
51089        };
51090        inserterMediaCategories.forEach(category => {
51091          if (canInsertMediaType[category.mediaType] && categoriesHaveMedia.get(category.name)) {
51092            _categories.push(category);
51093          }
51094        });
51095        if (!!_categories.length) {
51096          setCategories(_categories);
51097        }
51098      })();
51099    }, [canInsertImage, canInsertVideo, canInsertAudio, inserterMediaCategories]);
51100    return categories;
51101  }
51102  
51103  ;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/media-tab/media-panel.js
51104  /**
51105   * WordPress dependencies
51106   */
51107  
51108  
51109  
51110  
51111  /**
51112   * Internal dependencies
51113   */
51114  
51115  
51116  
51117  
51118  const INITIAL_MEDIA_ITEMS_PER_PAGE = 10;
51119  function MediaCategoryPanel({
51120    rootClientId,
51121    onInsert,
51122    category
51123  }) {
51124    const [search, setSearch, debouncedSearch] = (0,external_wp_compose_namespaceObject.useDebouncedInput)();
51125    const {
51126      mediaList,
51127      isLoading
51128    } = useMediaResults(category, {
51129      per_page: !!debouncedSearch ? 20 : INITIAL_MEDIA_ITEMS_PER_PAGE,
51130      search: debouncedSearch
51131    });
51132    const baseCssClass = 'block-editor-inserter__media-panel';
51133    const searchLabel = category.labels.search_items || (0,external_wp_i18n_namespaceObject.__)('Search');
51134    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
51135      className: baseCssClass,
51136      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.SearchControl, {
51137        __nextHasNoMarginBottom: true,
51138        className: `$baseCssClass}-search`,
51139        onChange: setSearch,
51140        value: search,
51141        label: searchLabel,
51142        placeholder: searchLabel
51143      }), isLoading && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
51144        className: `$baseCssClass}-spinner`,
51145        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Spinner, {})
51146      }), !isLoading && !mediaList?.length && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(no_results, {}), !isLoading && !!mediaList?.length && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(media_list, {
51147        rootClientId: rootClientId,
51148        onClick: onInsert,
51149        mediaList: mediaList,
51150        category: category
51151      })]
51152    });
51153  }
51154  
51155  ;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/media-tab/media-tab.js
51156  /**
51157   * WordPress dependencies
51158   */
51159  
51160  
51161  
51162  
51163  
51164  /**
51165   * Internal dependencies
51166   */
51167  
51168  
51169  
51170  
51171  
51172  
51173  
51174  
51175  
51176  const media_tab_ALLOWED_MEDIA_TYPES = ['image', 'video', 'audio'];
51177  function MediaTab({
51178    rootClientId,
51179    selectedCategory,
51180    onSelectCategory,
51181    onInsert,
51182    children
51183  }) {
51184    const mediaCategories = useMediaCategories(rootClientId);
51185    const isMobile = (0,external_wp_compose_namespaceObject.useViewportMatch)('medium', '<');
51186    const baseCssClass = 'block-editor-inserter__media-tabs';
51187    const onSelectMedia = (0,external_wp_element_namespaceObject.useCallback)(media => {
51188      if (!media?.url) {
51189        return;
51190      }
51191      const [block] = getBlockAndPreviewFromMedia(media, media.type);
51192      onInsert(block);
51193    }, [onInsert]);
51194    const categories = (0,external_wp_element_namespaceObject.useMemo)(() => mediaCategories.map(mediaCategory => ({
51195      ...mediaCategory,
51196      label: mediaCategory.labels.name
51197    })), [mediaCategories]);
51198    if (!categories.length) {
51199      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(no_results, {});
51200    }
51201    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
51202      children: [!isMobile && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
51203        className: `$baseCssClass}-container`,
51204        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(category_tabs, {
51205          categories: categories,
51206          selectedCategory: selectedCategory,
51207          onSelectCategory: onSelectCategory,
51208          children: children
51209        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(check, {
51210          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(media_upload, {
51211            multiple: false,
51212            onSelect: onSelectMedia,
51213            allowedTypes: media_tab_ALLOWED_MEDIA_TYPES,
51214            render: ({
51215              open
51216            }) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
51217              __next40pxDefaultSize: true,
51218              onClick: event => {
51219                // Safari doesn't emit a focus event on button elements when
51220                // clicked and we need to manually focus the button here.
51221                // The reason is that core's Media Library modal explicitly triggers a
51222                // focus event and therefore a `blur` event is triggered on a different
51223                // element, which doesn't contain the `data-unstable-ignore-focus-outside-for-relatedtarget`
51224                // attribute making the Inserter dialog to close.
51225                event.target.focus();
51226                open();
51227              },
51228              className: "block-editor-inserter__media-library-button",
51229              variant: "secondary",
51230              "data-unstable-ignore-focus-outside-for-relatedtarget": ".media-modal",
51231              children: (0,external_wp_i18n_namespaceObject.__)('Open Media Library')
51232            })
51233          })
51234        })]
51235      }), isMobile && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(MobileTabNavigation, {
51236        categories: categories,
51237        children: category => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(MediaCategoryPanel, {
51238          onInsert: onInsert,
51239          rootClientId: rootClientId,
51240          category: category
51241        })
51242      })]
51243    });
51244  }
51245  /* harmony default export */ const media_tab = (MediaTab);
51246  
51247  ;// ./node_modules/@wordpress/block-editor/build-module/components/inserter-menu-extension/index.js
51248  /**
51249   * WordPress dependencies
51250   */
51251  
51252  const {
51253    Fill: __unstableInserterMenuExtension,
51254    Slot
51255  } = (0,external_wp_components_namespaceObject.createSlotFill)('__unstableInserterMenuExtension');
51256  __unstableInserterMenuExtension.Slot = Slot;
51257  /* harmony default export */ const inserter_menu_extension = (__unstableInserterMenuExtension);
51258  
51259  ;// ./node_modules/@wordpress/block-editor/build-module/utils/order-inserter-block-items.js
51260  /** @typedef {import('../store/selectors').WPEditorInserterItem} WPEditorInserterItem */
51261  
51262  /**
51263   * Helper function to order inserter block items according to a provided array of prioritized blocks.
51264   *
51265   * @param {WPEditorInserterItem[]} items    The array of editor inserter block items to be sorted.
51266   * @param {string[]}               priority The array of block names to be prioritized.
51267   * @return {WPEditorInserterItem[]} The sorted array of editor inserter block items.
51268   */
51269  const orderInserterBlockItems = (items, priority) => {
51270    if (!priority) {
51271      return items;
51272    }
51273    items.sort(({
51274      id: aName
51275    }, {
51276      id: bName
51277    }) => {
51278      // Sort block items according to `priority`.
51279      let aIndex = priority.indexOf(aName);
51280      let bIndex = priority.indexOf(bName);
51281      // All other block items should come after that.
51282      if (aIndex < 0) {
51283        aIndex = priority.length;
51284      }
51285      if (bIndex < 0) {
51286        bIndex = priority.length;
51287      }
51288      return aIndex - bIndex;
51289    });
51290    return items;
51291  };
51292  
51293  ;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/search-results.js
51294  /**
51295   * WordPress dependencies
51296   */
51297  
51298  
51299  
51300  
51301  
51302  
51303  
51304  /**
51305   * Internal dependencies
51306   */
51307  
51308  
51309  
51310  
51311  
51312  
51313  
51314  
51315  
51316  
51317  
51318  
51319  
51320  
51321  const INITIAL_INSERTER_RESULTS = 9;
51322  /**
51323   * Shared reference to an empty array for cases where it is important to avoid
51324   * returning a new array reference on every invocation and rerendering the component.
51325   *
51326   * @type {Array}
51327   */
51328  const search_results_EMPTY_ARRAY = [];
51329  function InserterSearchResults({
51330    filterValue,
51331    onSelect,
51332    onHover,
51333    onHoverPattern,
51334    rootClientId,
51335    clientId,
51336    isAppender,
51337    __experimentalInsertionIndex,
51338    maxBlockPatterns,
51339    maxBlockTypes,
51340    showBlockDirectory = false,
51341    isDraggable = true,
51342    shouldFocusBlock = true,
51343    prioritizePatterns,
51344    selectBlockOnInsert,
51345    isQuick
51346  }) {
51347    const debouncedSpeak = (0,external_wp_compose_namespaceObject.useDebounce)(external_wp_a11y_namespaceObject.speak, 500);
51348    const {
51349      prioritizedBlocks
51350    } = (0,external_wp_data_namespaceObject.useSelect)(select => {
51351      const blockListSettings = select(store).getBlockListSettings(rootClientId);
51352      return {
51353        prioritizedBlocks: blockListSettings?.prioritizedInserterBlocks || search_results_EMPTY_ARRAY
51354      };
51355    }, [rootClientId]);
51356    const [destinationRootClientId, onInsertBlocks] = use_insertion_point({
51357      onSelect,
51358      rootClientId,
51359      clientId,
51360      isAppender,
51361      insertionIndex: __experimentalInsertionIndex,
51362      shouldFocusBlock,
51363      selectBlockOnInsert
51364    });
51365    const [blockTypes, blockTypeCategories, blockTypeCollections, onSelectBlockType] = use_block_types_state(destinationRootClientId, onInsertBlocks, isQuick);
51366    const [patterns,, onClickPattern] = use_patterns_state(onInsertBlocks, destinationRootClientId, undefined, isQuick);
51367    const filteredBlockPatterns = (0,external_wp_element_namespaceObject.useMemo)(() => {
51368      if (maxBlockPatterns === 0) {
51369        return [];
51370      }
51371      const results = searchItems(patterns, filterValue);
51372      return maxBlockPatterns !== undefined ? results.slice(0, maxBlockPatterns) : results;
51373    }, [filterValue, patterns, maxBlockPatterns]);
51374    let maxBlockTypesToShow = maxBlockTypes;
51375    if (prioritizePatterns && filteredBlockPatterns.length > 2) {
51376      maxBlockTypesToShow = 0;
51377    }
51378    const filteredBlockTypes = (0,external_wp_element_namespaceObject.useMemo)(() => {
51379      if (maxBlockTypesToShow === 0) {
51380        return [];
51381      }
51382      const nonPatternBlockTypes = blockTypes.filter(blockType => blockType.name !== 'core/block');
51383      let orderedItems = orderBy(nonPatternBlockTypes, 'frecency', 'desc');
51384      if (!filterValue && prioritizedBlocks.length) {
51385        orderedItems = orderInserterBlockItems(orderedItems, prioritizedBlocks);
51386      }
51387      const results = searchBlockItems(orderedItems, blockTypeCategories, blockTypeCollections, filterValue);
51388      return maxBlockTypesToShow !== undefined ? results.slice(0, maxBlockTypesToShow) : results;
51389    }, [filterValue, blockTypes, blockTypeCategories, blockTypeCollections, maxBlockTypesToShow, prioritizedBlocks]);
51390  
51391    // Announce search results on change.
51392    (0,external_wp_element_namespaceObject.useEffect)(() => {
51393      if (!filterValue) {
51394        return;
51395      }
51396      const count = filteredBlockTypes.length + filteredBlockPatterns.length;
51397      const resultsFoundMessage = (0,external_wp_i18n_namespaceObject.sprintf)(/* translators: %d: number of results. */
51398      (0,external_wp_i18n_namespaceObject._n)('%d result found.', '%d results found.', count), count);
51399      debouncedSpeak(resultsFoundMessage);
51400    }, [filterValue, debouncedSpeak, filteredBlockTypes, filteredBlockPatterns]);
51401    const currentShownBlockTypes = (0,external_wp_compose_namespaceObject.useAsyncList)(filteredBlockTypes, {
51402      step: INITIAL_INSERTER_RESULTS
51403    });
51404    const hasItems = filteredBlockTypes.length > 0 || filteredBlockPatterns.length > 0;
51405    const blocksUI = !!filteredBlockTypes.length && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(panel, {
51406      title: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.VisuallyHidden, {
51407        children: (0,external_wp_i18n_namespaceObject.__)('Blocks')
51408      }),
51409      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_types_list, {
51410        items: currentShownBlockTypes,
51411        onSelect: onSelectBlockType,
51412        onHover: onHover,
51413        label: (0,external_wp_i18n_namespaceObject.__)('Blocks'),
51414        isDraggable: isDraggable
51415      })
51416    });
51417    const patternsUI = !!filteredBlockPatterns.length && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(panel, {
51418      title: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.VisuallyHidden, {
51419        children: (0,external_wp_i18n_namespaceObject.__)('Block patterns')
51420      }),
51421      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
51422        className: "block-editor-inserter__quick-inserter-patterns",
51423        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_patterns_list, {
51424          blockPatterns: filteredBlockPatterns,
51425          onClickPattern: onClickPattern,
51426          onHover: onHoverPattern,
51427          isDraggable: isDraggable
51428        })
51429      })
51430    });
51431    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(inserter_listbox, {
51432      children: [!showBlockDirectory && !hasItems && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(no_results, {}), prioritizePatterns ? patternsUI : blocksUI, !!filteredBlockTypes.length && !!filteredBlockPatterns.length && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
51433        className: "block-editor-inserter__quick-inserter-separator"
51434      }), prioritizePatterns ? blocksUI : patternsUI, showBlockDirectory && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inserter_menu_extension.Slot, {
51435        fillProps: {
51436          onSelect: onSelectBlockType,
51437          onHover,
51438          filterValue,
51439          hasItems,
51440          rootClientId: destinationRootClientId
51441        },
51442        children: fills => {
51443          if (fills.length) {
51444            return fills;
51445          }
51446          if (!hasItems) {
51447            return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(no_results, {});
51448          }
51449          return null;
51450        }
51451      })]
51452    });
51453  }
51454  /* harmony default export */ const inserter_search_results = (InserterSearchResults);
51455  
51456  ;// ./node_modules/@wordpress/icons/build-module/library/close-small.js
51457  /**
51458   * WordPress dependencies
51459   */
51460  
51461  
51462  const closeSmall = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
51463    xmlns: "http://www.w3.org/2000/svg",
51464    viewBox: "0 0 24 24",
51465    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
51466      d: "M12 13.06l3.712 3.713 1.061-1.06L13.061 12l3.712-3.712-1.06-1.06L12 10.938 8.288 7.227l-1.061 1.06L10.939 12l-3.712 3.712 1.06 1.061L12 13.061z"
51467    })
51468  });
51469  /* harmony default export */ const close_small = (closeSmall);
51470  
51471  ;// ./node_modules/@wordpress/block-editor/build-module/components/tabbed-sidebar/index.js
51472  /**
51473   * WordPress dependencies
51474   */
51475  
51476  
51477  
51478  
51479  /**
51480   * Internal dependencies
51481   */
51482  
51483  
51484  const {
51485    Tabs: tabbed_sidebar_Tabs
51486  } = unlock(external_wp_components_namespaceObject.privateApis);
51487  
51488  /**
51489   * A component that creates a tabbed sidebar with a close button.
51490   *
51491   * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/tabbed-sidebar/README.md
51492   *
51493   * @example
51494   * ```jsx
51495   * function MyTabbedSidebar() {
51496   *   return (
51497   *     <TabbedSidebar
51498   *       tabs={ [
51499   *         {
51500   *           name: 'tab1',
51501   *           title: 'Settings',
51502   *           panel: <PanelContents />,
51503   *         }
51504   *       ] }
51505   *       onClose={ () => {} }
51506   *       onSelect={ () => {} }
51507   *       defaultTabId="tab1"
51508   *       selectedTab="tab1"
51509   *       closeButtonLabel="Close sidebar"
51510   *     />
51511   *   );
51512   * }
51513   * ```
51514   *
51515   * @param {Object}   props                  Component props.
51516   * @param {string}   [props.defaultTabId]   The ID of the tab to be selected by default when the component renders.
51517   * @param {Function} props.onClose          Function called when the close button is clicked.
51518   * @param {Function} props.onSelect         Function called when a tab is selected. Receives the selected tab's ID as an argument.
51519   * @param {string}   props.selectedTab      The ID of the currently selected tab.
51520   * @param {Array}    props.tabs             Array of tab objects. Each tab should have: name (string), title (string),
51521   *                                          panel (React.Node), and optionally panelRef (React.Ref).
51522   * @param {string}   props.closeButtonLabel Accessibility label for the close button.
51523   * @param {Object}   ref                    Forward ref to the tabs list element.
51524   * @return {Element} The tabbed sidebar component.
51525   */
51526  function TabbedSidebar({
51527    defaultTabId,
51528    onClose,
51529    onSelect,
51530    selectedTab,
51531    tabs,
51532    closeButtonLabel
51533  }, ref) {
51534    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
51535      className: "block-editor-tabbed-sidebar",
51536      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(tabbed_sidebar_Tabs, {
51537        selectOnMove: false,
51538        defaultTabId: defaultTabId,
51539        onSelect: onSelect,
51540        selectedTabId: selectedTab,
51541        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
51542          className: "block-editor-tabbed-sidebar__tablist-and-close-button",
51543          children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
51544            className: "block-editor-tabbed-sidebar__close-button",
51545            icon: close_small,
51546            label: closeButtonLabel,
51547            onClick: () => onClose(),
51548            size: "compact"
51549          }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(tabbed_sidebar_Tabs.TabList, {
51550            className: "block-editor-tabbed-sidebar__tablist",
51551            ref: ref,
51552            children: tabs.map(tab => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(tabbed_sidebar_Tabs.Tab, {
51553              tabId: tab.name,
51554              className: "block-editor-tabbed-sidebar__tab",
51555              children: tab.title
51556            }, tab.name))
51557          })]
51558        }), tabs.map(tab => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(tabbed_sidebar_Tabs.TabPanel, {
51559          tabId: tab.name,
51560          focusable: false,
51561          className: "block-editor-tabbed-sidebar__tabpanel",
51562          ref: tab.panelRef,
51563          children: tab.panel
51564        }, tab.name))]
51565      })
51566    });
51567  }
51568  /* harmony default export */ const tabbed_sidebar = ((0,external_wp_element_namespaceObject.forwardRef)(TabbedSidebar));
51569  
51570  ;// ./node_modules/@wordpress/block-editor/build-module/hooks/use-zoom-out.js
51571  /**
51572   * WordPress dependencies
51573   */
51574  
51575  
51576  
51577  /**
51578   * Internal dependencies
51579   */
51580  
51581  
51582  
51583  /**
51584   * A hook used to set the editor mode to zoomed out mode, invoking the hook sets the mode.
51585   * Concepts:
51586   * - If we most recently changed the zoom level for them (in or out), we always resetZoomLevel() level when unmounting.
51587   * - If the user most recently changed the zoom level (manually toggling), we do nothing when unmounting.
51588   *
51589   * @param {boolean} enabled If we should enter into zoomOut mode or not
51590   */
51591  function useZoomOut(enabled = true) {
51592    const {
51593      setZoomLevel,
51594      resetZoomLevel
51595    } = unlock((0,external_wp_data_namespaceObject.useDispatch)(store));
51596  
51597    /**
51598     * We need access to both the value and the function. The value is to trigger a useEffect hook
51599     * and the function is to check zoom out within another hook without triggering a re-render.
51600     */
51601    const {
51602      isZoomedOut,
51603      isZoomOut
51604    } = (0,external_wp_data_namespaceObject.useSelect)(select => {
51605      const {
51606        isZoomOut: _isZoomOut
51607      } = unlock(select(store));
51608      return {
51609        isZoomedOut: _isZoomOut(),
51610        isZoomOut: _isZoomOut
51611      };
51612    }, []);
51613    const controlZoomLevelRef = (0,external_wp_element_namespaceObject.useRef)(false);
51614    const isEnabledRef = (0,external_wp_element_namespaceObject.useRef)(enabled);
51615  
51616    /**
51617     * This hook tracks if the zoom state was changed manually by the user via clicking
51618     * the zoom out button. We only want this to run when isZoomedOut changes, so we use
51619     * a ref to track the enabled state.
51620     */
51621    (0,external_wp_element_namespaceObject.useEffect)(() => {
51622      // If the zoom state changed (isZoomOut) and it does not match the requested zoom
51623      // state (zoomOut), then it means the user manually changed the zoom state while
51624      // this hook was mounted, and we should no longer control the zoom state.
51625      if (isZoomedOut !== isEnabledRef.current) {
51626        controlZoomLevelRef.current = false;
51627      }
51628    }, [isZoomedOut]);
51629    (0,external_wp_element_namespaceObject.useEffect)(() => {
51630      isEnabledRef.current = enabled;
51631      if (enabled !== isZoomOut()) {
51632        controlZoomLevelRef.current = true;
51633        if (enabled) {
51634          setZoomLevel('auto-scaled');
51635        } else {
51636          resetZoomLevel();
51637        }
51638      }
51639      return () => {
51640        // If we are controlling zoom level and are zoomed out, reset the zoom level.
51641        if (controlZoomLevelRef.current && isZoomOut()) {
51642          resetZoomLevel();
51643        }
51644      };
51645    }, [enabled, isZoomOut, resetZoomLevel, setZoomLevel]);
51646  }
51647  
51648  ;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/menu.js
51649  /**
51650   * External dependencies
51651   */
51652  
51653  
51654  /**
51655   * WordPress dependencies
51656   */
51657  
51658  
51659  
51660  
51661  
51662  
51663  /**
51664   * Internal dependencies
51665   */
51666  
51667  
51668  
51669  
51670  
51671  
51672  
51673  
51674  
51675  
51676  
51677  
51678  
51679  const NOOP = () => {};
51680  function InserterMenu({
51681    rootClientId,
51682    clientId,
51683    isAppender,
51684    __experimentalInsertionIndex,
51685    onSelect,
51686    showInserterHelpPanel,
51687    showMostUsedBlocks,
51688    __experimentalFilterValue = '',
51689    shouldFocusBlock = true,
51690    onPatternCategorySelection,
51691    onClose,
51692    __experimentalInitialTab,
51693    __experimentalInitialCategory
51694  }, ref) {
51695    const {
51696      isZoomOutMode,
51697      hasSectionRootClientId
51698    } = (0,external_wp_data_namespaceObject.useSelect)(select => {
51699      const {
51700        isZoomOut,
51701        getSectionRootClientId
51702      } = unlock(select(store));
51703      return {
51704        isZoomOutMode: isZoomOut(),
51705        hasSectionRootClientId: !!getSectionRootClientId()
51706      };
51707    }, []);
51708    const [filterValue, setFilterValue, delayedFilterValue] = (0,external_wp_compose_namespaceObject.useDebouncedInput)(__experimentalFilterValue);
51709    const [hoveredItem, setHoveredItem] = (0,external_wp_element_namespaceObject.useState)(null);
51710    const [selectedPatternCategory, setSelectedPatternCategory] = (0,external_wp_element_namespaceObject.useState)(__experimentalInitialCategory);
51711    const [patternFilter, setPatternFilter] = (0,external_wp_element_namespaceObject.useState)('all');
51712    const [selectedMediaCategory, setSelectedMediaCategory] = (0,external_wp_element_namespaceObject.useState)(null);
51713    const isLargeViewport = (0,external_wp_compose_namespaceObject.useViewportMatch)('large');
51714    function getInitialTab() {
51715      if (__experimentalInitialTab) {
51716        return __experimentalInitialTab;
51717      }
51718      if (isZoomOutMode) {
51719        return 'patterns';
51720      }
51721      return 'blocks';
51722    }
51723    const [selectedTab, setSelectedTab] = (0,external_wp_element_namespaceObject.useState)(getInitialTab());
51724    const shouldUseZoomOut = hasSectionRootClientId && (selectedTab === 'patterns' || selectedTab === 'media');
51725    useZoomOut(shouldUseZoomOut && isLargeViewport);
51726    const [destinationRootClientId, onInsertBlocks, onToggleInsertionPoint] = use_insertion_point({
51727      rootClientId,
51728      clientId,
51729      isAppender,
51730      insertionIndex: __experimentalInsertionIndex,
51731      shouldFocusBlock
51732    });
51733    const blockTypesTabRef = (0,external_wp_element_namespaceObject.useRef)();
51734    const onInsert = (0,external_wp_element_namespaceObject.useCallback)((blocks, meta, shouldForceFocusBlock, _rootClientId) => {
51735      onInsertBlocks(blocks, meta, shouldForceFocusBlock, _rootClientId);
51736      onSelect(blocks);
51737  
51738      // Check for focus loss due to filtering blocks by selected block type
51739      window.requestAnimationFrame(() => {
51740        if (!shouldFocusBlock && !blockTypesTabRef.current?.contains(ref.current.ownerDocument.activeElement)) {
51741          // There has been a focus loss, so focus the first button in the block types tab
51742          blockTypesTabRef.current?.querySelector('button').focus();
51743        }
51744      });
51745    }, [onInsertBlocks, onSelect, shouldFocusBlock]);
51746    const onInsertPattern = (0,external_wp_element_namespaceObject.useCallback)((blocks, patternName, ...args) => {
51747      onToggleInsertionPoint(false);
51748      onInsertBlocks(blocks, {
51749        patternName
51750      }, ...args);
51751      onSelect();
51752    }, [onInsertBlocks, onSelect]);
51753    const onHover = (0,external_wp_element_namespaceObject.useCallback)(item => {
51754      onToggleInsertionPoint(item);
51755      setHoveredItem(item);
51756    }, [onToggleInsertionPoint, setHoveredItem]);
51757    const onClickPatternCategory = (0,external_wp_element_namespaceObject.useCallback)((patternCategory, filter) => {
51758      setSelectedPatternCategory(patternCategory);
51759      setPatternFilter(filter);
51760      onPatternCategorySelection?.();
51761    }, [setSelectedPatternCategory, onPatternCategorySelection]);
51762    const showPatternPanel = selectedTab === 'patterns' && !delayedFilterValue && !!selectedPatternCategory;
51763    const showMediaPanel = selectedTab === 'media' && !!selectedMediaCategory;
51764    const inserterSearch = (0,external_wp_element_namespaceObject.useMemo)(() => {
51765      if (selectedTab === 'media') {
51766        return null;
51767      }
51768      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
51769        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.SearchControl, {
51770          __nextHasNoMarginBottom: true,
51771          className: "block-editor-inserter__search",
51772          onChange: value => {
51773            if (hoveredItem) {
51774              setHoveredItem(null);
51775            }
51776            setFilterValue(value);
51777          },
51778          value: filterValue,
51779          label: (0,external_wp_i18n_namespaceObject.__)('Search'),
51780          placeholder: (0,external_wp_i18n_namespaceObject.__)('Search')
51781        }), !!delayedFilterValue && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inserter_search_results, {
51782          filterValue: delayedFilterValue,
51783          onSelect: onSelect,
51784          onHover: onHover,
51785          rootClientId: rootClientId,
51786          clientId: clientId,
51787          isAppender: isAppender,
51788          __experimentalInsertionIndex: __experimentalInsertionIndex,
51789          showBlockDirectory: true,
51790          shouldFocusBlock: shouldFocusBlock,
51791          prioritizePatterns: selectedTab === 'patterns'
51792        })]
51793      });
51794    }, [selectedTab, hoveredItem, setHoveredItem, setFilterValue, filterValue, delayedFilterValue, onSelect, onHover, shouldFocusBlock, clientId, rootClientId, __experimentalInsertionIndex, isAppender]);
51795    const blocksTab = (0,external_wp_element_namespaceObject.useMemo)(() => {
51796      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
51797        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
51798          className: "block-editor-inserter__block-list",
51799          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_types_tab, {
51800            ref: blockTypesTabRef,
51801            rootClientId: destinationRootClientId,
51802            onInsert: onInsert,
51803            onHover: onHover,
51804            showMostUsedBlocks: showMostUsedBlocks
51805          })
51806        }), showInserterHelpPanel && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
51807          className: "block-editor-inserter__tips",
51808          children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.VisuallyHidden, {
51809            as: "h2",
51810            children: (0,external_wp_i18n_namespaceObject.__)('A tip for using the block editor')
51811          }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(tips, {})]
51812        })]
51813      });
51814    }, [destinationRootClientId, onInsert, onHover, showMostUsedBlocks, showInserterHelpPanel]);
51815    const patternsTab = (0,external_wp_element_namespaceObject.useMemo)(() => {
51816      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_patterns_tab, {
51817        rootClientId: destinationRootClientId,
51818        onInsert: onInsertPattern,
51819        onSelectCategory: onClickPatternCategory,
51820        selectedCategory: selectedPatternCategory,
51821        children: showPatternPanel && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PatternCategoryPreviews, {
51822          rootClientId: destinationRootClientId,
51823          onInsert: onInsertPattern,
51824          category: selectedPatternCategory,
51825          patternFilter: patternFilter,
51826          showTitlesAsTooltip: true
51827        })
51828      });
51829    }, [destinationRootClientId, onInsertPattern, onClickPatternCategory, patternFilter, selectedPatternCategory, showPatternPanel]);
51830    const mediaTab = (0,external_wp_element_namespaceObject.useMemo)(() => {
51831      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(media_tab, {
51832        rootClientId: destinationRootClientId,
51833        selectedCategory: selectedMediaCategory,
51834        onSelectCategory: setSelectedMediaCategory,
51835        onInsert: onInsert,
51836        children: showMediaPanel && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(MediaCategoryPanel, {
51837          rootClientId: destinationRootClientId,
51838          onInsert: onInsert,
51839          category: selectedMediaCategory
51840        })
51841      });
51842    }, [destinationRootClientId, onInsert, selectedMediaCategory, setSelectedMediaCategory, showMediaPanel]);
51843    const handleSetSelectedTab = value => {
51844      // If no longer on patterns tab remove the category setting.
51845      if (value !== 'patterns') {
51846        setSelectedPatternCategory(null);
51847      }
51848      setSelectedTab(value);
51849    };
51850  
51851    // Focus first active tab, if any
51852    const tabsRef = (0,external_wp_element_namespaceObject.useRef)();
51853    (0,external_wp_element_namespaceObject.useLayoutEffect)(() => {
51854      if (tabsRef.current) {
51855        window.requestAnimationFrame(() => {
51856          tabsRef.current.querySelector('[role="tab"][aria-selected="true"]')?.focus();
51857        });
51858      }
51859    }, []);
51860    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
51861      className: dist_clsx('block-editor-inserter__menu', {
51862        'show-panel': showPatternPanel || showMediaPanel,
51863        'is-zoom-out': isZoomOutMode
51864      }),
51865      ref: ref,
51866      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
51867        className: "block-editor-inserter__main-area",
51868        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(tabbed_sidebar, {
51869          ref: tabsRef,
51870          onSelect: handleSetSelectedTab,
51871          onClose: onClose,
51872          selectedTab: selectedTab,
51873          closeButtonLabel: (0,external_wp_i18n_namespaceObject.__)('Close Block Inserter'),
51874          tabs: [{
51875            name: 'blocks',
51876            title: (0,external_wp_i18n_namespaceObject.__)('Blocks'),
51877            panel: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
51878              children: [inserterSearch, selectedTab === 'blocks' && !delayedFilterValue && blocksTab]
51879            })
51880          }, {
51881            name: 'patterns',
51882            title: (0,external_wp_i18n_namespaceObject.__)('Patterns'),
51883            panel: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
51884              children: [inserterSearch, selectedTab === 'patterns' && !delayedFilterValue && patternsTab]
51885            })
51886          }, {
51887            name: 'media',
51888            title: (0,external_wp_i18n_namespaceObject.__)('Media'),
51889            panel: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
51890              children: [inserterSearch, mediaTab]
51891            })
51892          }]
51893        })
51894      }), showInserterHelpPanel && hoveredItem && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Popover, {
51895        className: "block-editor-inserter__preview-container__popover",
51896        placement: "right-start",
51897        offset: 16,
51898        focusOnMount: false,
51899        animate: false,
51900        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(preview_panel, {
51901          item: hoveredItem
51902        })
51903      })]
51904    });
51905  }
51906  const PrivateInserterMenu = (0,external_wp_element_namespaceObject.forwardRef)(InserterMenu);
51907  function PublicInserterMenu(props, ref) {
51908    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PrivateInserterMenu, {
51909      ...props,
51910      onPatternCategorySelection: NOOP,
51911      ref: ref
51912    });
51913  }
51914  /* harmony default export */ const menu = ((0,external_wp_element_namespaceObject.forwardRef)(PublicInserterMenu));
51915  
51916  ;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/quick-inserter.js
51917  /**
51918   * External dependencies
51919   */
51920  
51921  
51922  /**
51923   * WordPress dependencies
51924   */
51925  
51926  
51927  
51928  
51929  
51930  /**
51931   * Internal dependencies
51932   */
51933  
51934  
51935  
51936  
51937  
51938  const SEARCH_THRESHOLD = 6;
51939  const SHOWN_BLOCK_TYPES = 6;
51940  const SHOWN_BLOCK_PATTERNS = 2;
51941  function QuickInserter({
51942    onSelect,
51943    rootClientId,
51944    clientId,
51945    isAppender,
51946    selectBlockOnInsert,
51947    hasSearch = true
51948  }) {
51949    const [filterValue, setFilterValue] = (0,external_wp_element_namespaceObject.useState)('');
51950    const [destinationRootClientId, onInsertBlocks] = use_insertion_point({
51951      onSelect,
51952      rootClientId,
51953      clientId,
51954      isAppender,
51955      selectBlockOnInsert
51956    });
51957    const [blockTypes] = use_block_types_state(destinationRootClientId, onInsertBlocks, true);
51958    const {
51959      setInserterIsOpened,
51960      insertionIndex
51961    } = (0,external_wp_data_namespaceObject.useSelect)(select => {
51962      const {
51963        getSettings,
51964        getBlockIndex,
51965        getBlockCount
51966      } = select(store);
51967      const settings = getSettings();
51968      const index = getBlockIndex(clientId);
51969      const blockCount = getBlockCount();
51970      return {
51971        setInserterIsOpened: settings.__experimentalSetIsInserterOpened,
51972        insertionIndex: index === -1 ? blockCount : index
51973      };
51974    }, [clientId]);
51975    const showSearch = hasSearch && blockTypes.length > SEARCH_THRESHOLD;
51976    (0,external_wp_element_namespaceObject.useEffect)(() => {
51977      if (setInserterIsOpened) {
51978        setInserterIsOpened(false);
51979      }
51980    }, [setInserterIsOpened]);
51981  
51982    // When clicking Browse All select the appropriate block so as
51983    // the insertion point can work as expected.
51984    const onBrowseAll = () => {
51985      setInserterIsOpened({
51986        filterValue,
51987        onSelect,
51988        rootClientId,
51989        insertionIndex
51990      });
51991    };
51992    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
51993      className: dist_clsx('block-editor-inserter__quick-inserter', {
51994        'has-search': showSearch,
51995        'has-expand': setInserterIsOpened
51996      }),
51997      children: [showSearch && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.SearchControl, {
51998        __nextHasNoMarginBottom: true,
51999        className: "block-editor-inserter__search",
52000        value: filterValue,
52001        onChange: value => {
52002          setFilterValue(value);
52003        },
52004        label: (0,external_wp_i18n_namespaceObject.__)('Search'),
52005        placeholder: (0,external_wp_i18n_namespaceObject.__)('Search')
52006      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
52007        className: "block-editor-inserter__quick-inserter-results",
52008        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inserter_search_results, {
52009          filterValue: filterValue,
52010          onSelect: onSelect,
52011          rootClientId: rootClientId,
52012          clientId: clientId,
52013          isAppender: isAppender,
52014          maxBlockPatterns: !!filterValue ? SHOWN_BLOCK_PATTERNS : 0,
52015          maxBlockTypes: SHOWN_BLOCK_TYPES,
52016          isDraggable: false,
52017          selectBlockOnInsert: selectBlockOnInsert,
52018          isQuick: true
52019        })
52020      }), setInserterIsOpened && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
52021        __next40pxDefaultSize: true,
52022        className: "block-editor-inserter__quick-inserter-expand",
52023        onClick: onBrowseAll,
52024        "aria-label": (0,external_wp_i18n_namespaceObject.__)('Browse all. This will open the main inserter panel in the editor toolbar.'),
52025        children: (0,external_wp_i18n_namespaceObject.__)('Browse all')
52026      })]
52027    });
52028  }
52029  
52030  ;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/index.js
52031  /**
52032   * External dependencies
52033   */
52034  
52035  
52036  /**
52037   * WordPress dependencies
52038   */
52039  
52040  
52041  
52042  
52043  
52044  
52045  
52046  
52047  
52048  /**
52049   * Internal dependencies
52050   */
52051  
52052  
52053  
52054  
52055  const defaultRenderToggle = ({
52056    onToggle,
52057    disabled,
52058    isOpen,
52059    blockTitle,
52060    hasSingleBlockType,
52061    toggleProps = {}
52062  }) => {
52063    const {
52064      as: Wrapper = external_wp_components_namespaceObject.Button,
52065      label: labelProp,
52066      onClick,
52067      ...rest
52068    } = toggleProps;
52069    let label = labelProp;
52070    if (!label && hasSingleBlockType) {
52071      label = (0,external_wp_i18n_namespaceObject.sprintf)(
52072      // translators: %s: the name of the block when there is only one
52073      (0,external_wp_i18n_namespaceObject._x)('Add %s', 'directly add the only allowed block'), blockTitle);
52074    } else if (!label) {
52075      label = (0,external_wp_i18n_namespaceObject._x)('Add block', 'Generic label for block inserter button');
52076    }
52077  
52078    // Handle both onClick functions from the toggle and the parent component.
52079    function handleClick(event) {
52080      if (onToggle) {
52081        onToggle(event);
52082      }
52083      if (onClick) {
52084        onClick(event);
52085      }
52086    }
52087    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Wrapper, {
52088      __next40pxDefaultSize: toggleProps.as ? undefined : true,
52089      icon: library_plus,
52090      label: label,
52091      tooltipPosition: "bottom",
52092      onClick: handleClick,
52093      className: "block-editor-inserter__toggle",
52094      "aria-haspopup": !hasSingleBlockType ? 'true' : false,
52095      "aria-expanded": !hasSingleBlockType ? isOpen : false,
52096      disabled: disabled,
52097      ...rest
52098    });
52099  };
52100  class Inserter extends external_wp_element_namespaceObject.Component {
52101    constructor() {
52102      super(...arguments);
52103      this.onToggle = this.onToggle.bind(this);
52104      this.renderToggle = this.renderToggle.bind(this);
52105      this.renderContent = this.renderContent.bind(this);
52106    }
52107    onToggle(isOpen) {
52108      const {
52109        onToggle
52110      } = this.props;
52111  
52112      // Surface toggle callback to parent component.
52113      if (onToggle) {
52114        onToggle(isOpen);
52115      }
52116    }
52117  
52118    /**
52119     * Render callback to display Dropdown toggle element.
52120     *
52121     * @param {Object}   options
52122     * @param {Function} options.onToggle Callback to invoke when toggle is
52123     *                                    pressed.
52124     * @param {boolean}  options.isOpen   Whether dropdown is currently open.
52125     *
52126     * @return {Element} Dropdown toggle element.
52127     */
52128    renderToggle({
52129      onToggle,
52130      isOpen
52131    }) {
52132      const {
52133        disabled,
52134        blockTitle,
52135        hasSingleBlockType,
52136        directInsertBlock,
52137        toggleProps,
52138        hasItems,
52139        renderToggle = defaultRenderToggle
52140      } = this.props;
52141      return renderToggle({
52142        onToggle,
52143        isOpen,
52144        disabled: disabled || !hasItems,
52145        blockTitle,
52146        hasSingleBlockType,
52147        directInsertBlock,
52148        toggleProps
52149      });
52150    }
52151  
52152    /**
52153     * Render callback to display Dropdown content element.
52154     *
52155     * @param {Object}   options
52156     * @param {Function} options.onClose Callback to invoke when dropdown is
52157     *                                   closed.
52158     *
52159     * @return {Element} Dropdown content element.
52160     */
52161    renderContent({
52162      onClose
52163    }) {
52164      const {
52165        rootClientId,
52166        clientId,
52167        isAppender,
52168        showInserterHelpPanel,
52169        // This prop is experimental to give some time for the quick inserter to mature
52170        // Feel free to make them stable after a few releases.
52171        __experimentalIsQuick: isQuick,
52172        onSelectOrClose,
52173        selectBlockOnInsert
52174      } = this.props;
52175      if (isQuick) {
52176        return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(QuickInserter, {
52177          onSelect: blocks => {
52178            const firstBlock = Array.isArray(blocks) && blocks?.length ? blocks[0] : blocks;
52179            if (onSelectOrClose && typeof onSelectOrClose === 'function') {
52180              onSelectOrClose(firstBlock);
52181            }
52182            onClose();
52183          },
52184          rootClientId: rootClientId,
52185          clientId: clientId,
52186          isAppender: isAppender,
52187          selectBlockOnInsert: selectBlockOnInsert
52188        });
52189      }
52190      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(menu, {
52191        onSelect: () => {
52192          onClose();
52193        },
52194        rootClientId: rootClientId,
52195        clientId: clientId,
52196        isAppender: isAppender,
52197        showInserterHelpPanel: showInserterHelpPanel
52198      });
52199    }
52200    render() {
52201      const {
52202        position,
52203        hasSingleBlockType,
52204        directInsertBlock,
52205        insertOnlyAllowedBlock,
52206        __experimentalIsQuick: isQuick,
52207        onSelectOrClose
52208      } = this.props;
52209      if (hasSingleBlockType || directInsertBlock) {
52210        return this.renderToggle({
52211          onToggle: insertOnlyAllowedBlock
52212        });
52213      }
52214      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Dropdown, {
52215        className: "block-editor-inserter",
52216        contentClassName: dist_clsx('block-editor-inserter__popover', {
52217          'is-quick': isQuick
52218        }),
52219        popoverProps: {
52220          position,
52221          shift: true
52222        },
52223        onToggle: this.onToggle,
52224        expandOnMobile: true,
52225        headerTitle: (0,external_wp_i18n_namespaceObject.__)('Add a block'),
52226        renderToggle: this.renderToggle,
52227        renderContent: this.renderContent,
52228        onClose: onSelectOrClose
52229      });
52230    }
52231  }
52232  /* harmony default export */ const inserter = ((0,external_wp_compose_namespaceObject.compose)([(0,external_wp_data_namespaceObject.withSelect)((select, {
52233    clientId,
52234    rootClientId,
52235    shouldDirectInsert = true
52236  }) => {
52237    const {
52238      getBlockRootClientId,
52239      hasInserterItems,
52240      getAllowedBlocks,
52241      getDirectInsertBlock
52242    } = select(store);
52243    const {
52244      getBlockVariations
52245    } = select(external_wp_blocks_namespaceObject.store);
52246    rootClientId = rootClientId || getBlockRootClientId(clientId) || undefined;
52247    const allowedBlocks = getAllowedBlocks(rootClientId);
52248    const directInsertBlock = shouldDirectInsert && getDirectInsertBlock(rootClientId);
52249    const hasSingleBlockType = allowedBlocks?.length === 1 && getBlockVariations(allowedBlocks[0].name, 'inserter')?.length === 0;
52250    let allowedBlockType = false;
52251    if (hasSingleBlockType) {
52252      allowedBlockType = allowedBlocks[0];
52253    }
52254    return {
52255      hasItems: hasInserterItems(rootClientId),
52256      hasSingleBlockType,
52257      blockTitle: allowedBlockType ? allowedBlockType.title : '',
52258      allowedBlockType,
52259      directInsertBlock,
52260      rootClientId
52261    };
52262  }), (0,external_wp_data_namespaceObject.withDispatch)((dispatch, ownProps, {
52263    select
52264  }) => {
52265    return {
52266      insertOnlyAllowedBlock() {
52267        const {
52268          rootClientId,
52269          clientId,
52270          isAppender,
52271          hasSingleBlockType,
52272          allowedBlockType,
52273          directInsertBlock,
52274          onSelectOrClose,
52275          selectBlockOnInsert
52276        } = ownProps;
52277        if (!hasSingleBlockType && !directInsertBlock) {
52278          return;
52279        }
52280        function getAdjacentBlockAttributes(attributesToCopy) {
52281          const {
52282            getBlock,
52283            getPreviousBlockClientId
52284          } = select(store);
52285          if (!attributesToCopy || !clientId && !rootClientId) {
52286            return {};
52287          }
52288          const result = {};
52289          let adjacentAttributes = {};
52290  
52291          // If there is no clientId, then attempt to get attributes
52292          // from the last block within innerBlocks of the root block.
52293          if (!clientId) {
52294            const parentBlock = getBlock(rootClientId);
52295            if (parentBlock?.innerBlocks?.length) {
52296              const lastInnerBlock = parentBlock.innerBlocks[parentBlock.innerBlocks.length - 1];
52297              if (directInsertBlock && directInsertBlock?.name === lastInnerBlock.name) {
52298                adjacentAttributes = lastInnerBlock.attributes;
52299              }
52300            }
52301          } else {
52302            // Otherwise, attempt to get attributes from the
52303            // previous block relative to the current clientId.
52304            const currentBlock = getBlock(clientId);
52305            const previousBlock = getBlock(getPreviousBlockClientId(clientId));
52306            if (currentBlock?.name === previousBlock?.name) {
52307              adjacentAttributes = previousBlock?.attributes || {};
52308            }
52309          }
52310  
52311          // Copy over only those attributes flagged to be copied.
52312          attributesToCopy.forEach(attribute => {
52313            if (adjacentAttributes.hasOwnProperty(attribute)) {
52314              result[attribute] = adjacentAttributes[attribute];
52315            }
52316          });
52317          return result;
52318        }
52319        function getInsertionIndex() {
52320          const {
52321            getBlockIndex,
52322            getBlockSelectionEnd,
52323            getBlockOrder,
52324            getBlockRootClientId
52325          } = select(store);
52326  
52327          // If the clientId is defined, we insert at the position of the block.
52328          if (clientId) {
52329            return getBlockIndex(clientId);
52330          }
52331  
52332          // If there a selected block, we insert after the selected block.
52333          const end = getBlockSelectionEnd();
52334          if (!isAppender && end && getBlockRootClientId(end) === rootClientId) {
52335            return getBlockIndex(end) + 1;
52336          }
52337  
52338          // Otherwise, we insert at the end of the current rootClientId.
52339          return getBlockOrder(rootClientId).length;
52340        }
52341        const {
52342          insertBlock
52343        } = dispatch(store);
52344        let blockToInsert;
52345  
52346        // Attempt to augment the directInsertBlock with attributes from an adjacent block.
52347        // This ensures styling from nearby blocks is preserved in the newly inserted block.
52348        // See: https://github.com/WordPress/gutenberg/issues/37904
52349        if (directInsertBlock) {
52350          const newAttributes = getAdjacentBlockAttributes(directInsertBlock.attributesToCopy);
52351          blockToInsert = (0,external_wp_blocks_namespaceObject.createBlock)(directInsertBlock.name, {
52352            ...(directInsertBlock.attributes || {}),
52353            ...newAttributes
52354          });
52355        } else {
52356          blockToInsert = (0,external_wp_blocks_namespaceObject.createBlock)(allowedBlockType.name);
52357        }
52358        insertBlock(blockToInsert, getInsertionIndex(), rootClientId, selectBlockOnInsert);
52359        if (onSelectOrClose) {
52360          onSelectOrClose({
52361            clientId: blockToInsert?.clientId
52362          });
52363        }
52364        const message = (0,external_wp_i18n_namespaceObject.sprintf)(
52365        // translators: %s: the name of the block that has been added
52366        (0,external_wp_i18n_namespaceObject.__)('%s block added'), allowedBlockType.title);
52367        (0,external_wp_a11y_namespaceObject.speak)(message);
52368      }
52369    };
52370  }),
52371  // The global inserter should always be visible, we are using ( ! isAppender && ! rootClientId && ! clientId ) as
52372  // a way to detect the global Inserter.
52373  (0,external_wp_compose_namespaceObject.ifCondition)(({
52374    hasItems,
52375    isAppender,
52376    rootClientId,
52377    clientId
52378  }) => hasItems || !isAppender && !rootClientId && !clientId)])(Inserter));
52379  
52380  ;// ./node_modules/@wordpress/block-editor/build-module/components/button-block-appender/index.js
52381  /**
52382   * External dependencies
52383   */
52384  
52385  
52386  /**
52387   * WordPress dependencies
52388   */
52389  
52390  
52391  
52392  
52393  
52394  
52395  /**
52396   * Internal dependencies
52397   */
52398  
52399  
52400  function button_block_appender_ButtonBlockAppender({
52401    rootClientId,
52402    className,
52403    onFocus,
52404    tabIndex,
52405    onSelect
52406  }, ref) {
52407    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inserter, {
52408      position: "bottom center",
52409      rootClientId: rootClientId,
52410      __experimentalIsQuick: true,
52411      onSelectOrClose: (...args) => {
52412        if (onSelect && typeof onSelect === 'function') {
52413          onSelect(...args);
52414        }
52415      },
52416      renderToggle: ({
52417        onToggle,
52418        disabled,
52419        isOpen,
52420        blockTitle,
52421        hasSingleBlockType
52422      }) => {
52423        const isToggleButton = !hasSingleBlockType;
52424        const label = hasSingleBlockType ? (0,external_wp_i18n_namespaceObject.sprintf)(
52425        // translators: %s: the name of the block when there is only one
52426        (0,external_wp_i18n_namespaceObject._x)('Add %s', 'directly add the only allowed block'), blockTitle) : (0,external_wp_i18n_namespaceObject._x)('Add block', 'Generic label for block inserter button');
52427        return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
52428          __next40pxDefaultSize: true,
52429          ref: ref,
52430          onFocus: onFocus,
52431          tabIndex: tabIndex,
52432          className: dist_clsx(className, 'block-editor-button-block-appender'),
52433          onClick: onToggle,
52434          "aria-haspopup": isToggleButton ? 'true' : undefined,
52435          "aria-expanded": isToggleButton ? isOpen : undefined
52436          // Disable reason: There shouldn't be a case where this button is disabled but not visually hidden.
52437          // eslint-disable-next-line no-restricted-syntax
52438          ,
52439          disabled: disabled,
52440          label: label,
52441          showTooltip: true,
52442          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(build_module_icon, {
52443            icon: library_plus
52444          })
52445        });
52446      },
52447      isAppender: true
52448    });
52449  }
52450  
52451  /**
52452   * Use `ButtonBlockAppender` instead.
52453   *
52454   * @deprecated
52455   */
52456  const ButtonBlockerAppender = (0,external_wp_element_namespaceObject.forwardRef)((props, ref) => {
52457    external_wp_deprecated_default()(`wp.blockEditor.ButtonBlockerAppender`, {
52458      alternative: 'wp.blockEditor.ButtonBlockAppender',
52459      since: '5.9'
52460    });
52461    return button_block_appender_ButtonBlockAppender(props, ref);
52462  });
52463  
52464  /**
52465   * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/button-block-appender/README.md
52466   */
52467  /* harmony default export */ const button_block_appender = ((0,external_wp_element_namespaceObject.forwardRef)(button_block_appender_ButtonBlockAppender));
52468  
52469  ;// ./node_modules/@wordpress/block-editor/build-module/components/grid/grid-visualizer.js
52470  /**
52471   * External dependencies
52472   */
52473  
52474  
52475  /**
52476   * WordPress dependencies
52477   */
52478  
52479  
52480  
52481  
52482  /**
52483   * Internal dependencies
52484   */
52485  
52486  
52487  
52488  
52489  
52490  
52491  
52492  
52493  function GridVisualizer({
52494    clientId,
52495    contentRef,
52496    parentLayout
52497  }) {
52498    const isDistractionFree = (0,external_wp_data_namespaceObject.useSelect)(select => select(store).getSettings().isDistractionFree, []);
52499    const gridElement = useBlockElement(clientId);
52500    if (isDistractionFree || !gridElement) {
52501      return null;
52502    }
52503    const isManualGrid = parentLayout?.isManualPlacement && window.__experimentalEnableGridInteractivity;
52504    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(GridVisualizerGrid, {
52505      gridClientId: clientId,
52506      gridElement: gridElement,
52507      isManualGrid: isManualGrid,
52508      ref: contentRef
52509    });
52510  }
52511  const GridVisualizerGrid = (0,external_wp_element_namespaceObject.forwardRef)(({
52512    gridClientId,
52513    gridElement,
52514    isManualGrid
52515  }, ref) => {
52516    const [gridInfo, setGridInfo] = (0,external_wp_element_namespaceObject.useState)(() => getGridInfo(gridElement));
52517    const [isDroppingAllowed, setIsDroppingAllowed] = (0,external_wp_element_namespaceObject.useState)(false);
52518    (0,external_wp_element_namespaceObject.useEffect)(() => {
52519      const resizeCallback = () => setGridInfo(getGridInfo(gridElement));
52520      // Both border-box and content-box are observed as they may change
52521      // independently. This requires two observers because a single one
52522      // can’t be made to monitor both on the same element.
52523      const borderBoxSpy = new window.ResizeObserver(resizeCallback);
52524      borderBoxSpy.observe(gridElement, {
52525        box: 'border-box'
52526      });
52527      const contentBoxSpy = new window.ResizeObserver(resizeCallback);
52528      contentBoxSpy.observe(gridElement);
52529      return () => {
52530        borderBoxSpy.disconnect();
52531        contentBoxSpy.disconnect();
52532      };
52533    }, [gridElement]);
52534    (0,external_wp_element_namespaceObject.useEffect)(() => {
52535      function onGlobalDrag() {
52536        setIsDroppingAllowed(true);
52537      }
52538      function onGlobalDragEnd() {
52539        setIsDroppingAllowed(false);
52540      }
52541      document.addEventListener('drag', onGlobalDrag);
52542      document.addEventListener('dragend', onGlobalDragEnd);
52543      return () => {
52544        document.removeEventListener('drag', onGlobalDrag);
52545        document.removeEventListener('dragend', onGlobalDragEnd);
52546      };
52547    }, []);
52548    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(cover, {
52549      className: dist_clsx('block-editor-grid-visualizer', {
52550        'is-dropping-allowed': isDroppingAllowed
52551      }),
52552      clientId: gridClientId,
52553      __unstablePopoverSlot: "__unstable-block-tools-after",
52554      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
52555        ref: ref,
52556        className: "block-editor-grid-visualizer__grid",
52557        style: gridInfo.style,
52558        children: isManualGrid ? /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ManualGridVisualizer, {
52559          gridClientId: gridClientId,
52560          gridInfo: gridInfo
52561        }) : Array.from({
52562          length: gridInfo.numItems
52563        }, (_, i) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(GridVisualizerCell, {
52564          color: gridInfo.currentColor
52565        }, i))
52566      })
52567    });
52568  });
52569  function ManualGridVisualizer({
52570    gridClientId,
52571    gridInfo
52572  }) {
52573    const [highlightedRect, setHighlightedRect] = (0,external_wp_element_namespaceObject.useState)(null);
52574    const gridItemStyles = (0,external_wp_data_namespaceObject.useSelect)(select => {
52575      const {
52576        getBlockOrder,
52577        getBlockStyles
52578      } = unlock(select(store));
52579      const blockOrder = getBlockOrder(gridClientId);
52580      return getBlockStyles(blockOrder);
52581    }, [gridClientId]);
52582    const occupiedRects = (0,external_wp_element_namespaceObject.useMemo)(() => {
52583      const rects = [];
52584      for (const style of Object.values(gridItemStyles)) {
52585        var _style$layout;
52586        const {
52587          columnStart,
52588          rowStart,
52589          columnSpan = 1,
52590          rowSpan = 1
52591        } = (_style$layout = style?.layout) !== null && _style$layout !== void 0 ? _style$layout : {};
52592        if (!columnStart || !rowStart) {
52593          continue;
52594        }
52595        rects.push(new GridRect({
52596          columnStart,
52597          rowStart,
52598          columnSpan,
52599          rowSpan
52600        }));
52601      }
52602      return rects;
52603    }, [gridItemStyles]);
52604    return range(1, gridInfo.numRows).map(row => range(1, gridInfo.numColumns).map(column => {
52605      var _highlightedRect$cont;
52606      const isCellOccupied = occupiedRects.some(rect => rect.contains(column, row));
52607      const isHighlighted = (_highlightedRect$cont = highlightedRect?.contains(column, row)) !== null && _highlightedRect$cont !== void 0 ? _highlightedRect$cont : false;
52608      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(GridVisualizerCell, {
52609        color: gridInfo.currentColor,
52610        className: isHighlighted && 'is-highlighted',
52611        children: isCellOccupied ? /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(GridVisualizerDropZone, {
52612          column: column,
52613          row: row,
52614          gridClientId: gridClientId,
52615          gridInfo: gridInfo,
52616          setHighlightedRect: setHighlightedRect
52617        }) : /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(GridVisualizerAppender, {
52618          column: column,
52619          row: row,
52620          gridClientId: gridClientId,
52621          gridInfo: gridInfo,
52622          setHighlightedRect: setHighlightedRect
52623        })
52624      }, `$row}-$column}`);
52625    }));
52626  }
52627  function GridVisualizerCell({
52628    color,
52629    children,
52630    className
52631  }) {
52632    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
52633      className: dist_clsx('block-editor-grid-visualizer__cell', className),
52634      style: {
52635        boxShadow: `inset 0 0 0 1px color-mix(in srgb, $color} 20%, #0000)`,
52636        color
52637      },
52638      children: children
52639    });
52640  }
52641  function useGridVisualizerDropZone(column, row, gridClientId, gridInfo, setHighlightedRect) {
52642    const {
52643      getBlockAttributes,
52644      getBlockRootClientId,
52645      canInsertBlockType,
52646      getBlockName
52647    } = (0,external_wp_data_namespaceObject.useSelect)(store);
52648    const {
52649      updateBlockAttributes,
52650      moveBlocksToPosition,
52651      __unstableMarkNextChangeAsNotPersistent
52652    } = (0,external_wp_data_namespaceObject.useDispatch)(store);
52653    const getNumberOfBlocksBeforeCell = useGetNumberOfBlocksBeforeCell(gridClientId, gridInfo.numColumns);
52654    return useDropZoneWithValidation({
52655      validateDrag(srcClientId) {
52656        const blockName = getBlockName(srcClientId);
52657        if (!canInsertBlockType(blockName, gridClientId)) {
52658          return false;
52659        }
52660        const attributes = getBlockAttributes(srcClientId);
52661        const rect = new GridRect({
52662          columnStart: column,
52663          rowStart: row,
52664          columnSpan: attributes.style?.layout?.columnSpan,
52665          rowSpan: attributes.style?.layout?.rowSpan
52666        });
52667        const isInBounds = new GridRect({
52668          columnSpan: gridInfo.numColumns,
52669          rowSpan: gridInfo.numRows
52670        }).containsRect(rect);
52671        return isInBounds;
52672      },
52673      onDragEnter(srcClientId) {
52674        const attributes = getBlockAttributes(srcClientId);
52675        setHighlightedRect(new GridRect({
52676          columnStart: column,
52677          rowStart: row,
52678          columnSpan: attributes.style?.layout?.columnSpan,
52679          rowSpan: attributes.style?.layout?.rowSpan
52680        }));
52681      },
52682      onDragLeave() {
52683        // onDragEnter can be called before onDragLeave if the user moves
52684        // their mouse quickly, so only clear the highlight if it was set
52685        // by this cell.
52686        setHighlightedRect(prevHighlightedRect => prevHighlightedRect?.columnStart === column && prevHighlightedRect?.rowStart === row ? null : prevHighlightedRect);
52687      },
52688      onDrop(srcClientId) {
52689        setHighlightedRect(null);
52690        const attributes = getBlockAttributes(srcClientId);
52691        updateBlockAttributes(srcClientId, {
52692          style: {
52693            ...attributes.style,
52694            layout: {
52695              ...attributes.style?.layout,
52696              columnStart: column,
52697              rowStart: row
52698            }
52699          }
52700        });
52701        __unstableMarkNextChangeAsNotPersistent();
52702        moveBlocksToPosition([srcClientId], getBlockRootClientId(srcClientId), gridClientId, getNumberOfBlocksBeforeCell(column, row));
52703      }
52704    });
52705  }
52706  function GridVisualizerDropZone({
52707    column,
52708    row,
52709    gridClientId,
52710    gridInfo,
52711    setHighlightedRect
52712  }) {
52713    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
52714      className: "block-editor-grid-visualizer__drop-zone",
52715      ref: useGridVisualizerDropZone(column, row, gridClientId, gridInfo, setHighlightedRect)
52716    });
52717  }
52718  function GridVisualizerAppender({
52719    column,
52720    row,
52721    gridClientId,
52722    gridInfo,
52723    setHighlightedRect
52724  }) {
52725    const {
52726      updateBlockAttributes,
52727      moveBlocksToPosition,
52728      __unstableMarkNextChangeAsNotPersistent
52729    } = (0,external_wp_data_namespaceObject.useDispatch)(store);
52730    const getNumberOfBlocksBeforeCell = useGetNumberOfBlocksBeforeCell(gridClientId, gridInfo.numColumns);
52731    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(button_block_appender, {
52732      rootClientId: gridClientId,
52733      className: "block-editor-grid-visualizer__appender",
52734      ref: useGridVisualizerDropZone(column, row, gridClientId, gridInfo, setHighlightedRect),
52735      style: {
52736        color: gridInfo.currentColor
52737      },
52738      onSelect: block => {
52739        if (!block) {
52740          return;
52741        }
52742        updateBlockAttributes(block.clientId, {
52743          style: {
52744            layout: {
52745              columnStart: column,
52746              rowStart: row
52747            }
52748          }
52749        });
52750        __unstableMarkNextChangeAsNotPersistent();
52751        moveBlocksToPosition([block.clientId], gridClientId, gridClientId, getNumberOfBlocksBeforeCell(column, row));
52752      }
52753    });
52754  }
52755  function useDropZoneWithValidation({
52756    validateDrag,
52757    onDragEnter,
52758    onDragLeave,
52759    onDrop
52760  }) {
52761    const {
52762      getDraggedBlockClientIds
52763    } = (0,external_wp_data_namespaceObject.useSelect)(store);
52764    return (0,external_wp_compose_namespaceObject.__experimentalUseDropZone)({
52765      onDragEnter() {
52766        const [srcClientId] = getDraggedBlockClientIds();
52767        if (srcClientId && validateDrag(srcClientId)) {
52768          onDragEnter(srcClientId);
52769        }
52770      },
52771      onDragLeave() {
52772        onDragLeave();
52773      },
52774      onDrop() {
52775        const [srcClientId] = getDraggedBlockClientIds();
52776        if (srcClientId && validateDrag(srcClientId)) {
52777          onDrop(srcClientId);
52778        }
52779      }
52780    });
52781  }
52782  
52783  ;// ./node_modules/@wordpress/block-editor/build-module/components/grid/grid-item-resizer.js
52784  /**
52785   * WordPress dependencies
52786   */
52787  
52788  
52789  
52790  /**
52791   * Internal dependencies
52792   */
52793  
52794  
52795  
52796  
52797  function GridItemResizer({
52798    clientId,
52799    bounds,
52800    onChange,
52801    parentLayout
52802  }) {
52803    const blockElement = useBlockElement(clientId);
52804    const rootBlockElement = blockElement?.parentElement;
52805    const {
52806      isManualPlacement
52807    } = parentLayout;
52808    if (!blockElement || !rootBlockElement) {
52809      return null;
52810    }
52811    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(GridItemResizerInner, {
52812      clientId: clientId,
52813      bounds: bounds,
52814      blockElement: blockElement,
52815      rootBlockElement: rootBlockElement,
52816      onChange: onChange,
52817      isManualGrid: isManualPlacement && window.__experimentalEnableGridInteractivity
52818    });
52819  }
52820  function GridItemResizerInner({
52821    clientId,
52822    bounds,
52823    blockElement,
52824    rootBlockElement,
52825    onChange,
52826    isManualGrid
52827  }) {
52828    const [resizeDirection, setResizeDirection] = (0,external_wp_element_namespaceObject.useState)(null);
52829    const [enableSide, setEnableSide] = (0,external_wp_element_namespaceObject.useState)({
52830      top: false,
52831      bottom: false,
52832      left: false,
52833      right: false
52834    });
52835    (0,external_wp_element_namespaceObject.useEffect)(() => {
52836      const observer = new window.ResizeObserver(() => {
52837        const blockClientRect = blockElement.getBoundingClientRect();
52838        const rootBlockClientRect = rootBlockElement.getBoundingClientRect();
52839        setEnableSide({
52840          top: blockClientRect.top > rootBlockClientRect.top,
52841          bottom: blockClientRect.bottom < rootBlockClientRect.bottom,
52842          left: blockClientRect.left > rootBlockClientRect.left,
52843          right: blockClientRect.right < rootBlockClientRect.right
52844        });
52845      });
52846      observer.observe(blockElement);
52847      return () => observer.disconnect();
52848    }, [blockElement, rootBlockElement]);
52849    const justification = {
52850      right: 'left',
52851      left: 'right'
52852    };
52853    const alignment = {
52854      top: 'flex-end',
52855      bottom: 'flex-start'
52856    };
52857    const styles = {
52858      display: 'flex',
52859      justifyContent: 'center',
52860      alignItems: 'center',
52861      ...(justification[resizeDirection] && {
52862        justifyContent: justification[resizeDirection]
52863      }),
52864      ...(alignment[resizeDirection] && {
52865        alignItems: alignment[resizeDirection]
52866      })
52867    };
52868    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(cover, {
52869      className: "block-editor-grid-item-resizer",
52870      clientId: clientId,
52871      __unstablePopoverSlot: "__unstable-block-tools-after",
52872      additionalStyles: styles,
52873      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ResizableBox, {
52874        className: "block-editor-grid-item-resizer__box",
52875        size: {
52876          width: '100%',
52877          height: '100%'
52878        },
52879        enable: {
52880          bottom: enableSide.bottom,
52881          bottomLeft: false,
52882          bottomRight: false,
52883          left: enableSide.left,
52884          right: enableSide.right,
52885          top: enableSide.top,
52886          topLeft: false,
52887          topRight: false
52888        },
52889        bounds: bounds,
52890        boundsByDirection: true,
52891        onPointerDown: ({
52892          target,
52893          pointerId
52894        }) => {
52895          /*
52896           * Captures the pointer to avoid hiccups while dragging over objects
52897           * like iframes and ensures that the event to end the drag is
52898           * captured by the target (resize handle) whether or not it’s under
52899           * the pointer.
52900           */
52901          target.setPointerCapture(pointerId);
52902        },
52903        onResizeStart: (event, direction) => {
52904          /*
52905           * The container justification and alignment need to be set
52906           * according to the direction the resizer is being dragged in,
52907           * so that it resizes in the right direction.
52908           */
52909          setResizeDirection(direction);
52910        },
52911        onResizeStop: (event, direction, boxElement) => {
52912          const columnGap = parseFloat(utils_getComputedCSS(rootBlockElement, 'column-gap'));
52913          const rowGap = parseFloat(utils_getComputedCSS(rootBlockElement, 'row-gap'));
52914          const gridColumnTracks = getGridTracks(utils_getComputedCSS(rootBlockElement, 'grid-template-columns'), columnGap);
52915          const gridRowTracks = getGridTracks(utils_getComputedCSS(rootBlockElement, 'grid-template-rows'), rowGap);
52916          const rect = new window.DOMRect(blockElement.offsetLeft + boxElement.offsetLeft, blockElement.offsetTop + boxElement.offsetTop, boxElement.offsetWidth, boxElement.offsetHeight);
52917          const columnStart = getClosestTrack(gridColumnTracks, rect.left) + 1;
52918          const rowStart = getClosestTrack(gridRowTracks, rect.top) + 1;
52919          const columnEnd = getClosestTrack(gridColumnTracks, rect.right, 'end') + 1;
52920          const rowEnd = getClosestTrack(gridRowTracks, rect.bottom, 'end') + 1;
52921          onChange({
52922            columnSpan: columnEnd - columnStart + 1,
52923            rowSpan: rowEnd - rowStart + 1,
52924            columnStart: isManualGrid ? columnStart : undefined,
52925            rowStart: isManualGrid ? rowStart : undefined
52926          });
52927        }
52928      })
52929    });
52930  }
52931  
52932  ;// ./node_modules/@wordpress/icons/build-module/library/chevron-up.js
52933  /**
52934   * WordPress dependencies
52935   */
52936  
52937  
52938  const chevronUp = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
52939    viewBox: "0 0 24 24",
52940    xmlns: "http://www.w3.org/2000/svg",
52941    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
52942      d: "M6.5 12.4L12 8l5.5 4.4-.9 1.2L12 10l-4.5 3.6-1-1.2z"
52943    })
52944  });
52945  /* harmony default export */ const chevron_up = (chevronUp);
52946  
52947  ;// ./node_modules/@wordpress/icons/build-module/library/chevron-down.js
52948  /**
52949   * WordPress dependencies
52950   */
52951  
52952  
52953  const chevronDown = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
52954    viewBox: "0 0 24 24",
52955    xmlns: "http://www.w3.org/2000/svg",
52956    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
52957      d: "M17.5 11.6L12 16l-5.5-4.4.9-1.2L12 14l4.5-3.6 1 1.2z"
52958    })
52959  });
52960  /* harmony default export */ const chevron_down = (chevronDown);
52961  
52962  ;// ./node_modules/@wordpress/block-editor/build-module/components/grid/grid-item-movers.js
52963  /**
52964   * External dependencies
52965   */
52966  
52967  
52968  /**
52969   * WordPress dependencies
52970   */
52971  
52972  
52973  
52974  
52975  
52976  
52977  /**
52978   * Internal dependencies
52979   */
52980  
52981  
52982  
52983  
52984  function GridItemMovers({
52985    layout,
52986    parentLayout,
52987    onChange,
52988    gridClientId,
52989    blockClientId
52990  }) {
52991    var _layout$columnStart, _layout$rowStart, _layout$columnSpan, _layout$rowSpan;
52992    const {
52993      moveBlocksToPosition,
52994      __unstableMarkNextChangeAsNotPersistent
52995    } = (0,external_wp_data_namespaceObject.useDispatch)(store);
52996    const columnStart = (_layout$columnStart = layout?.columnStart) !== null && _layout$columnStart !== void 0 ? _layout$columnStart : 1;
52997    const rowStart = (_layout$rowStart = layout?.rowStart) !== null && _layout$rowStart !== void 0 ? _layout$rowStart : 1;
52998    const columnSpan = (_layout$columnSpan = layout?.columnSpan) !== null && _layout$columnSpan !== void 0 ? _layout$columnSpan : 1;
52999    const rowSpan = (_layout$rowSpan = layout?.rowSpan) !== null && _layout$rowSpan !== void 0 ? _layout$rowSpan : 1;
53000    const columnEnd = columnStart + columnSpan - 1;
53001    const rowEnd = rowStart + rowSpan - 1;
53002    const columnCount = parentLayout?.columnCount;
53003    const rowCount = parentLayout?.rowCount;
53004    const getNumberOfBlocksBeforeCell = useGetNumberOfBlocksBeforeCell(gridClientId, columnCount);
53005    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_controls, {
53006      group: "parent",
53007      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.ToolbarGroup, {
53008        className: "block-editor-grid-item-mover__move-button-container",
53009        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
53010          className: "block-editor-grid-item-mover__move-horizontal-button-container is-left",
53011          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(GridItemMover, {
53012            icon: (0,external_wp_i18n_namespaceObject.isRTL)() ? chevron_right : chevron_left,
53013            label: (0,external_wp_i18n_namespaceObject.__)('Move left'),
53014            description: (0,external_wp_i18n_namespaceObject.__)('Move left'),
53015            isDisabled: columnStart <= 1,
53016            onClick: () => {
53017              onChange({
53018                columnStart: columnStart - 1
53019              });
53020              __unstableMarkNextChangeAsNotPersistent();
53021              moveBlocksToPosition([blockClientId], gridClientId, gridClientId, getNumberOfBlocksBeforeCell(columnStart - 1, rowStart));
53022            }
53023          })
53024        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
53025          className: "block-editor-grid-item-mover__move-vertical-button-container",
53026          children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(GridItemMover, {
53027            className: "is-up-button",
53028            icon: chevron_up,
53029            label: (0,external_wp_i18n_namespaceObject.__)('Move up'),
53030            description: (0,external_wp_i18n_namespaceObject.__)('Move up'),
53031            isDisabled: rowStart <= 1,
53032            onClick: () => {
53033              onChange({
53034                rowStart: rowStart - 1
53035              });
53036              __unstableMarkNextChangeAsNotPersistent();
53037              moveBlocksToPosition([blockClientId], gridClientId, gridClientId, getNumberOfBlocksBeforeCell(columnStart, rowStart - 1));
53038            }
53039          }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(GridItemMover, {
53040            className: "is-down-button",
53041            icon: chevron_down,
53042            label: (0,external_wp_i18n_namespaceObject.__)('Move down'),
53043            description: (0,external_wp_i18n_namespaceObject.__)('Move down'),
53044            isDisabled: rowCount && rowEnd >= rowCount,
53045            onClick: () => {
53046              onChange({
53047                rowStart: rowStart + 1
53048              });
53049              __unstableMarkNextChangeAsNotPersistent();
53050              moveBlocksToPosition([blockClientId], gridClientId, gridClientId, getNumberOfBlocksBeforeCell(columnStart, rowStart + 1));
53051            }
53052          })]
53053        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
53054          className: "block-editor-grid-item-mover__move-horizontal-button-container is-right",
53055          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(GridItemMover, {
53056            icon: (0,external_wp_i18n_namespaceObject.isRTL)() ? chevron_left : chevron_right,
53057            label: (0,external_wp_i18n_namespaceObject.__)('Move right'),
53058            description: (0,external_wp_i18n_namespaceObject.__)('Move right'),
53059            isDisabled: columnCount && columnEnd >= columnCount,
53060            onClick: () => {
53061              onChange({
53062                columnStart: columnStart + 1
53063              });
53064              __unstableMarkNextChangeAsNotPersistent();
53065              moveBlocksToPosition([blockClientId], gridClientId, gridClientId, getNumberOfBlocksBeforeCell(columnStart + 1, rowStart));
53066            }
53067          })
53068        })]
53069      })
53070    });
53071  }
53072  function GridItemMover({
53073    className,
53074    icon,
53075    label,
53076    isDisabled,
53077    onClick,
53078    description
53079  }) {
53080    const instanceId = (0,external_wp_compose_namespaceObject.useInstanceId)(GridItemMover);
53081    const descriptionId = `block-editor-grid-item-mover-button__description-$instanceId}`;
53082    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
53083      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarButton, {
53084        className: dist_clsx('block-editor-grid-item-mover-button', className),
53085        icon: icon,
53086        label: label,
53087        "aria-describedby": descriptionId,
53088        onClick: isDisabled ? null : onClick,
53089        disabled: isDisabled,
53090        accessibleWhenDisabled: true
53091      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.VisuallyHidden, {
53092        id: descriptionId,
53093        children: description
53094      })]
53095    });
53096  }
53097  
53098  ;// ./node_modules/@wordpress/block-editor/build-module/hooks/layout-child.js
53099  /**
53100   * WordPress dependencies
53101   */
53102  
53103  
53104  
53105  
53106  /**
53107   * Internal dependencies
53108   */
53109  
53110  
53111  
53112  
53113  
53114  // Used for generating the instance ID
53115  
53116  const LAYOUT_CHILD_BLOCK_PROPS_REFERENCE = {};
53117  function useBlockPropsChildLayoutStyles({
53118    style
53119  }) {
53120    var _style$layout;
53121    const shouldRenderChildLayoutStyles = (0,external_wp_data_namespaceObject.useSelect)(select => {
53122      return !select(store).getSettings().disableLayoutStyles;
53123    });
53124    const layout = (_style$layout = style?.layout) !== null && _style$layout !== void 0 ? _style$layout : {};
53125    const {
53126      selfStretch,
53127      flexSize,
53128      columnStart,
53129      rowStart,
53130      columnSpan,
53131      rowSpan
53132    } = layout;
53133    const parentLayout = useLayout() || {};
53134    const {
53135      columnCount,
53136      minimumColumnWidth
53137    } = parentLayout;
53138    const id = (0,external_wp_compose_namespaceObject.useInstanceId)(LAYOUT_CHILD_BLOCK_PROPS_REFERENCE);
53139    const selector = `.wp-container-content-$id}`;
53140  
53141    // Check that the grid layout attributes are of the correct type, so that we don't accidentally
53142    // write code that stores a string attribute instead of a number.
53143    if (false) {}
53144    let css = '';
53145    if (shouldRenderChildLayoutStyles) {
53146      if (selfStretch === 'fixed' && flexSize) {
53147        css = `$selector} {
53148                  flex-basis: $flexSize};
53149                  box-sizing: border-box;
53150              }`;
53151      } else if (selfStretch === 'fill') {
53152        css = `$selector} {
53153                  flex-grow: 1;
53154              }`;
53155      } else if (columnStart && columnSpan) {
53156        css = `$selector} {
53157                  grid-column: $columnStart} / span $columnSpan};
53158              }`;
53159      } else if (columnStart) {
53160        css = `$selector} {
53161                  grid-column: $columnStart};
53162              }`;
53163      } else if (columnSpan) {
53164        css = `$selector} {
53165                  grid-column: span $columnSpan};
53166              }`;
53167      }
53168      if (rowStart && rowSpan) {
53169        css += `$selector} {
53170                  grid-row: $rowStart} / span $rowSpan};
53171              }`;
53172      } else if (rowStart) {
53173        css += `$selector} {
53174                  grid-row: $rowStart};
53175              }`;
53176      } else if (rowSpan) {
53177        css += `$selector} {
53178                  grid-row: span $rowSpan};
53179              }`;
53180      }
53181      /**
53182       * If minimumColumnWidth is set on the parent, or if no
53183       * columnCount is set, the grid is responsive so a
53184       * container query is needed for the span to resize.
53185       */
53186      if ((columnSpan || columnStart) && (minimumColumnWidth || !columnCount)) {
53187        let parentColumnValue = parseFloat(minimumColumnWidth);
53188        /**
53189         * 12rem is the default minimumColumnWidth value.
53190         * If parentColumnValue is not a number, default to 12.
53191         */
53192        if (isNaN(parentColumnValue)) {
53193          parentColumnValue = 12;
53194        }
53195        let parentColumnUnit = minimumColumnWidth?.replace(parentColumnValue, '');
53196        /**
53197         * Check that parent column unit is either 'px', 'rem' or 'em'.
53198         * If not, default to 'rem'.
53199         */
53200        if (!['px', 'rem', 'em'].includes(parentColumnUnit)) {
53201          parentColumnUnit = 'rem';
53202        }
53203        let numColsToBreakAt = 2;
53204        if (columnSpan && columnStart) {
53205          numColsToBreakAt = columnSpan + columnStart - 1;
53206        } else if (columnSpan) {
53207          numColsToBreakAt = columnSpan;
53208        } else {
53209          numColsToBreakAt = columnStart;
53210        }
53211        const defaultGapValue = parentColumnUnit === 'px' ? 24 : 1.5;
53212        const containerQueryValue = numColsToBreakAt * parentColumnValue + (numColsToBreakAt - 1) * defaultGapValue;
53213        // For blocks that only span one column, we want to remove any rowStart values as
53214        // the container reduces in size, so that blocks are still arranged in markup order.
53215        const minimumContainerQueryValue = parentColumnValue * 2 + defaultGapValue - 1;
53216        // If a span is set we want to preserve it as long as possible, otherwise we just reset the value.
53217        const gridColumnValue = columnSpan && columnSpan > 1 ? '1/-1' : 'auto';
53218        css += `@container (max-width: $Math.max(containerQueryValue, minimumContainerQueryValue)}$parentColumnUnit}) {
53219                  $selector} {
53220                      grid-column: $gridColumnValue};
53221                      grid-row: auto;
53222                  }
53223              }`;
53224      }
53225    }
53226    useStyleOverride({
53227      css
53228    });
53229  
53230    // Only attach a container class if there is generated CSS to be attached.
53231    if (!css) {
53232      return;
53233    }
53234  
53235    // Attach a `wp-container-content` id-based classname.
53236    return {
53237      className: `wp-container-content-$id}`
53238    };
53239  }
53240  function ChildLayoutControlsPure({
53241    clientId,
53242    style,
53243    setAttributes
53244  }) {
53245    const parentLayout = useLayout() || {};
53246    const {
53247      type: parentLayoutType = 'default',
53248      allowSizingOnChildren = false,
53249      isManualPlacement
53250    } = parentLayout;
53251    if (parentLayoutType !== 'grid') {
53252      return null;
53253    }
53254    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(GridTools, {
53255      clientId: clientId,
53256      style: style,
53257      setAttributes: setAttributes,
53258      allowSizingOnChildren: allowSizingOnChildren,
53259      isManualPlacement: isManualPlacement,
53260      parentLayout: parentLayout
53261    });
53262  }
53263  function GridTools({
53264    clientId,
53265    style,
53266    setAttributes,
53267    allowSizingOnChildren,
53268    isManualPlacement,
53269    parentLayout
53270  }) {
53271    const {
53272      rootClientId,
53273      isVisible
53274    } = (0,external_wp_data_namespaceObject.useSelect)(select => {
53275      const {
53276        getBlockRootClientId,
53277        getBlockEditingMode,
53278        getTemplateLock
53279      } = select(store);
53280      const _rootClientId = getBlockRootClientId(clientId);
53281      if (getTemplateLock(_rootClientId) || getBlockEditingMode(_rootClientId) !== 'default') {
53282        return {
53283          rootClientId: _rootClientId,
53284          isVisible: false
53285        };
53286      }
53287      return {
53288        rootClientId: _rootClientId,
53289        isVisible: true
53290      };
53291    }, [clientId]);
53292  
53293    // Use useState() instead of useRef() so that GridItemResizer updates when ref is set.
53294    const [resizerBounds, setResizerBounds] = (0,external_wp_element_namespaceObject.useState)();
53295    if (!isVisible) {
53296      return null;
53297    }
53298    function updateLayout(layout) {
53299      setAttributes({
53300        style: {
53301          ...style,
53302          layout: {
53303            ...style?.layout,
53304            ...layout
53305          }
53306        }
53307      });
53308    }
53309    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
53310      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(GridVisualizer, {
53311        clientId: rootClientId,
53312        contentRef: setResizerBounds,
53313        parentLayout: parentLayout
53314      }), allowSizingOnChildren && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(GridItemResizer, {
53315        clientId: clientId
53316        // Don't allow resizing beyond the grid visualizer.
53317        ,
53318        bounds: resizerBounds,
53319        onChange: updateLayout,
53320        parentLayout: parentLayout
53321      }), isManualPlacement && window.__experimentalEnableGridInteractivity && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(GridItemMovers, {
53322        layout: style?.layout,
53323        parentLayout: parentLayout,
53324        onChange: updateLayout,
53325        gridClientId: rootClientId,
53326        blockClientId: clientId
53327      })]
53328    });
53329  }
53330  /* harmony default export */ const layout_child = ({
53331    useBlockProps: useBlockPropsChildLayoutStyles,
53332    edit: ChildLayoutControlsPure,
53333    attributeKeys: ['style'],
53334    hasSupport() {
53335      return true;
53336    }
53337  });
53338  
53339  ;// ./node_modules/@wordpress/block-editor/build-module/hooks/content-lock-ui.js
53340  /**
53341   * WordPress dependencies
53342   */
53343  
53344  
53345  
53346  
53347  
53348  /**
53349   * Internal dependencies
53350   */
53351  
53352  
53353  
53354  
53355  // The implementation of content locking is mainly in this file, although the mechanism
53356  // to stop temporarily editing as blocks when an outside block is selected is on component StopEditingAsBlocksOnOutsideSelect
53357  // at block-editor/src/components/block-list/index.js.
53358  // Besides the components on this file and the file referenced above the implementation
53359  // also includes artifacts on the store (actions, reducers, and selector).
53360  
53361  function ContentLockControlsPure({
53362    clientId
53363  }) {
53364    const {
53365      templateLock,
53366      isLockedByParent,
53367      isEditingAsBlocks
53368    } = (0,external_wp_data_namespaceObject.useSelect)(select => {
53369      const {
53370        getContentLockingParent,
53371        getTemplateLock,
53372        getTemporarilyEditingAsBlocks
53373      } = unlock(select(store));
53374      return {
53375        templateLock: getTemplateLock(clientId),
53376        isLockedByParent: !!getContentLockingParent(clientId),
53377        isEditingAsBlocks: getTemporarilyEditingAsBlocks() === clientId
53378      };
53379    }, [clientId]);
53380    const {
53381      stopEditingAsBlocks
53382    } = unlock((0,external_wp_data_namespaceObject.useDispatch)(store));
53383    const isContentLocked = !isLockedByParent && templateLock === 'contentOnly';
53384    const stopEditingAsBlockCallback = (0,external_wp_element_namespaceObject.useCallback)(() => {
53385      stopEditingAsBlocks(clientId);
53386    }, [clientId, stopEditingAsBlocks]);
53387    if (!isContentLocked && !isEditingAsBlocks) {
53388      return null;
53389    }
53390    const showStopEditingAsBlocks = isEditingAsBlocks && !isContentLocked;
53391    return showStopEditingAsBlocks && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_controls, {
53392      group: "other",
53393      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarButton, {
53394        onClick: stopEditingAsBlockCallback,
53395        children: (0,external_wp_i18n_namespaceObject.__)('Done')
53396      })
53397    });
53398  }
53399  /* harmony default export */ const content_lock_ui = ({
53400    edit: ContentLockControlsPure,
53401    hasSupport() {
53402      return true;
53403    }
53404  });
53405  
53406  ;// ./node_modules/@wordpress/block-editor/build-module/hooks/metadata.js
53407  /**
53408   * WordPress dependencies
53409   */
53410  
53411  const META_ATTRIBUTE_NAME = 'metadata';
53412  
53413  /**
53414   * Filters registered block settings, extending attributes to include `metadata`.
53415   *
53416   * see: https://github.com/WordPress/gutenberg/pull/40393/files#r864632012
53417   *
53418   * @param {Object} blockTypeSettings Original block settings.
53419   * @return {Object} Filtered block settings.
53420   */
53421  function addMetaAttribute(blockTypeSettings) {
53422    // Allow blocks to specify their own attribute definition with default values if needed.
53423    if (blockTypeSettings?.attributes?.[META_ATTRIBUTE_NAME]?.type) {
53424      return blockTypeSettings;
53425    }
53426    blockTypeSettings.attributes = {
53427      ...blockTypeSettings.attributes,
53428      [META_ATTRIBUTE_NAME]: {
53429        type: 'object'
53430      }
53431    };
53432    return blockTypeSettings;
53433  }
53434  (0,external_wp_hooks_namespaceObject.addFilter)('blocks.registerBlockType', 'core/metadata/addMetaAttribute', addMetaAttribute);
53435  
53436  ;// ./node_modules/@wordpress/block-editor/build-module/hooks/block-hooks.js
53437  /**
53438   * WordPress dependencies
53439   */
53440  
53441  
53442  
53443  
53444  
53445  
53446  /**
53447   * Internal dependencies
53448   */
53449  
53450  
53451  
53452  const block_hooks_EMPTY_OBJECT = {};
53453  function BlockHooksControlPure({
53454    name,
53455    clientId,
53456    metadata: {
53457      ignoredHookedBlocks = []
53458    } = {}
53459  }) {
53460    const blockTypes = (0,external_wp_data_namespaceObject.useSelect)(select => select(external_wp_blocks_namespaceObject.store).getBlockTypes(), []);
53461  
53462    // A hooked block added via a filter will not be exposed through a block
53463    // type's `blockHooks` property; however, if the containing layout has been
53464    // modified, it will be present in the anchor block's `ignoredHookedBlocks`
53465    // metadata.
53466    const hookedBlocksForCurrentBlock = (0,external_wp_element_namespaceObject.useMemo)(() => blockTypes?.filter(({
53467      name: blockName,
53468      blockHooks
53469    }) => blockHooks && name in blockHooks || ignoredHookedBlocks.includes(blockName)), [blockTypes, name, ignoredHookedBlocks]);
53470    const hookedBlockClientIds = (0,external_wp_data_namespaceObject.useSelect)(select => {
53471      const {
53472        getBlocks,
53473        getBlockRootClientId,
53474        getGlobalBlockCount
53475      } = select(store);
53476      const rootClientId = getBlockRootClientId(clientId);
53477      const _hookedBlockClientIds = hookedBlocksForCurrentBlock.reduce((clientIds, block) => {
53478        // If the block doesn't exist anywhere in the block tree,
53479        // we know that we have to set the toggle to disabled.
53480        if (getGlobalBlockCount(block.name) === 0) {
53481          return clientIds;
53482        }
53483        const relativePosition = block?.blockHooks?.[name];
53484        let candidates;
53485        switch (relativePosition) {
53486          case 'before':
53487          case 'after':
53488            // Any of the current block's siblings (with the right block type) qualifies
53489            // as a hooked block (inserted `before` or `after` the current one), as the block
53490            // might've been automatically inserted and then moved around a bit by the user.
53491            candidates = getBlocks(rootClientId);
53492            break;
53493          case 'first_child':
53494          case 'last_child':
53495            // Any of the current block's child blocks (with the right block type) qualifies
53496            // as a hooked first or last child block, as the block might've been automatically
53497            // inserted and then moved around a bit by the user.
53498            candidates = getBlocks(clientId);
53499            break;
53500          case undefined:
53501            // If we haven't found a blockHooks field with a relative position for the hooked
53502            // block, it means that it was added by a filter. In this case, we look for the block
53503            // both among the current block's siblings and its children.
53504            candidates = [...getBlocks(rootClientId), ...getBlocks(clientId)];
53505            break;
53506        }
53507        const hookedBlock = candidates?.find(candidate => candidate.name === block.name);
53508  
53509        // If the block exists in the designated location, we consider it hooked
53510        // and show the toggle as enabled.
53511        if (hookedBlock) {
53512          return {
53513            ...clientIds,
53514            [block.name]: hookedBlock.clientId
53515          };
53516        }
53517  
53518        // If no hooked block was found in any of its designated locations,
53519        // we set the toggle to disabled.
53520        return clientIds;
53521      }, {});
53522      if (Object.values(_hookedBlockClientIds).length > 0) {
53523        return _hookedBlockClientIds;
53524      }
53525      return block_hooks_EMPTY_OBJECT;
53526    }, [hookedBlocksForCurrentBlock, name, clientId]);
53527    const {
53528      getBlockIndex,
53529      getBlockCount,
53530      getBlockRootClientId
53531    } = (0,external_wp_data_namespaceObject.useSelect)(store);
53532    const {
53533      insertBlock,
53534      removeBlock
53535    } = (0,external_wp_data_namespaceObject.useDispatch)(store);
53536    if (!hookedBlocksForCurrentBlock.length) {
53537      return null;
53538    }
53539  
53540    // Group by block namespace (i.e. prefix before the slash).
53541    const groupedHookedBlocks = hookedBlocksForCurrentBlock.reduce((groups, block) => {
53542      const [namespace] = block.name.split('/');
53543      if (!groups[namespace]) {
53544        groups[namespace] = [];
53545      }
53546      groups[namespace].push(block);
53547      return groups;
53548    }, {});
53549    const insertBlockIntoDesignatedLocation = (block, relativePosition) => {
53550      const blockIndex = getBlockIndex(clientId);
53551      const innerBlocksLength = getBlockCount(clientId);
53552      const rootClientId = getBlockRootClientId(clientId);
53553      switch (relativePosition) {
53554        case 'before':
53555        case 'after':
53556          insertBlock(block, relativePosition === 'after' ? blockIndex + 1 : blockIndex, rootClientId,
53557          // Insert as a child of the current block's parent
53558          false);
53559          break;
53560        case 'first_child':
53561        case 'last_child':
53562          insertBlock(block,
53563          // TODO: It'd be great if insertBlock() would accept negative indices for insertion.
53564          relativePosition === 'first_child' ? 0 : innerBlocksLength, clientId,
53565          // Insert as a child of the current block.
53566          false);
53567          break;
53568        case undefined:
53569          // If we do not know the relative position, it is because the block was
53570          // added via a filter. In this case, we default to inserting it after the
53571          // current block.
53572          insertBlock(block, blockIndex + 1, rootClientId,
53573          // Insert as a child of the current block's parent
53574          false);
53575          break;
53576      }
53577    };
53578    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls, {
53579      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.PanelBody, {
53580        className: "block-editor-hooks__block-hooks",
53581        title: (0,external_wp_i18n_namespaceObject.__)('Plugins'),
53582        initialOpen: true,
53583        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("p", {
53584          className: "block-editor-hooks__block-hooks-helptext",
53585          children: (0,external_wp_i18n_namespaceObject.__)('Manage the inclusion of blocks added automatically by plugins.')
53586        }), Object.keys(groupedHookedBlocks).map(vendor => {
53587          return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_element_namespaceObject.Fragment, {
53588            children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("h3", {
53589              children: vendor
53590            }), groupedHookedBlocks[vendor].map(block => {
53591              const checked = block.name in hookedBlockClientIds;
53592              return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToggleControl, {
53593                __nextHasNoMarginBottom: true,
53594                checked: checked,
53595                label: block.title,
53596                onChange: () => {
53597                  if (!checked) {
53598                    // Create and insert block.
53599                    const relativePosition = block.blockHooks[name];
53600                    insertBlockIntoDesignatedLocation((0,external_wp_blocks_namespaceObject.createBlock)(block.name), relativePosition);
53601                    return;
53602                  }
53603  
53604                  // Remove block.
53605                  removeBlock(hookedBlockClientIds[block.name], false);
53606                }
53607              }, block.title);
53608            })]
53609          }, vendor);
53610        })]
53611      })
53612    });
53613  }
53614  /* harmony default export */ const block_hooks = ({
53615    edit: BlockHooksControlPure,
53616    attributeKeys: ['metadata'],
53617    hasSupport() {
53618      return true;
53619    }
53620  });
53621  
53622  ;// ./node_modules/@wordpress/block-editor/build-module/hooks/block-bindings.js
53623  /**
53624   * WordPress dependencies
53625   */
53626  
53627  
53628  
53629  
53630  
53631  
53632  
53633  /**
53634   * Internal dependencies
53635   */
53636  
53637  
53638  
53639  
53640  
53641  
53642  
53643  const {
53644    Menu
53645  } = unlock(external_wp_components_namespaceObject.privateApis);
53646  const block_bindings_EMPTY_OBJECT = {};
53647  const block_bindings_useToolsPanelDropdownMenuProps = () => {
53648    const isMobile = (0,external_wp_compose_namespaceObject.useViewportMatch)('medium', '<');
53649    return !isMobile ? {
53650      popoverProps: {
53651        placement: 'left-start',
53652        // For non-mobile, inner sidebar width (248px) - button width (24px) - border (1px) + padding (16px) + spacing (20px)
53653        offset: 259
53654      }
53655    } : {};
53656  };
53657  function BlockBindingsPanelMenuContent({
53658    fieldsList,
53659    attribute,
53660    binding
53661  }) {
53662    const {
53663      clientId
53664    } = useBlockEditContext();
53665    const registeredSources = (0,external_wp_blocks_namespaceObject.getBlockBindingsSources)();
53666    const {
53667      updateBlockBindings
53668    } = useBlockBindingsUtils();
53669    const currentKey = binding?.args?.key;
53670    const attributeType = (0,external_wp_data_namespaceObject.useSelect)(select => {
53671      const {
53672        name: blockName
53673      } = select(store).getBlock(clientId);
53674      const _attributeType = (0,external_wp_blocks_namespaceObject.getBlockType)(blockName).attributes?.[attribute]?.type;
53675      return _attributeType === 'rich-text' ? 'string' : _attributeType;
53676    }, [clientId, attribute]);
53677    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_ReactJSXRuntime_namespaceObject.Fragment, {
53678      children: Object.entries(fieldsList).map(([name, fields], i) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_element_namespaceObject.Fragment, {
53679        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(Menu.Group, {
53680          children: [Object.keys(fieldsList).length > 1 && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Menu.GroupLabel, {
53681            children: registeredSources[name].label
53682          }), Object.entries(fields).filter(([, args]) => args?.type === attributeType).map(([key, args]) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(Menu.RadioItem, {
53683            onChange: () => updateBlockBindings({
53684              [attribute]: {
53685                source: name,
53686                args: {
53687                  key
53688                }
53689              }
53690            }),
53691            name: attribute + '-binding',
53692            value: key,
53693            checked: key === currentKey,
53694            children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Menu.ItemLabel, {
53695              children: args?.label
53696            }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Menu.ItemHelpText, {
53697              children: args?.value
53698            })]
53699          }, key))]
53700        }), i !== Object.keys(fieldsList).length - 1 && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Menu.Separator, {})]
53701      }, name))
53702    });
53703  }
53704  function BlockBindingsAttribute({
53705    attribute,
53706    binding,
53707    fieldsList
53708  }) {
53709    const {
53710      source: sourceName,
53711      args
53712    } = binding || {};
53713    const sourceProps = (0,external_wp_blocks_namespaceObject.getBlockBindingsSource)(sourceName);
53714    const isSourceInvalid = !sourceProps;
53715    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalVStack, {
53716      className: "block-editor-bindings__item",
53717      spacing: 0,
53718      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalText, {
53719        truncate: true,
53720        children: attribute
53721      }), !!binding && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalText, {
53722        truncate: true,
53723        variant: !isSourceInvalid && 'muted',
53724        isDestructive: isSourceInvalid,
53725        children: isSourceInvalid ? (0,external_wp_i18n_namespaceObject.__)('Invalid source') : fieldsList?.[sourceName]?.[args?.key]?.label || sourceProps?.label || sourceName
53726      })]
53727    });
53728  }
53729  function ReadOnlyBlockBindingsPanelItems({
53730    bindings,
53731    fieldsList
53732  }) {
53733    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_ReactJSXRuntime_namespaceObject.Fragment, {
53734      children: Object.entries(bindings).map(([attribute, binding]) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalItem, {
53735        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockBindingsAttribute, {
53736          attribute: attribute,
53737          binding: binding,
53738          fieldsList: fieldsList
53739        })
53740      }, attribute))
53741    });
53742  }
53743  function EditableBlockBindingsPanelItems({
53744    attributes,
53745    bindings,
53746    fieldsList
53747  }) {
53748    const {
53749      updateBlockBindings
53750    } = useBlockBindingsUtils();
53751    const isMobile = (0,external_wp_compose_namespaceObject.useViewportMatch)('medium', '<');
53752    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_ReactJSXRuntime_namespaceObject.Fragment, {
53753      children: attributes.map(attribute => {
53754        const binding = bindings[attribute];
53755        return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanelItem, {
53756          hasValue: () => !!binding,
53757          label: attribute,
53758          onDeselect: () => {
53759            updateBlockBindings({
53760              [attribute]: undefined
53761            });
53762          },
53763          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(Menu, {
53764            placement: isMobile ? 'bottom-start' : 'left-start',
53765            children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Menu.TriggerButton, {
53766              render: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalItem, {}),
53767              children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockBindingsAttribute, {
53768                attribute: attribute,
53769                binding: binding,
53770                fieldsList: fieldsList
53771              })
53772            }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Menu.Popover, {
53773              gutter: isMobile ? 8 : 36,
53774              children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockBindingsPanelMenuContent, {
53775                fieldsList: fieldsList,
53776                attribute: attribute,
53777                binding: binding
53778              })
53779            })]
53780          })
53781        }, attribute);
53782      })
53783    });
53784  }
53785  const BlockBindingsPanel = ({
53786    name: blockName,
53787    metadata
53788  }) => {
53789    const blockContext = (0,external_wp_element_namespaceObject.useContext)(block_context);
53790    const {
53791      removeAllBlockBindings
53792    } = useBlockBindingsUtils();
53793    const bindableAttributes = getBindableAttributes(blockName);
53794    const dropdownMenuProps = block_bindings_useToolsPanelDropdownMenuProps();
53795  
53796    // `useSelect` is used purposely here to ensure `getFieldsList`
53797    // is updated whenever there are updates in block context.
53798    // `source.getFieldsList` may also call a selector via `select`.
53799    const _fieldsList = {};
53800    const {
53801      fieldsList,
53802      canUpdateBlockBindings
53803    } = (0,external_wp_data_namespaceObject.useSelect)(select => {
53804      if (!bindableAttributes || bindableAttributes.length === 0) {
53805        return block_bindings_EMPTY_OBJECT;
53806      }
53807      const registeredSources = (0,external_wp_blocks_namespaceObject.getBlockBindingsSources)();
53808      Object.entries(registeredSources).forEach(([sourceName, {
53809        getFieldsList,
53810        usesContext
53811      }]) => {
53812        if (getFieldsList) {
53813          // Populate context.
53814          const context = {};
53815          if (usesContext?.length) {
53816            for (const key of usesContext) {
53817              context[key] = blockContext[key];
53818            }
53819          }
53820          const sourceList = getFieldsList({
53821            select,
53822            context
53823          });
53824          // Only add source if the list is not empty.
53825          if (Object.keys(sourceList || {}).length) {
53826            _fieldsList[sourceName] = {
53827              ...sourceList
53828            };
53829          }
53830        }
53831      });
53832      return {
53833        fieldsList: Object.values(_fieldsList).length > 0 ? _fieldsList : block_bindings_EMPTY_OBJECT,
53834        canUpdateBlockBindings: select(store).getSettings().canUpdateBlockBindings
53835      };
53836    }, [blockContext, bindableAttributes]);
53837    // Return early if there are no bindable attributes.
53838    if (!bindableAttributes || bindableAttributes.length === 0) {
53839      return null;
53840    }
53841    // Filter bindings to only show bindable attributes and remove pattern overrides.
53842    const {
53843      bindings
53844    } = metadata || {};
53845    const filteredBindings = {
53846      ...bindings
53847    };
53848    Object.keys(filteredBindings).forEach(key => {
53849      if (!canBindAttribute(blockName, key) || filteredBindings[key].source === 'core/pattern-overrides') {
53850        delete filteredBindings[key];
53851      }
53852    });
53853  
53854    // Lock the UI when the user can't update bindings or there are no fields to connect to.
53855    const readOnly = !canUpdateBlockBindings || !Object.keys(fieldsList).length;
53856    if (readOnly && Object.keys(filteredBindings).length === 0) {
53857      return null;
53858    }
53859    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls, {
53860      group: "bindings",
53861      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalToolsPanel, {
53862        label: (0,external_wp_i18n_namespaceObject.__)('Attributes'),
53863        resetAll: () => {
53864          removeAllBlockBindings();
53865        },
53866        dropdownMenuProps: dropdownMenuProps,
53867        className: "block-editor-bindings__panel",
53868        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalItemGroup, {
53869          isBordered: true,
53870          isSeparated: true,
53871          children: readOnly ? /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ReadOnlyBlockBindingsPanelItems, {
53872            bindings: filteredBindings,
53873            fieldsList: fieldsList
53874          }) : /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(EditableBlockBindingsPanelItems, {
53875            attributes: bindableAttributes,
53876            bindings: filteredBindings,
53877            fieldsList: fieldsList
53878          })
53879        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalText, {
53880          as: "div",
53881          variant: "muted",
53882          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("p", {
53883            children: (0,external_wp_i18n_namespaceObject.__)('Attributes connected to custom fields or other dynamic data.')
53884          })
53885        })]
53886      })
53887    });
53888  };
53889  /* harmony default export */ const block_bindings = ({
53890    edit: BlockBindingsPanel,
53891    attributeKeys: ['metadata'],
53892    hasSupport() {
53893      return true;
53894    }
53895  });
53896  
53897  ;// ./node_modules/@wordpress/block-editor/build-module/hooks/block-renaming.js
53898  /**
53899   * WordPress dependencies
53900   */
53901  
53902  
53903  
53904  /**
53905   * Filters registered block settings, adding an `__experimentalLabel` callback if one does not already exist.
53906   *
53907   * @param {Object} settings Original block settings.
53908   *
53909   * @return {Object} Filtered block settings.
53910   */
53911  function addLabelCallback(settings) {
53912    // If blocks provide their own label callback, do not override it.
53913    if (settings.__experimentalLabel) {
53914      return settings;
53915    }
53916    const supportsBlockNaming = (0,external_wp_blocks_namespaceObject.hasBlockSupport)(settings, 'renaming', true // default value
53917    );
53918  
53919    // Check whether block metadata is supported before using it.
53920    if (supportsBlockNaming) {
53921      settings.__experimentalLabel = (attributes, {
53922        context
53923      }) => {
53924        const {
53925          metadata
53926        } = attributes;
53927  
53928        // In the list view, use the block's name attribute as the label.
53929        if (context === 'list-view' && metadata?.name) {
53930          return metadata.name;
53931        }
53932      };
53933    }
53934    return settings;
53935  }
53936  (0,external_wp_hooks_namespaceObject.addFilter)('blocks.registerBlockType', 'core/metadata/addLabelCallback', addLabelCallback);
53937  
53938  ;// ./node_modules/@wordpress/block-editor/build-module/components/grid/use-grid-layout-sync.js
53939  /**
53940   * WordPress dependencies
53941   */
53942  
53943  
53944  
53945  
53946  /**
53947   * Internal dependencies
53948   */
53949  
53950  
53951  
53952  function useGridLayoutSync({
53953    clientId: gridClientId
53954  }) {
53955    const {
53956      gridLayout,
53957      blockOrder,
53958      selectedBlockLayout
53959    } = (0,external_wp_data_namespaceObject.useSelect)(select => {
53960      var _getBlockAttributes$l;
53961      const {
53962        getBlockAttributes,
53963        getBlockOrder
53964      } = select(store);
53965      const selectedBlock = select(store).getSelectedBlock();
53966      return {
53967        gridLayout: (_getBlockAttributes$l = getBlockAttributes(gridClientId).layout) !== null && _getBlockAttributes$l !== void 0 ? _getBlockAttributes$l : {},
53968        blockOrder: getBlockOrder(gridClientId),
53969        selectedBlockLayout: selectedBlock?.attributes.style?.layout
53970      };
53971    }, [gridClientId]);
53972    const {
53973      getBlockAttributes,
53974      getBlockRootClientId
53975    } = (0,external_wp_data_namespaceObject.useSelect)(store);
53976    const {
53977      updateBlockAttributes,
53978      __unstableMarkNextChangeAsNotPersistent
53979    } = (0,external_wp_data_namespaceObject.useDispatch)(store);
53980    const selectedBlockRect = (0,external_wp_element_namespaceObject.useMemo)(() => selectedBlockLayout ? new GridRect(selectedBlockLayout) : null, [selectedBlockLayout]);
53981    const previouslySelectedBlockRect = (0,external_wp_compose_namespaceObject.usePrevious)(selectedBlockRect);
53982    const previousIsManualPlacement = (0,external_wp_compose_namespaceObject.usePrevious)(gridLayout.isManualPlacement);
53983    const previousBlockOrder = (0,external_wp_compose_namespaceObject.usePrevious)(blockOrder);
53984    (0,external_wp_element_namespaceObject.useEffect)(() => {
53985      const updates = {};
53986      if (gridLayout.isManualPlacement) {
53987        const occupiedRects = [];
53988  
53989        // Respect the position of blocks that already have a columnStart and rowStart value.
53990        for (const clientId of blockOrder) {
53991          var _getBlockAttributes$s;
53992          const {
53993            columnStart,
53994            rowStart,
53995            columnSpan = 1,
53996            rowSpan = 1
53997          } = (_getBlockAttributes$s = getBlockAttributes(clientId).style?.layout) !== null && _getBlockAttributes$s !== void 0 ? _getBlockAttributes$s : {};
53998          if (!columnStart || !rowStart) {
53999            continue;
54000          }
54001          occupiedRects.push(new GridRect({
54002            columnStart,
54003            rowStart,
54004            columnSpan,
54005            rowSpan
54006          }));
54007        }
54008  
54009        // When in manual mode, ensure that every block has a columnStart and rowStart value.
54010        for (const clientId of blockOrder) {
54011          var _attributes$style$lay;
54012          const attributes = getBlockAttributes(clientId);
54013          const {
54014            columnStart,
54015            rowStart,
54016            columnSpan = 1,
54017            rowSpan = 1
54018          } = (_attributes$style$lay = attributes.style?.layout) !== null && _attributes$style$lay !== void 0 ? _attributes$style$lay : {};
54019          if (columnStart && rowStart) {
54020            continue;
54021          }
54022          const [newColumnStart, newRowStart] = placeBlock(occupiedRects, gridLayout.columnCount, columnSpan, rowSpan, previouslySelectedBlockRect?.columnEnd, previouslySelectedBlockRect?.rowEnd);
54023          occupiedRects.push(new GridRect({
54024            columnStart: newColumnStart,
54025            rowStart: newRowStart,
54026            columnSpan,
54027            rowSpan
54028          }));
54029          updates[clientId] = {
54030            style: {
54031              ...attributes.style,
54032              layout: {
54033                ...attributes.style?.layout,
54034                columnStart: newColumnStart,
54035                rowStart: newRowStart
54036              }
54037            }
54038          };
54039        }
54040  
54041        // Ensure there's enough rows to fit all blocks.
54042        const bottomMostRow = Math.max(...occupiedRects.map(r => r.rowEnd));
54043        if (!gridLayout.rowCount || gridLayout.rowCount < bottomMostRow) {
54044          updates[gridClientId] = {
54045            layout: {
54046              ...gridLayout,
54047              rowCount: bottomMostRow
54048            }
54049          };
54050        }
54051  
54052        // Unset grid layout attributes for blocks removed from the grid.
54053        for (const clientId of previousBlockOrder !== null && previousBlockOrder !== void 0 ? previousBlockOrder : []) {
54054          if (!blockOrder.includes(clientId)) {
54055            var _attributes$style$lay2;
54056            const rootClientId = getBlockRootClientId(clientId);
54057  
54058            // Block was removed from the editor, so nothing to do.
54059            if (rootClientId === null) {
54060              continue;
54061            }
54062  
54063            // Check if the block is being moved to another grid.
54064            // If so, do nothing and let the new grid parent handle
54065            // the attributes.
54066            const rootAttributes = getBlockAttributes(rootClientId);
54067            if (rootAttributes?.layout?.type === 'grid') {
54068              continue;
54069            }
54070            const attributes = getBlockAttributes(clientId);
54071            const {
54072              columnStart,
54073              rowStart,
54074              columnSpan,
54075              rowSpan,
54076              ...layout
54077            } = (_attributes$style$lay2 = attributes.style?.layout) !== null && _attributes$style$lay2 !== void 0 ? _attributes$style$lay2 : {};
54078            if (columnStart || rowStart || columnSpan || rowSpan) {
54079              const hasEmptyLayoutAttribute = Object.keys(layout).length === 0;
54080              updates[clientId] = setImmutably(attributes, ['style', 'layout'], hasEmptyLayoutAttribute ? undefined : layout);
54081            }
54082          }
54083        }
54084      } else {
54085        // Remove all of the columnStart and rowStart values
54086        // when switching from manual to auto mode,
54087        if (previousIsManualPlacement === true) {
54088          for (const clientId of blockOrder) {
54089            var _attributes$style$lay3;
54090            const attributes = getBlockAttributes(clientId);
54091            const {
54092              columnStart,
54093              rowStart,
54094              ...layout
54095            } = (_attributes$style$lay3 = attributes.style?.layout) !== null && _attributes$style$lay3 !== void 0 ? _attributes$style$lay3 : {};
54096            // Only update attributes if columnStart or rowStart are set.
54097            if (columnStart || rowStart) {
54098              const hasEmptyLayoutAttribute = Object.keys(layout).length === 0;
54099              updates[clientId] = setImmutably(attributes, ['style', 'layout'], hasEmptyLayoutAttribute ? undefined : layout);
54100            }
54101          }
54102        }
54103  
54104        // Remove row styles in auto mode
54105        if (gridLayout.rowCount) {
54106          updates[gridClientId] = {
54107            layout: {
54108              ...gridLayout,
54109              rowCount: undefined
54110            }
54111          };
54112        }
54113      }
54114      if (Object.keys(updates).length) {
54115        __unstableMarkNextChangeAsNotPersistent();
54116        updateBlockAttributes(Object.keys(updates), updates, /* uniqueByBlock: */true);
54117      }
54118    }, [
54119    // Actual deps to sync:
54120    gridClientId, gridLayout, previousBlockOrder, blockOrder, previouslySelectedBlockRect, previousIsManualPlacement,
54121    // These won't change, but the linter thinks they might:
54122    __unstableMarkNextChangeAsNotPersistent, getBlockAttributes, getBlockRootClientId, updateBlockAttributes]);
54123  }
54124  
54125  /**
54126   * @param {GridRect[]} occupiedRects
54127   * @param {number}     gridColumnCount
54128   * @param {number}     blockColumnSpan
54129   * @param {number}     blockRowSpan
54130   * @param {number?}    startColumn
54131   * @param {number?}    startRow
54132   */
54133  function placeBlock(occupiedRects, gridColumnCount, blockColumnSpan, blockRowSpan, startColumn = 1, startRow = 1) {
54134    for (let row = startRow;; row++) {
54135      for (let column = row === startRow ? startColumn : 1; column <= gridColumnCount; column++) {
54136        const candidateRect = new GridRect({
54137          columnStart: column,
54138          rowStart: row,
54139          columnSpan: blockColumnSpan,
54140          rowSpan: blockRowSpan
54141        });
54142        if (!occupiedRects.some(r => r.intersectsRect(candidateRect))) {
54143          return [column, row];
54144        }
54145      }
54146    }
54147  }
54148  
54149  ;// ./node_modules/@wordpress/block-editor/build-module/hooks/grid-visualizer.js
54150  /**
54151   * WordPress dependencies
54152   */
54153  
54154  
54155  
54156  
54157  /**
54158   * Internal dependencies
54159   */
54160  
54161  
54162  
54163  function GridLayoutSync(props) {
54164    useGridLayoutSync(props);
54165  }
54166  function grid_visualizer_GridTools({
54167    clientId,
54168    layout
54169  }) {
54170    const isVisible = (0,external_wp_data_namespaceObject.useSelect)(select => {
54171      const {
54172        isBlockSelected,
54173        isDraggingBlocks,
54174        getTemplateLock,
54175        getBlockEditingMode
54176      } = select(store);
54177  
54178      // These calls are purposely ordered from least expensive to most expensive.
54179      // Hides the visualizer in cases where the user is not or cannot interact with it.
54180      if (!isDraggingBlocks() && !isBlockSelected(clientId) || getTemplateLock(clientId) || getBlockEditingMode(clientId) !== 'default') {
54181        return false;
54182      }
54183      return true;
54184    }, [clientId]);
54185    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
54186      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(GridLayoutSync, {
54187        clientId: clientId
54188      }), isVisible && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(GridVisualizer, {
54189        clientId: clientId,
54190        parentLayout: layout
54191      })]
54192    });
54193  }
54194  const addGridVisualizerToBlockEdit = (0,external_wp_compose_namespaceObject.createHigherOrderComponent)(BlockEdit => props => {
54195    if (props.attributes.layout?.type !== 'grid') {
54196      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockEdit, {
54197        ...props
54198      }, "edit");
54199    }
54200    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
54201      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(grid_visualizer_GridTools, {
54202        clientId: props.clientId,
54203        layout: props.attributes.layout
54204      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockEdit, {
54205        ...props
54206      }, "edit")]
54207    });
54208  }, 'addGridVisualizerToBlockEdit');
54209  (0,external_wp_hooks_namespaceObject.addFilter)('editor.BlockEdit', 'core/editor/grid-visualizer', addGridVisualizerToBlockEdit);
54210  
54211  ;// ./node_modules/@wordpress/block-editor/build-module/hooks/use-border-props.js
54212  /**
54213   * Internal dependencies
54214   */
54215  
54216  
54217  
54218  
54219  // This utility is intended to assist where the serialization of the border
54220  // block support is being skipped for a block but the border related CSS classes
54221  // & styles still need to be generated so they can be applied to inner elements.
54222  
54223  /**
54224   * Provides the CSS class names and inline styles for a block's border support
54225   * attributes.
54226   *
54227   * @param {Object} attributes Block attributes.
54228   * @return {Object} Border block support derived CSS classes & styles.
54229   */
54230  function getBorderClassesAndStyles(attributes) {
54231    const border = attributes.style?.border || {};
54232    const className = getBorderClasses(attributes);
54233    return {
54234      className: className || undefined,
54235      style: getInlineStyles({
54236        border
54237      })
54238    };
54239  }
54240  
54241  /**
54242   * Derives the border related props for a block from its border block support
54243   * attributes.
54244   *
54245   * Inline styles are forced for named colors to ensure these selections are
54246   * reflected when themes do not load their color stylesheets in the editor.
54247   *
54248   * @param {Object} attributes Block attributes.
54249   *
54250   * @return {Object} ClassName & style props from border block support.
54251   */
54252  function useBorderProps(attributes) {
54253    const {
54254      colors
54255    } = useMultipleOriginColorsAndGradients();
54256    const borderProps = getBorderClassesAndStyles(attributes);
54257    const {
54258      borderColor
54259    } = attributes;
54260  
54261    // Force inline styles to apply named border colors when themes do not load
54262    // their color stylesheets in the editor.
54263    if (borderColor) {
54264      const borderColorObject = getMultiOriginColor({
54265        colors,
54266        namedColor: borderColor
54267      });
54268      borderProps.style.borderColor = borderColorObject.color;
54269    }
54270    return borderProps;
54271  }
54272  
54273  ;// ./node_modules/@wordpress/block-editor/build-module/hooks/use-shadow-props.js
54274  /**
54275   * Internal dependencies
54276   */
54277  
54278  
54279  // This utility is intended to assist where the serialization of the shadow
54280  // block support is being skipped for a block but the shadow related CSS classes
54281  // & styles still need to be generated so they can be applied to inner elements.
54282  
54283  /**
54284   * Provides the CSS class names and inline styles for a block's shadow support
54285   * attributes.
54286   *
54287   * @param {Object} attributes Block attributes.
54288   * @return {Object} Shadow block support derived CSS classes & styles.
54289   */
54290  function getShadowClassesAndStyles(attributes) {
54291    const shadow = attributes.style?.shadow || '';
54292    return {
54293      style: getInlineStyles({
54294        shadow
54295      })
54296    };
54297  }
54298  
54299  ;// ./node_modules/@wordpress/block-editor/build-module/hooks/use-color-props.js
54300  /**
54301   * External dependencies
54302   */
54303  
54304  
54305  /**
54306   * WordPress dependencies
54307   */
54308  
54309  
54310  /**
54311   * Internal dependencies
54312   */
54313  
54314  
54315  
54316  
54317  
54318  // The code in this file has largely been lifted from the color block support
54319  // hook.
54320  //
54321  // This utility is intended to assist where the serialization of the colors
54322  // block support is being skipped for a block but the color related CSS classes
54323  // & styles still need to be generated so they can be applied to inner elements.
54324  
54325  /**
54326   * Provides the CSS class names and inline styles for a block's color support
54327   * attributes.
54328   *
54329   * @param {Object} attributes Block attributes.
54330   *
54331   * @return {Object} Color block support derived CSS classes & styles.
54332   */
54333  function getColorClassesAndStyles(attributes) {
54334    const {
54335      backgroundColor,
54336      textColor,
54337      gradient,
54338      style
54339    } = attributes;
54340  
54341    // Collect color CSS classes.
54342    const backgroundClass = getColorClassName('background-color', backgroundColor);
54343    const textClass = getColorClassName('color', textColor);
54344    const gradientClass = __experimentalGetGradientClass(gradient);
54345    const hasGradient = gradientClass || style?.color?.gradient;
54346  
54347    // Determine color CSS class name list.
54348    const className = dist_clsx(textClass, gradientClass, {
54349      // Don't apply the background class if there's a gradient.
54350      [backgroundClass]: !hasGradient && !!backgroundClass,
54351      'has-text-color': textColor || style?.color?.text,
54352      'has-background': backgroundColor || style?.color?.background || gradient || style?.color?.gradient,
54353      'has-link-color': style?.elements?.link?.color
54354    });
54355  
54356    // Collect inline styles for colors.
54357    const colorStyles = style?.color || {};
54358    const styleProp = getInlineStyles({
54359      color: colorStyles
54360    });
54361    return {
54362      className: className || undefined,
54363      style: styleProp
54364    };
54365  }
54366  
54367  /**
54368   * Determines the color related props for a block derived from its color block
54369   * support attributes.
54370   *
54371   * Inline styles are forced for named colors to ensure these selections are
54372   * reflected when themes do not load their color stylesheets in the editor.
54373   *
54374   * @param {Object} attributes Block attributes.
54375   *
54376   * @return {Object} ClassName & style props from colors block support.
54377   */
54378  function useColorProps(attributes) {
54379    const {
54380      backgroundColor,
54381      textColor,
54382      gradient
54383    } = attributes;
54384    const [userPalette, themePalette, defaultPalette, userGradients, themeGradients, defaultGradients] = use_settings_useSettings('color.palette.custom', 'color.palette.theme', 'color.palette.default', 'color.gradients.custom', 'color.gradients.theme', 'color.gradients.default');
54385    const colors = (0,external_wp_element_namespaceObject.useMemo)(() => [...(userPalette || []), ...(themePalette || []), ...(defaultPalette || [])], [userPalette, themePalette, defaultPalette]);
54386    const gradients = (0,external_wp_element_namespaceObject.useMemo)(() => [...(userGradients || []), ...(themeGradients || []), ...(defaultGradients || [])], [userGradients, themeGradients, defaultGradients]);
54387    const colorProps = getColorClassesAndStyles(attributes);
54388  
54389    // Force inline styles to apply colors when themes do not load their color
54390    // stylesheets in the editor.
54391    if (backgroundColor) {
54392      const backgroundColorObject = getColorObjectByAttributeValues(colors, backgroundColor);
54393      colorProps.style.backgroundColor = backgroundColorObject.color;
54394    }
54395    if (gradient) {
54396      colorProps.style.background = getGradientValueBySlug(gradients, gradient);
54397    }
54398    if (textColor) {
54399      const textColorObject = getColorObjectByAttributeValues(colors, textColor);
54400      colorProps.style.color = textColorObject.color;
54401    }
54402    return colorProps;
54403  }
54404  
54405  ;// ./node_modules/@wordpress/block-editor/build-module/hooks/use-spacing-props.js
54406  /**
54407   * Internal dependencies
54408   */
54409  
54410  
54411  // This utility is intended to assist where the serialization of the spacing
54412  // block support is being skipped for a block but the spacing related CSS
54413  // styles still need to be generated so they can be applied to inner elements.
54414  
54415  /**
54416   * Provides the CSS class names and inline styles for a block's spacing support
54417   * attributes.
54418   *
54419   * @param {Object} attributes Block attributes.
54420   *
54421   * @return {Object} Spacing block support derived CSS classes & styles.
54422   */
54423  function getSpacingClassesAndStyles(attributes) {
54424    const {
54425      style
54426    } = attributes;
54427  
54428    // Collect inline styles for spacing.
54429    const spacingStyles = style?.spacing || {};
54430    const styleProp = getInlineStyles({
54431      spacing: spacingStyles
54432    });
54433    return {
54434      style: styleProp
54435    };
54436  }
54437  
54438  ;// ./node_modules/@wordpress/block-editor/build-module/hooks/use-typography-props.js
54439  /**
54440   * External dependencies
54441   */
54442  
54443  
54444  /**
54445   * WordPress dependencies
54446   */
54447  
54448  
54449  /**
54450   * Internal dependencies
54451   */
54452  
54453  
54454  
54455  
54456  const {
54457    kebabCase: use_typography_props_kebabCase
54458  } = unlock(external_wp_components_namespaceObject.privateApis);
54459  
54460  /*
54461   * This utility is intended to assist where the serialization of the typography
54462   * block support is being skipped for a block but the typography related CSS
54463   * styles still need to be generated so they can be applied to inner elements.
54464   */
54465  /**
54466   * Provides the CSS class names and inline styles for a block's typography support
54467   * attributes.
54468   *
54469   * @param {Object}         attributes Block attributes.
54470   * @param {Object|boolean} settings   Merged theme.json settings
54471   *
54472   * @return {Object} Typography block support derived CSS classes & styles.
54473   */
54474  function getTypographyClassesAndStyles(attributes, settings) {
54475    let typographyStyles = attributes?.style?.typography || {};
54476    typographyStyles = {
54477      ...typographyStyles,
54478      fontSize: getTypographyFontSizeValue({
54479        size: attributes?.style?.typography?.fontSize
54480      }, settings)
54481    };
54482    const style = getInlineStyles({
54483      typography: typographyStyles
54484    });
54485    const fontFamilyClassName = !!attributes?.fontFamily ? `has-$use_typography_props_kebabCase(attributes.fontFamily)}-font-family` : '';
54486    const textAlignClassName = !!attributes?.style?.typography?.textAlign ? `has-text-align-$attributes?.style?.typography?.textAlign}` : '';
54487    const className = dist_clsx(fontFamilyClassName, textAlignClassName, getFontSizeClass(attributes?.fontSize));
54488    return {
54489      className,
54490      style
54491    };
54492  }
54493  
54494  ;// ./node_modules/@wordpress/block-editor/build-module/hooks/use-cached-truthy.js
54495  /**
54496   * WordPress dependencies
54497   */
54498  
54499  
54500  /**
54501   * Keeps an up-to-date copy of the passed value and returns it. If value becomes falsy, it will return the last truthy copy.
54502   *
54503   * @param {any} value
54504   * @return {any} value
54505   */
54506  function useCachedTruthy(value) {
54507    const [cachedValue, setCachedValue] = (0,external_wp_element_namespaceObject.useState)(value);
54508    (0,external_wp_element_namespaceObject.useEffect)(() => {
54509      if (value) {
54510        setCachedValue(value);
54511      }
54512    }, [value]);
54513    return cachedValue;
54514  }
54515  
54516  ;// ./node_modules/@wordpress/block-editor/build-module/hooks/index.js
54517  /**
54518   * Internal dependencies
54519   */
54520  
54521  
54522  
54523  
54524  
54525  
54526  
54527  
54528  
54529  
54530  
54531  
54532  
54533  
54534  
54535  
54536  
54537  
54538  
54539  
54540  
54541  
54542  
54543  
54544  
54545  
54546  
54547  
54548  createBlockEditFilter([align, text_align, hooks_anchor, custom_class_name, style, duotone, position, layout, content_lock_ui, block_hooks, block_bindings, layout_child].filter(Boolean));
54549  createBlockListBlockFilter([align, text_align, background, style, color, dimensions, duotone, font_family, font_size, border, position, block_style_variation, layout_child]);
54550  createBlockSaveFilter([align, text_align, hooks_anchor, aria_label, custom_class_name, border, color, style, font_family, font_size]);
54551  
54552  
54553  
54554  
54555  
54556  
54557  
54558  
54559  
54560  
54561  
54562  
54563  
54564  
54565  ;// ./node_modules/@wordpress/block-editor/build-module/components/colors/with-colors.js
54566  /**
54567   * WordPress dependencies
54568   */
54569  
54570  
54571  
54572  
54573  /**
54574   * Internal dependencies
54575   */
54576  
54577  
54578  
54579  
54580  const {
54581    kebabCase: with_colors_kebabCase
54582  } = unlock(external_wp_components_namespaceObject.privateApis);
54583  
54584  /**
54585   * Capitalizes the first letter in a string.
54586   *
54587   * @param {string} str The string whose first letter the function will capitalize.
54588   *
54589   * @return {string} Capitalized string.
54590   */
54591  const upperFirst = ([firstLetter, ...rest]) => firstLetter.toUpperCase() + rest.join('');
54592  
54593  /**
54594   * Higher order component factory for injecting the `colorsArray` argument as
54595   * the colors prop in the `withCustomColors` HOC.
54596   *
54597   * @param {Array} colorsArray An array of color objects.
54598   *
54599   * @return {Function} The higher order component.
54600   */
54601  const withCustomColorPalette = colorsArray => (0,external_wp_compose_namespaceObject.createHigherOrderComponent)(WrappedComponent => props => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(WrappedComponent, {
54602    ...props,
54603    colors: colorsArray
54604  }), 'withCustomColorPalette');
54605  
54606  /**
54607   * Higher order component factory for injecting the editor colors as the
54608   * `colors` prop in the `withColors` HOC.
54609   *
54610   * @return {Function} The higher order component.
54611   */
54612  const withEditorColorPalette = () => (0,external_wp_compose_namespaceObject.createHigherOrderComponent)(WrappedComponent => props => {
54613    const [userPalette, themePalette, defaultPalette] = use_settings_useSettings('color.palette.custom', 'color.palette.theme', 'color.palette.default');
54614    const allColors = (0,external_wp_element_namespaceObject.useMemo)(() => [...(userPalette || []), ...(themePalette || []), ...(defaultPalette || [])], [userPalette, themePalette, defaultPalette]);
54615    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(WrappedComponent, {
54616      ...props,
54617      colors: allColors
54618    });
54619  }, 'withEditorColorPalette');
54620  
54621  /**
54622   * Helper function used with `createHigherOrderComponent` to create
54623   * higher order components for managing color logic.
54624   *
54625   * @param {Array}    colorTypes       An array of color types (e.g. 'backgroundColor, borderColor).
54626   * @param {Function} withColorPalette A HOC for injecting the 'colors' prop into the WrappedComponent.
54627   *
54628   * @return {Component} The component that can be used as a HOC.
54629   */
54630  function createColorHOC(colorTypes, withColorPalette) {
54631    const colorMap = colorTypes.reduce((colorObject, colorType) => {
54632      return {
54633        ...colorObject,
54634        ...(typeof colorType === 'string' ? {
54635          [colorType]: with_colors_kebabCase(colorType)
54636        } : colorType)
54637      };
54638    }, {});
54639    return (0,external_wp_compose_namespaceObject.compose)([withColorPalette, WrappedComponent => {
54640      return class extends external_wp_element_namespaceObject.Component {
54641        constructor(props) {
54642          super(props);
54643          this.setters = this.createSetters();
54644          this.colorUtils = {
54645            getMostReadableColor: this.getMostReadableColor.bind(this)
54646          };
54647          this.state = {};
54648        }
54649        getMostReadableColor(colorValue) {
54650          const {
54651            colors
54652          } = this.props;
54653          return getMostReadableColor(colors, colorValue);
54654        }
54655        createSetters() {
54656          return Object.keys(colorMap).reduce((settersAccumulator, colorAttributeName) => {
54657            const upperFirstColorAttributeName = upperFirst(colorAttributeName);
54658            const customColorAttributeName = `custom$upperFirstColorAttributeName}`;
54659            settersAccumulator[`set$upperFirstColorAttributeName}`] = this.createSetColor(colorAttributeName, customColorAttributeName);
54660            return settersAccumulator;
54661          }, {});
54662        }
54663        createSetColor(colorAttributeName, customColorAttributeName) {
54664          return colorValue => {
54665            const colorObject = getColorObjectByColorValue(this.props.colors, colorValue);
54666            this.props.setAttributes({
54667              [colorAttributeName]: colorObject && colorObject.slug ? colorObject.slug : undefined,
54668              [customColorAttributeName]: colorObject && colorObject.slug ? undefined : colorValue
54669            });
54670          };
54671        }
54672        static getDerivedStateFromProps({
54673          attributes,
54674          colors
54675        }, previousState) {
54676          return Object.entries(colorMap).reduce((newState, [colorAttributeName, colorContext]) => {
54677            const colorObject = getColorObjectByAttributeValues(colors, attributes[colorAttributeName], attributes[`custom$upperFirst(colorAttributeName)}`]);
54678            const previousColorObject = previousState[colorAttributeName];
54679            const previousColor = previousColorObject?.color;
54680            /**
54681             * The "and previousColorObject" condition checks that a previous color object was already computed.
54682             * At the start previousColorObject and colorValue are both equal to undefined
54683             * bus as previousColorObject does not exist we should compute the object.
54684             */
54685            if (previousColor === colorObject.color && previousColorObject) {
54686              newState[colorAttributeName] = previousColorObject;
54687            } else {
54688              newState[colorAttributeName] = {
54689                ...colorObject,
54690                class: getColorClassName(colorContext, colorObject.slug)
54691              };
54692            }
54693            return newState;
54694          }, {});
54695        }
54696        render() {
54697          return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(WrappedComponent, {
54698            ...this.props,
54699            colors: undefined,
54700            ...this.state,
54701            ...this.setters,
54702            colorUtils: this.colorUtils
54703          });
54704        }
54705      };
54706    }]);
54707  }
54708  
54709  /**
54710   * A higher-order component factory for creating a 'withCustomColors' HOC, which handles color logic
54711   * for class generation color value, retrieval and color attribute setting.
54712   *
54713   * Use this higher-order component to work with a custom set of colors.
54714   *
54715   * @example
54716   *
54717   * ```jsx
54718   * const CUSTOM_COLORS = [ { name: 'Red', slug: 'red', color: '#ff0000' }, { name: 'Blue', slug: 'blue', color: '#0000ff' } ];
54719   * const withCustomColors = createCustomColorsHOC( CUSTOM_COLORS );
54720   * // ...
54721   * export default compose(
54722   *     withCustomColors( 'backgroundColor', 'borderColor' ),
54723   *     MyColorfulComponent,
54724   * );
54725   * ```
54726   *
54727   * @param {Array} colorsArray The array of color objects (name, slug, color, etc... ).
54728   *
54729   * @return {Function} Higher-order component.
54730   */
54731  function createCustomColorsHOC(colorsArray) {
54732    return (...colorTypes) => {
54733      const withColorPalette = withCustomColorPalette(colorsArray);
54734      return (0,external_wp_compose_namespaceObject.createHigherOrderComponent)(createColorHOC(colorTypes, withColorPalette), 'withCustomColors');
54735    };
54736  }
54737  
54738  /**
54739   * A higher-order component, which handles color logic for class generation color value, retrieval and color attribute setting.
54740   *
54741   * For use with the default editor/theme color palette.
54742   *
54743   * @example
54744   *
54745   * ```jsx
54746   * export default compose(
54747   *     withColors( 'backgroundColor', { textColor: 'color' } ),
54748   *     MyColorfulComponent,
54749   * );
54750   * ```
54751   *
54752   * @param {...(Object|string)} colorTypes The arguments can be strings or objects. If the argument is an object,
54753   *                                        it should contain the color attribute name as key and the color context as value.
54754   *                                        If the argument is a string the value should be the color attribute name,
54755   *                                        the color context is computed by applying a kebab case transform to the value.
54756   *                                        Color context represents the context/place where the color is going to be used.
54757   *                                        The class name of the color is generated using 'has' followed by the color name
54758   *                                        and ending with the color context all in kebab case e.g: has-green-background-color.
54759   *
54760   * @return {Function} Higher-order component.
54761   */
54762  function withColors(...colorTypes) {
54763    const withColorPalette = withEditorColorPalette();
54764    return (0,external_wp_compose_namespaceObject.createHigherOrderComponent)(createColorHOC(colorTypes, withColorPalette), 'withColors');
54765  }
54766  
54767  ;// ./node_modules/@wordpress/block-editor/build-module/components/colors/index.js
54768  
54769  
54770  
54771  ;// ./node_modules/@wordpress/block-editor/build-module/components/gradients/index.js
54772  
54773  
54774  ;// ./node_modules/@wordpress/block-editor/build-module/components/font-sizes/font-size-picker.js
54775  /**
54776   * WordPress dependencies
54777   */
54778  
54779  
54780  /**
54781   * Internal dependencies
54782   */
54783  
54784  
54785  function font_size_picker_FontSizePicker(props) {
54786    const [fontSizes, customFontSize] = use_settings_useSettings('typography.fontSizes', 'typography.customFontSize');
54787    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FontSizePicker, {
54788      ...props,
54789      fontSizes: fontSizes,
54790      disableCustomFontSizes: !customFontSize
54791    });
54792  }
54793  
54794  /**
54795   * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/font-sizes/README.md
54796   */
54797  /* harmony default export */ const font_size_picker = (font_size_picker_FontSizePicker);
54798  
54799  ;// ./node_modules/@wordpress/block-editor/build-module/components/font-sizes/with-font-sizes.js
54800  /**
54801   * WordPress dependencies
54802   */
54803  
54804  
54805  
54806  /**
54807   * Internal dependencies
54808   */
54809  
54810  
54811  
54812  const DEFAULT_FONT_SIZES = [];
54813  
54814  /**
54815   * Capitalizes the first letter in a string.
54816   *
54817   * @param {string} str The string whose first letter the function will capitalize.
54818   *
54819   * @return {string} Capitalized string.
54820   */
54821  const with_font_sizes_upperFirst = ([firstLetter, ...rest]) => firstLetter.toUpperCase() + rest.join('');
54822  
54823  /**
54824   * Higher-order component, which handles font size logic for class generation,
54825   * font size value retrieval, and font size change handling.
54826   *
54827   * @param {...(Object|string)} fontSizeNames The arguments should all be strings.
54828   *                                           Each string contains the font size
54829   *                                           attribute name e.g: 'fontSize'.
54830   *
54831   * @return {Function} Higher-order component.
54832   */
54833  /* harmony default export */ const with_font_sizes = ((...fontSizeNames) => {
54834    /*
54835     * Computes an object whose key is the font size attribute name as passed in the array,
54836     * and the value is the custom font size attribute name.
54837     * Custom font size is automatically compted by appending custom followed by the font size attribute name in with the first letter capitalized.
54838     */
54839    const fontSizeAttributeNames = fontSizeNames.reduce((fontSizeAttributeNamesAccumulator, fontSizeAttributeName) => {
54840      fontSizeAttributeNamesAccumulator[fontSizeAttributeName] = `custom$with_font_sizes_upperFirst(fontSizeAttributeName)}`;
54841      return fontSizeAttributeNamesAccumulator;
54842    }, {});
54843    return (0,external_wp_compose_namespaceObject.createHigherOrderComponent)((0,external_wp_compose_namespaceObject.compose)([(0,external_wp_compose_namespaceObject.createHigherOrderComponent)(WrappedComponent => props => {
54844      const [fontSizes] = use_settings_useSettings('typography.fontSizes');
54845      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(WrappedComponent, {
54846        ...props,
54847        fontSizes: fontSizes || DEFAULT_FONT_SIZES
54848      });
54849    }, 'withFontSizes'), WrappedComponent => {
54850      return class extends external_wp_element_namespaceObject.Component {
54851        constructor(props) {
54852          super(props);
54853          this.setters = this.createSetters();
54854          this.state = {};
54855        }
54856        createSetters() {
54857          return Object.entries(fontSizeAttributeNames).reduce((settersAccumulator, [fontSizeAttributeName, customFontSizeAttributeName]) => {
54858            const upperFirstFontSizeAttributeName = with_font_sizes_upperFirst(fontSizeAttributeName);
54859            settersAccumulator[`set$upperFirstFontSizeAttributeName}`] = this.createSetFontSize(fontSizeAttributeName, customFontSizeAttributeName);
54860            return settersAccumulator;
54861          }, {});
54862        }
54863        createSetFontSize(fontSizeAttributeName, customFontSizeAttributeName) {
54864          return fontSizeValue => {
54865            const fontSizeObject = this.props.fontSizes?.find(({
54866              size
54867            }) => size === Number(fontSizeValue));
54868            this.props.setAttributes({
54869              [fontSizeAttributeName]: fontSizeObject && fontSizeObject.slug ? fontSizeObject.slug : undefined,
54870              [customFontSizeAttributeName]: fontSizeObject && fontSizeObject.slug ? undefined : fontSizeValue
54871            });
54872          };
54873        }
54874        static getDerivedStateFromProps({
54875          attributes,
54876          fontSizes
54877        }, previousState) {
54878          const didAttributesChange = (customFontSizeAttributeName, fontSizeAttributeName) => {
54879            if (previousState[fontSizeAttributeName]) {
54880              // If new font size is name compare with the previous slug.
54881              if (attributes[fontSizeAttributeName]) {
54882                return attributes[fontSizeAttributeName] !== previousState[fontSizeAttributeName].slug;
54883              }
54884              // If font size is not named, update when the font size value changes.
54885              return previousState[fontSizeAttributeName].size !== attributes[customFontSizeAttributeName];
54886            }
54887            // In this case we need to build the font size object.
54888            return true;
54889          };
54890          if (!Object.values(fontSizeAttributeNames).some(didAttributesChange)) {
54891            return null;
54892          }
54893          const newState = Object.entries(fontSizeAttributeNames).filter(([key, value]) => didAttributesChange(value, key)).reduce((newStateAccumulator, [fontSizeAttributeName, customFontSizeAttributeName]) => {
54894            const fontSizeAttributeValue = attributes[fontSizeAttributeName];
54895            const fontSizeObject = utils_getFontSize(fontSizes, fontSizeAttributeValue, attributes[customFontSizeAttributeName]);
54896            newStateAccumulator[fontSizeAttributeName] = {
54897              ...fontSizeObject,
54898              class: getFontSizeClass(fontSizeAttributeValue)
54899            };
54900            return newStateAccumulator;
54901          }, {});
54902          return {
54903            ...previousState,
54904            ...newState
54905          };
54906        }
54907        render() {
54908          return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(WrappedComponent, {
54909            ...this.props,
54910            fontSizes: undefined,
54911            ...this.state,
54912            ...this.setters
54913          });
54914        }
54915      };
54916    }]), 'withFontSizes');
54917  });
54918  
54919  ;// ./node_modules/@wordpress/block-editor/build-module/components/font-sizes/index.js
54920  
54921  
54922  
54923  
54924  
54925  ;// ./node_modules/@wordpress/block-editor/build-module/autocompleters/block.js
54926  /**
54927   * WordPress dependencies
54928   */
54929  
54930  
54931  
54932  
54933  /**
54934   * Internal dependencies
54935   */
54936  
54937  
54938  
54939  
54940  
54941  
54942  
54943  const block_noop = () => {};
54944  const block_SHOWN_BLOCK_TYPES = 9;
54945  
54946  /**
54947   * Creates a blocks repeater for replacing the current block with a selected block type.
54948   *
54949   * @return {Object} A blocks completer.
54950   */
54951  function createBlockCompleter() {
54952    return {
54953      name: 'blocks',
54954      className: 'block-editor-autocompleters__block',
54955      triggerPrefix: '/',
54956      useItems(filterValue) {
54957        const {
54958          rootClientId,
54959          selectedBlockId,
54960          prioritizedBlocks
54961        } = (0,external_wp_data_namespaceObject.useSelect)(select => {
54962          const {
54963            getSelectedBlockClientId,
54964            getBlock,
54965            getBlockListSettings,
54966            getBlockRootClientId
54967          } = select(store);
54968          const {
54969            getActiveBlockVariation
54970          } = select(external_wp_blocks_namespaceObject.store);
54971          const selectedBlockClientId = getSelectedBlockClientId();
54972          const {
54973            name: blockName,
54974            attributes
54975          } = getBlock(selectedBlockClientId);
54976          const activeBlockVariation = getActiveBlockVariation(blockName, attributes);
54977          const _rootClientId = getBlockRootClientId(selectedBlockClientId);
54978          return {
54979            selectedBlockId: activeBlockVariation ? `$blockName}/$activeBlockVariation.name}` : blockName,
54980            rootClientId: _rootClientId,
54981            prioritizedBlocks: getBlockListSettings(_rootClientId)?.prioritizedInserterBlocks
54982          };
54983        }, []);
54984        const [items, categories, collections] = use_block_types_state(rootClientId, block_noop, true);
54985        const filteredItems = (0,external_wp_element_namespaceObject.useMemo)(() => {
54986          const initialFilteredItems = !!filterValue.trim() ? searchBlockItems(items, categories, collections, filterValue) : orderInserterBlockItems(orderBy(items, 'frecency', 'desc'), prioritizedBlocks);
54987          return initialFilteredItems.filter(item => item.id !== selectedBlockId).slice(0, block_SHOWN_BLOCK_TYPES);
54988        }, [filterValue, selectedBlockId, items, categories, collections, prioritizedBlocks]);
54989        const options = (0,external_wp_element_namespaceObject.useMemo)(() => filteredItems.map(blockItem => {
54990          const {
54991            title,
54992            icon,
54993            isDisabled
54994          } = blockItem;
54995          return {
54996            key: `block-$blockItem.id}`,
54997            value: blockItem,
54998            label: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
54999              children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_icon, {
55000                icon: icon,
55001                showColors: true
55002              }, "icon"), title]
55003            }),
55004            isDisabled
55005          };
55006        }), [filteredItems]);
55007        return [options];
55008      },
55009      allowContext(before, after) {
55010        return !(/\S/.test(before) || /\S/.test(after));
55011      },
55012      getOptionCompletion(inserterItem) {
55013        const {
55014          name,
55015          initialAttributes,
55016          innerBlocks,
55017          syncStatus,
55018          content
55019        } = inserterItem;
55020        return {
55021          action: 'replace',
55022          value: syncStatus === 'unsynced' ? (0,external_wp_blocks_namespaceObject.parse)(content, {
55023            __unstableSkipMigrationLogs: true
55024          }) : (0,external_wp_blocks_namespaceObject.createBlock)(name, initialAttributes, (0,external_wp_blocks_namespaceObject.createBlocksFromInnerBlocksTemplate)(innerBlocks))
55025        };
55026      }
55027    };
55028  }
55029  
55030  /**
55031   * Creates a blocks repeater for replacing the current block with a selected block type.
55032   *
55033   * @return {Object} A blocks completer.
55034   */
55035  /* harmony default export */ const autocompleters_block = (createBlockCompleter());
55036  
55037  ;// external ["wp","apiFetch"]
55038  const external_wp_apiFetch_namespaceObject = window["wp"]["apiFetch"];
55039  var external_wp_apiFetch_default = /*#__PURE__*/__webpack_require__.n(external_wp_apiFetch_namespaceObject);
55040  ;// ./node_modules/@wordpress/icons/build-module/library/post.js
55041  /**
55042   * WordPress dependencies
55043   */
55044  
55045  
55046  const post = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
55047    xmlns: "http://www.w3.org/2000/svg",
55048    viewBox: "0 0 24 24",
55049    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
55050      d: "m7.3 9.7 1.4 1.4c.2-.2.3-.3.4-.5 0 0 0-.1.1-.1.3-.5.4-1.1.3-1.6L12 7 9 4 7.2 6.5c-.6-.1-1.1 0-1.6.3 0 0-.1 0-.1.1-.3.1-.4.2-.6.4l1.4 1.4L4 11v1h1l2.3-2.3zM4 20h9v-1.5H4V20zm0-5.5V16h16v-1.5H4z"
55051    })
55052  });
55053  /* harmony default export */ const library_post = (post);
55054  
55055  ;// ./node_modules/@wordpress/block-editor/build-module/autocompleters/link.js
55056  /**
55057   * WordPress dependencies
55058   */
55059  // Disable Reason: Needs to be refactored.
55060  // eslint-disable-next-line no-restricted-imports
55061  
55062  
55063  
55064  
55065  
55066  const SHOWN_SUGGESTIONS = 10;
55067  
55068  /**
55069   * Creates a suggestion list for links to posts or pages.
55070   *
55071   * @return {Object} A links completer.
55072   */
55073  function createLinkCompleter() {
55074    return {
55075      name: 'links',
55076      className: 'block-editor-autocompleters__link',
55077      triggerPrefix: '[[',
55078      options: async letters => {
55079        let options = await external_wp_apiFetch_default()({
55080          path: (0,external_wp_url_namespaceObject.addQueryArgs)('/wp/v2/search', {
55081            per_page: SHOWN_SUGGESTIONS,
55082            search: letters,
55083            type: 'post',
55084            order_by: 'menu_order'
55085          })
55086        });
55087        options = options.filter(option => option.title !== '');
55088        return options;
55089      },
55090      getOptionKeywords(item) {
55091        const expansionWords = item.title.split(/\s+/);
55092        return [...expansionWords];
55093      },
55094      getOptionLabel(item) {
55095        return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
55096          children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(build_module_icon, {
55097            icon: item.subtype === 'page' ? library_page : library_post
55098          }, "icon"), (0,external_wp_htmlEntities_namespaceObject.decodeEntities)(item.title)]
55099        });
55100      },
55101      getOptionCompletion(item) {
55102        return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("a", {
55103          href: item.url,
55104          children: item.title
55105        });
55106      }
55107    };
55108  }
55109  
55110  /**
55111   * Creates a suggestion list for links to posts or pages..
55112   *
55113   * @return {Object} A link completer.
55114   */
55115  /* harmony default export */ const autocompleters_link = (createLinkCompleter());
55116  
55117  ;// ./node_modules/@wordpress/block-editor/build-module/components/autocomplete/index.js
55118  /**
55119   * WordPress dependencies
55120   */
55121  
55122  
55123  
55124  
55125  
55126  /**
55127   * Internal dependencies
55128   */
55129  
55130  
55131  
55132  
55133  /**
55134   * Shared reference to an empty array for cases where it is important to avoid
55135   * returning a new array reference on every invocation.
55136   *
55137   * @type {Array}
55138   */
55139  
55140  const autocomplete_EMPTY_ARRAY = [];
55141  function useCompleters({
55142    completers = autocomplete_EMPTY_ARRAY
55143  }) {
55144    const {
55145      name
55146    } = useBlockEditContext();
55147    return (0,external_wp_element_namespaceObject.useMemo)(() => {
55148      let filteredCompleters = [...completers, autocompleters_link];
55149      if (name === (0,external_wp_blocks_namespaceObject.getDefaultBlockName)() || (0,external_wp_blocks_namespaceObject.getBlockSupport)(name, '__experimentalSlashInserter', false)) {
55150        filteredCompleters = [...filteredCompleters, autocompleters_block];
55151      }
55152      if ((0,external_wp_hooks_namespaceObject.hasFilter)('editor.Autocomplete.completers')) {
55153        // Provide copies so filters may directly modify them.
55154        if (filteredCompleters === completers) {
55155          filteredCompleters = filteredCompleters.map(completer => ({
55156            ...completer
55157          }));
55158        }
55159        filteredCompleters = (0,external_wp_hooks_namespaceObject.applyFilters)('editor.Autocomplete.completers', filteredCompleters, name);
55160      }
55161      return filteredCompleters;
55162    }, [completers, name]);
55163  }
55164  function useBlockEditorAutocompleteProps(props) {
55165    return (0,external_wp_components_namespaceObject.__unstableUseAutocompleteProps)({
55166      ...props,
55167      completers: useCompleters(props)
55168    });
55169  }
55170  
55171  /**
55172   * Wrap the default Autocomplete component with one that supports a filter hook
55173   * for customizing its list of autocompleters.
55174   *
55175   * @type {import('react').FC}
55176   */
55177  function BlockEditorAutocomplete(props) {
55178    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Autocomplete, {
55179      ...props,
55180      completers: useCompleters(props)
55181    });
55182  }
55183  
55184  /**
55185   * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/autocomplete/README.md
55186   */
55187  /* harmony default export */ const autocomplete = (BlockEditorAutocomplete);
55188  
55189  ;// ./node_modules/@wordpress/icons/build-module/library/fullscreen.js
55190  /**
55191   * WordPress dependencies
55192   */
55193  
55194  
55195  const fullscreen = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
55196    xmlns: "http://www.w3.org/2000/svg",
55197    viewBox: "0 0 24 24",
55198    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
55199      d: "M6 4a2 2 0 0 0-2 2v3h1.5V6a.5.5 0 0 1 .5-.5h3V4H6Zm3 14.5H6a.5.5 0 0 1-.5-.5v-3H4v3a2 2 0 0 0 2 2h3v-1.5Zm6 1.5v-1.5h3a.5.5 0 0 0 .5-.5v-3H20v3a2 2 0 0 1-2 2h-3Zm3-16a2 2 0 0 1 2 2v3h-1.5V6a.5.5 0 0 0-.5-.5h-3V4h3Z"
55200    })
55201  });
55202  /* harmony default export */ const library_fullscreen = (fullscreen);
55203  
55204  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-full-height-alignment-control/index.js
55205  /**
55206   * WordPress dependencies
55207   */
55208  
55209  
55210  
55211  
55212  function BlockFullHeightAlignmentControl({
55213    isActive,
55214    label = (0,external_wp_i18n_namespaceObject.__)('Full height'),
55215    onToggle,
55216    isDisabled
55217  }) {
55218    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarButton, {
55219      isActive: isActive,
55220      icon: library_fullscreen,
55221      label: label,
55222      onClick: () => onToggle(!isActive),
55223      disabled: isDisabled
55224    });
55225  }
55226  /* harmony default export */ const block_full_height_alignment_control = (BlockFullHeightAlignmentControl);
55227  
55228  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-alignment-matrix-control/index.js
55229  /**
55230   * WordPress dependencies
55231   */
55232  
55233  
55234  
55235  
55236  const block_alignment_matrix_control_noop = () => {};
55237  
55238  /**
55239   * The alignment matrix control allows users to quickly adjust inner block alignment.
55240   *
55241   * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/block-alignment-matrix-control/README.md
55242   *
55243   * @example
55244   * ```jsx
55245   * function Example() {
55246   *   return (
55247   *     <BlockControls>
55248   *       <BlockAlignmentMatrixControl
55249   *         label={ __( 'Change content position' ) }
55250   *         value="center"
55251   *         onChange={ ( nextPosition ) =>
55252   *           setAttributes( { contentPosition: nextPosition } )
55253   *         }
55254   *       />
55255   *     </BlockControls>
55256   *   );
55257   * }
55258   * ```
55259   *
55260   * @param {Object}   props            Component props.
55261   * @param {string}   props.label      Label for the control. Defaults to 'Change matrix alignment'.
55262   * @param {Function} props.onChange   Function to execute upon change of matrix state.
55263   * @param {string}   props.value      Content alignment location. One of: 'center', 'center center',
55264   *                                    'center left', 'center right', 'top center', 'top left',
55265   *                                    'top right', 'bottom center', 'bottom left', 'bottom right'.
55266   * @param {boolean}  props.isDisabled Whether the control should be disabled.
55267   * @return {Element} The BlockAlignmentMatrixControl component.
55268   */
55269  function BlockAlignmentMatrixControl(props) {
55270    const {
55271      label = (0,external_wp_i18n_namespaceObject.__)('Change matrix alignment'),
55272      onChange = block_alignment_matrix_control_noop,
55273      value = 'center',
55274      isDisabled
55275    } = props;
55276    const icon = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.AlignmentMatrixControl.Icon, {
55277      value: value
55278    });
55279    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Dropdown, {
55280      popoverProps: {
55281        placement: 'bottom-start'
55282      },
55283      renderToggle: ({
55284        onToggle,
55285        isOpen
55286      }) => {
55287        const openOnArrowDown = event => {
55288          if (!isOpen && event.keyCode === external_wp_keycodes_namespaceObject.DOWN) {
55289            event.preventDefault();
55290            onToggle();
55291          }
55292        };
55293        return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarButton, {
55294          onClick: onToggle,
55295          "aria-haspopup": "true",
55296          "aria-expanded": isOpen,
55297          onKeyDown: openOnArrowDown,
55298          label: label,
55299          icon: icon,
55300          showTooltip: true,
55301          disabled: isDisabled
55302        });
55303      },
55304      renderContent: () => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.AlignmentMatrixControl, {
55305        hasFocusBorder: false,
55306        onChange: onChange,
55307        value: value
55308      })
55309    });
55310  }
55311  /* harmony default export */ const block_alignment_matrix_control = (BlockAlignmentMatrixControl);
55312  
55313  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-title/use-block-display-title.js
55314  /**
55315   * WordPress dependencies
55316   */
55317  
55318  
55319  
55320  /**
55321   * Internal dependencies
55322   */
55323  
55324  
55325  /**
55326   * Returns the block's configured title as a string, or empty if the title
55327   * cannot be determined.
55328   *
55329   * @example
55330   *
55331   * ```js
55332   * useBlockDisplayTitle( { clientId: 'afd1cb17-2c08-4e7a-91be-007ba7ddc3a1', maximumLength: 17 } );
55333   * ```
55334   *
55335   * @param {Object}           props
55336   * @param {string}           props.clientId      Client ID of block.
55337   * @param {number|undefined} props.maximumLength The maximum length that the block title string may be before truncated.
55338   * @param {string|undefined} props.context       The context to pass to `getBlockLabel`.
55339   * @return {?string} Block title.
55340   */
55341  function useBlockDisplayTitle({
55342    clientId,
55343    maximumLength,
55344    context
55345  }) {
55346    const blockTitle = (0,external_wp_data_namespaceObject.useSelect)(select => {
55347      if (!clientId) {
55348        return null;
55349      }
55350      const {
55351        getBlockName,
55352        getBlockAttributes
55353      } = select(store);
55354      const {
55355        getBlockType,
55356        getActiveBlockVariation
55357      } = select(external_wp_blocks_namespaceObject.store);
55358      const blockName = getBlockName(clientId);
55359      const blockType = getBlockType(blockName);
55360      if (!blockType) {
55361        return null;
55362      }
55363      const attributes = getBlockAttributes(clientId);
55364      const label = (0,external_wp_blocks_namespaceObject.__experimentalGetBlockLabel)(blockType, attributes, context);
55365      // If the label is defined we prioritize it over a possible block variation title match.
55366      if (label !== blockType.title) {
55367        return label;
55368      }
55369      const match = getActiveBlockVariation(blockName, attributes);
55370      // Label will fallback to the title if no label is defined for the current label context.
55371      return match?.title || blockType.title;
55372    }, [clientId, context]);
55373    if (!blockTitle) {
55374      return null;
55375    }
55376    if (maximumLength && maximumLength > 0 && blockTitle.length > maximumLength) {
55377      const omission = '...';
55378      return blockTitle.slice(0, maximumLength - omission.length) + omission;
55379    }
55380    return blockTitle;
55381  }
55382  
55383  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-title/index.js
55384  /**
55385   * Internal dependencies
55386   */
55387  
55388  
55389  
55390  /**
55391   * Renders the block's configured title as a string, or empty if the title
55392   * cannot be determined.
55393   *
55394   * @example
55395   *
55396   * ```jsx
55397   * <BlockTitle clientId="afd1cb17-2c08-4e7a-91be-007ba7ddc3a1" maximumLength={ 17 }/>
55398   * ```
55399   *
55400   * @param {Object}           props
55401   * @param {string}           props.clientId      Client ID of block.
55402   * @param {number|undefined} props.maximumLength The maximum length that the block title string may be before truncated.
55403   * @param {string|undefined} props.context       The context to pass to `getBlockLabel`.
55404   *
55405   * @return {JSX.Element} Block title.
55406   */
55407  function BlockTitle({
55408    clientId,
55409    maximumLength,
55410    context
55411  }) {
55412    return useBlockDisplayTitle({
55413      clientId,
55414      maximumLength,
55415      context
55416    });
55417  }
55418  
55419  ;// ./node_modules/@wordpress/block-editor/build-module/utils/get-editor-region.js
55420  /**
55421   * Gets the editor region for a given editor canvas element or
55422   * returns the passed element if no region is found
55423   *
55424   * @param { Object } editor The editor canvas element.
55425   * @return { Object } The editor region or given editor element
55426   */
55427  function getEditorRegion(editor) {
55428    var _Array$from$find, _editorCanvas$closest;
55429    if (!editor) {
55430      return null;
55431    }
55432  
55433    // If there are multiple editors, we need to find the iframe that contains our contentRef to make sure
55434    // we're focusing the region that contains this editor.
55435    const editorCanvas = (_Array$from$find = Array.from(document.querySelectorAll('iframe[name="editor-canvas"]').values()).find(iframe => {
55436      // Find the iframe that contains our contentRef
55437      const iframeDocument = iframe.contentDocument || iframe.contentWindow.document;
55438      return iframeDocument === editor.ownerDocument;
55439    })) !== null && _Array$from$find !== void 0 ? _Array$from$find : editor;
55440  
55441    // The region is provided by the editor, not the block-editor.
55442    // We should send focus to the region if one is available to reuse the
55443    // same interface for navigating landmarks. If no region is available,
55444    // use the canvas instead.
55445    return (_editorCanvas$closest = editorCanvas?.closest('[role="region"]')) !== null && _editorCanvas$closest !== void 0 ? _editorCanvas$closest : editorCanvas;
55446  }
55447  
55448  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-breadcrumb/index.js
55449  /**
55450   * WordPress dependencies
55451   */
55452  
55453  
55454  
55455  
55456  
55457  
55458  /**
55459   * Internal dependencies
55460   */
55461  
55462  
55463  
55464  
55465  
55466  
55467  /**
55468   * Block breadcrumb component, displaying the hierarchy of the current block selection as a breadcrumb.
55469   *
55470   * @param {Object} props               Component props.
55471   * @param {string} props.rootLabelText Translated label for the root element of the breadcrumb trail.
55472   * @return {Element}                   Block Breadcrumb.
55473   */
55474  
55475  function BlockBreadcrumb({
55476    rootLabelText
55477  }) {
55478    const {
55479      selectBlock,
55480      clearSelectedBlock
55481    } = (0,external_wp_data_namespaceObject.useDispatch)(store);
55482    const {
55483      clientId,
55484      parents,
55485      hasSelection
55486    } = (0,external_wp_data_namespaceObject.useSelect)(select => {
55487      const {
55488        getSelectionStart,
55489        getSelectedBlockClientId,
55490        getEnabledBlockParents
55491      } = unlock(select(store));
55492      const selectedBlockClientId = getSelectedBlockClientId();
55493      return {
55494        parents: getEnabledBlockParents(selectedBlockClientId),
55495        clientId: selectedBlockClientId,
55496        hasSelection: !!getSelectionStart().clientId
55497      };
55498    }, []);
55499    const rootLabel = rootLabelText || (0,external_wp_i18n_namespaceObject.__)('Document');
55500  
55501    // We don't care about this specific ref, but this is a way
55502    // to get a ref within the editor canvas so we can focus it later.
55503    const blockRef = (0,external_wp_element_namespaceObject.useRef)();
55504    useBlockElementRef(clientId, blockRef);
55505  
55506    /*
55507     * Disable reason: The `list` ARIA role is redundant but
55508     * Safari+VoiceOver won't announce the list otherwise.
55509     */
55510    /* eslint-disable jsx-a11y/no-redundant-roles */
55511    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("ul", {
55512      className: "block-editor-block-breadcrumb",
55513      role: "list",
55514      "aria-label": (0,external_wp_i18n_namespaceObject.__)('Block breadcrumb'),
55515      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("li", {
55516        className: !hasSelection ? 'block-editor-block-breadcrumb__current' : undefined,
55517        "aria-current": !hasSelection ? 'true' : undefined,
55518        children: [hasSelection && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
55519          size: "small",
55520          className: "block-editor-block-breadcrumb__button",
55521          onClick: () => {
55522            // Find the block editor wrapper for the selected block
55523            const blockEditor = blockRef.current?.closest('.editor-styles-wrapper');
55524            clearSelectedBlock();
55525            getEditorRegion(blockEditor)?.focus();
55526          },
55527          children: rootLabel
55528        }), !hasSelection && rootLabel, !!clientId && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(build_module_icon, {
55529          icon: chevron_right_small,
55530          className: "block-editor-block-breadcrumb__separator"
55531        })]
55532      }), parents.map(parentClientId => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("li", {
55533        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
55534          size: "small",
55535          className: "block-editor-block-breadcrumb__button",
55536          onClick: () => selectBlock(parentClientId),
55537          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockTitle, {
55538            clientId: parentClientId,
55539            maximumLength: 35
55540          })
55541        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(build_module_icon, {
55542          icon: chevron_right_small,
55543          className: "block-editor-block-breadcrumb__separator"
55544        })]
55545      }, parentClientId)), !!clientId && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("li", {
55546        className: "block-editor-block-breadcrumb__current",
55547        "aria-current": "true",
55548        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockTitle, {
55549          clientId: clientId,
55550          maximumLength: 35
55551        })
55552      })]
55553    })
55554    /* eslint-enable jsx-a11y/no-redundant-roles */;
55555  }
55556  /* harmony default export */ const block_breadcrumb = (BlockBreadcrumb);
55557  
55558  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-content-overlay/index.js
55559  /**
55560   * WordPress dependencies
55561   */
55562  
55563  
55564  /**
55565   * Internal dependencies
55566   */
55567  
55568  function useBlockOverlayActive(clientId) {
55569    return (0,external_wp_data_namespaceObject.useSelect)(select => {
55570      const {
55571        __unstableHasActiveBlockOverlayActive
55572      } = select(store);
55573      return __unstableHasActiveBlockOverlayActive(clientId);
55574    }, [clientId]);
55575  }
55576  
55577  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-tools/use-block-toolbar-popover-props.js
55578  /**
55579   * WordPress dependencies
55580   */
55581  
55582  
55583  
55584  
55585  
55586  /**
55587   * Internal dependencies
55588   */
55589  
55590  
55591  
55592  
55593  const COMMON_PROPS = {
55594    placement: 'top-start'
55595  };
55596  
55597  // By default the toolbar sets the `shift` prop. If the user scrolls the page
55598  // down the toolbar will stay on screen by adopting a sticky position at the
55599  // top of the viewport.
55600  const DEFAULT_PROPS = {
55601    ...COMMON_PROPS,
55602    flip: false,
55603    shift: true
55604  };
55605  
55606  // When there isn't enough height between the top of the block and the editor
55607  // canvas, the `shift` prop is set to `false`, as it will cause the block to be
55608  // obscured. The `flip` behavior is enabled, which positions the toolbar below
55609  // the block. This only happens if the block is smaller than the viewport, as
55610  // otherwise the toolbar will be off-screen.
55611  const RESTRICTED_HEIGHT_PROPS = {
55612    ...COMMON_PROPS,
55613    flip: true,
55614    shift: false
55615  };
55616  
55617  /**
55618   * Get the popover props for the block toolbar, determined by the space at the top of the canvas and the toolbar height.
55619   *
55620   * @param {Element} contentElement       The DOM element that represents the editor content or canvas.
55621   * @param {Element} selectedBlockElement The outer DOM element of the first selected block.
55622   * @param {Element} scrollContainer      The scrollable container for the contentElement.
55623   * @param {number}  toolbarHeight        The height of the toolbar in pixels.
55624   * @param {boolean} isSticky             Whether or not the selected block is sticky or fixed.
55625   *
55626   * @return {Object} The popover props used to determine the position of the toolbar.
55627   */
55628  function getProps(contentElement, selectedBlockElement, scrollContainer, toolbarHeight, isSticky) {
55629    if (!contentElement || !selectedBlockElement) {
55630      return DEFAULT_PROPS;
55631    }
55632  
55633    // Get how far the content area has been scrolled.
55634    const scrollTop = scrollContainer?.scrollTop || 0;
55635    const blockRect = getElementBounds(selectedBlockElement);
55636    const contentRect = contentElement.getBoundingClientRect();
55637  
55638    // Get the vertical position of top of the visible content area.
55639    const topOfContentElementInViewport = scrollTop + contentRect.top;
55640  
55641    // The document element's clientHeight represents the viewport height.
55642    const viewportHeight = contentElement.ownerDocument.documentElement.clientHeight;
55643  
55644    // The restricted height area is calculated as the sum of the
55645    // vertical position of the visible content area, plus the height
55646    // of the block toolbar.
55647    const restrictedTopArea = topOfContentElementInViewport + toolbarHeight;
55648    const hasSpaceForToolbarAbove = blockRect.top > restrictedTopArea;
55649    const isBlockTallerThanViewport = blockRect.height > viewportHeight - toolbarHeight;
55650  
55651    // Sticky blocks are treated as if they will never have enough space for the toolbar above.
55652    if (!isSticky && (hasSpaceForToolbarAbove || isBlockTallerThanViewport)) {
55653      return DEFAULT_PROPS;
55654    }
55655    return RESTRICTED_HEIGHT_PROPS;
55656  }
55657  
55658  /**
55659   * Determines the desired popover positioning behavior, returning a set of appropriate props.
55660   *
55661   * @param {Object}  elements
55662   * @param {Element} elements.contentElement The DOM element that represents the editor content or canvas.
55663   * @param {string}  elements.clientId       The clientId of the first selected block.
55664   *
55665   * @return {Object} The popover props used to determine the position of the toolbar.
55666   */
55667  function useBlockToolbarPopoverProps({
55668    contentElement,
55669    clientId
55670  }) {
55671    const selectedBlockElement = useBlockElement(clientId);
55672    const [toolbarHeight, setToolbarHeight] = (0,external_wp_element_namespaceObject.useState)(0);
55673    const {
55674      blockIndex,
55675      isSticky
55676    } = (0,external_wp_data_namespaceObject.useSelect)(select => {
55677      const {
55678        getBlockIndex,
55679        getBlockAttributes
55680      } = select(store);
55681      return {
55682        blockIndex: getBlockIndex(clientId),
55683        isSticky: hasStickyOrFixedPositionValue(getBlockAttributes(clientId))
55684      };
55685    }, [clientId]);
55686    const scrollContainer = (0,external_wp_element_namespaceObject.useMemo)(() => {
55687      if (!contentElement) {
55688        return;
55689      }
55690      return (0,external_wp_dom_namespaceObject.getScrollContainer)(contentElement);
55691    }, [contentElement]);
55692    const [props, setProps] = (0,external_wp_element_namespaceObject.useState)(() => getProps(contentElement, selectedBlockElement, scrollContainer, toolbarHeight, isSticky));
55693    const popoverRef = (0,external_wp_compose_namespaceObject.useRefEffect)(popoverNode => {
55694      setToolbarHeight(popoverNode.offsetHeight);
55695    }, []);
55696    const updateProps = (0,external_wp_element_namespaceObject.useCallback)(() => setProps(getProps(contentElement, selectedBlockElement, scrollContainer, toolbarHeight, isSticky)), [contentElement, selectedBlockElement, scrollContainer, toolbarHeight]);
55697  
55698    // Update props when the block is moved. This also ensures the props are
55699    // correct on initial mount, and when the selected block or content element
55700    // changes (since the callback ref will update).
55701    (0,external_wp_element_namespaceObject.useLayoutEffect)(updateProps, [blockIndex, updateProps]);
55702  
55703    // Update props when the viewport is resized or the block is resized.
55704    (0,external_wp_element_namespaceObject.useLayoutEffect)(() => {
55705      if (!contentElement || !selectedBlockElement) {
55706        return;
55707      }
55708  
55709      // Update the toolbar props on viewport resize.
55710      const contentView = contentElement?.ownerDocument?.defaultView;
55711      contentView?.addEventHandler?.('resize', updateProps);
55712  
55713      // Update the toolbar props on block resize.
55714      let resizeObserver;
55715      const blockView = selectedBlockElement?.ownerDocument?.defaultView;
55716      if (blockView.ResizeObserver) {
55717        resizeObserver = new blockView.ResizeObserver(updateProps);
55718        resizeObserver.observe(selectedBlockElement);
55719      }
55720      return () => {
55721        contentView?.removeEventHandler?.('resize', updateProps);
55722        if (resizeObserver) {
55723          resizeObserver.disconnect();
55724        }
55725      };
55726    }, [updateProps, contentElement, selectedBlockElement]);
55727    return {
55728      ...props,
55729      ref: popoverRef
55730    };
55731  }
55732  
55733  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-tools/use-selected-block-tool-props.js
55734  /**
55735   * WordPress dependencies
55736   */
55737  
55738  
55739  /**
55740   * Internal dependencies
55741   */
55742  
55743  
55744  /**
55745   * Returns props for the selected block tools and empty block inserter.
55746   *
55747   * @param {string} clientId Selected block client ID.
55748   */
55749  function useSelectedBlockToolProps(clientId) {
55750    const selectedBlockProps = (0,external_wp_data_namespaceObject.useSelect)(select => {
55751      const {
55752        getBlockRootClientId,
55753        getBlockParents,
55754        __experimentalGetBlockListSettingsForBlocks,
55755        isBlockInsertionPointVisible,
55756        getBlockInsertionPoint,
55757        getBlockOrder,
55758        hasMultiSelection,
55759        getLastMultiSelectedBlockClientId
55760      } = select(store);
55761      const blockParentsClientIds = getBlockParents(clientId);
55762  
55763      // Get Block List Settings for all ancestors of the current Block clientId.
55764      const parentBlockListSettings = __experimentalGetBlockListSettingsForBlocks(blockParentsClientIds);
55765  
55766      // Get the clientId of the topmost parent with the capture toolbars setting.
55767      const capturingClientId = blockParentsClientIds.find(parentClientId => parentBlockListSettings[parentClientId]?.__experimentalCaptureToolbars);
55768      let isInsertionPointVisible = false;
55769      if (isBlockInsertionPointVisible()) {
55770        const insertionPoint = getBlockInsertionPoint();
55771        const order = getBlockOrder(insertionPoint.rootClientId);
55772        isInsertionPointVisible = order[insertionPoint.index] === clientId;
55773      }
55774      return {
55775        capturingClientId,
55776        isInsertionPointVisible,
55777        lastClientId: hasMultiSelection() ? getLastMultiSelectedBlockClientId() : null,
55778        rootClientId: getBlockRootClientId(clientId)
55779      };
55780    }, [clientId]);
55781    return selectedBlockProps;
55782  }
55783  
55784  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-tools/empty-block-inserter.js
55785  /**
55786   * External dependencies
55787   */
55788  
55789  
55790  /**
55791   * Internal dependencies
55792   */
55793  
55794  
55795  
55796  
55797  
55798  function EmptyBlockInserter({
55799    clientId,
55800    __unstableContentRef
55801  }) {
55802    const {
55803      capturingClientId,
55804      isInsertionPointVisible,
55805      lastClientId,
55806      rootClientId
55807    } = useSelectedBlockToolProps(clientId);
55808    const popoverProps = useBlockToolbarPopoverProps({
55809      contentElement: __unstableContentRef?.current,
55810      clientId
55811    });
55812    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(cover, {
55813      clientId: capturingClientId || clientId,
55814      bottomClientId: lastClientId,
55815      className: dist_clsx('block-editor-block-list__block-side-inserter-popover', {
55816        'is-insertion-point-visible': isInsertionPointVisible
55817      }),
55818      __unstableContentRef: __unstableContentRef,
55819      ...popoverProps,
55820      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
55821        className: "block-editor-block-list__empty-block-inserter",
55822        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inserter, {
55823          position: "bottom right",
55824          rootClientId: rootClientId,
55825          clientId: clientId,
55826          __experimentalIsQuick: true
55827        })
55828      })
55829    });
55830  }
55831  
55832  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-draggable/use-scroll-when-dragging.js
55833  /**
55834   * WordPress dependencies
55835   */
55836  
55837  
55838  const SCROLL_INACTIVE_DISTANCE_PX = 50;
55839  const SCROLL_INTERVAL_MS = 25;
55840  const PIXELS_PER_SECOND_PER_PERCENTAGE = 1000;
55841  const VELOCITY_MULTIPLIER = PIXELS_PER_SECOND_PER_PERCENTAGE * (SCROLL_INTERVAL_MS / 1000);
55842  
55843  /**
55844   * React hook that scrolls the scroll container when a block is being dragged.
55845   *
55846   * @return {Function[]} `startScrolling`, `scrollOnDragOver`, `stopScrolling`
55847   *                      functions to be called in `onDragStart`, `onDragOver`
55848   *                      and `onDragEnd` events respectively.
55849   */
55850  function useScrollWhenDragging() {
55851    const dragStartYRef = (0,external_wp_element_namespaceObject.useRef)(null);
55852    const velocityYRef = (0,external_wp_element_namespaceObject.useRef)(null);
55853    const scrollParentYRef = (0,external_wp_element_namespaceObject.useRef)(null);
55854    const scrollEditorIntervalRef = (0,external_wp_element_namespaceObject.useRef)(null);
55855  
55856    // Clear interval when unmounting.
55857    (0,external_wp_element_namespaceObject.useEffect)(() => () => {
55858      if (scrollEditorIntervalRef.current) {
55859        clearInterval(scrollEditorIntervalRef.current);
55860        scrollEditorIntervalRef.current = null;
55861      }
55862    }, []);
55863    const startScrolling = (0,external_wp_element_namespaceObject.useCallback)(event => {
55864      dragStartYRef.current = event.clientY;
55865  
55866      // Find nearest parent(s) to scroll.
55867      scrollParentYRef.current = (0,external_wp_dom_namespaceObject.getScrollContainer)(event.target);
55868      scrollEditorIntervalRef.current = setInterval(() => {
55869        if (scrollParentYRef.current && velocityYRef.current) {
55870          const newTop = scrollParentYRef.current.scrollTop + velocityYRef.current;
55871  
55872          // Setting `behavior: 'smooth'` as a scroll property seems to hurt performance.
55873          // Better to use a small scroll interval.
55874          scrollParentYRef.current.scroll({
55875            top: newTop
55876          });
55877        }
55878      }, SCROLL_INTERVAL_MS);
55879    }, []);
55880    const scrollOnDragOver = (0,external_wp_element_namespaceObject.useCallback)(event => {
55881      if (!scrollParentYRef.current) {
55882        return;
55883      }
55884      const scrollParentHeight = scrollParentYRef.current.offsetHeight;
55885      const offsetDragStartPosition = dragStartYRef.current - scrollParentYRef.current.offsetTop;
55886      const offsetDragPosition = event.clientY - scrollParentYRef.current.offsetTop;
55887      if (event.clientY > offsetDragStartPosition) {
55888        // User is dragging downwards.
55889        const moveableDistance = Math.max(scrollParentHeight - offsetDragStartPosition - SCROLL_INACTIVE_DISTANCE_PX, 0);
55890        const dragDistance = Math.max(offsetDragPosition - offsetDragStartPosition - SCROLL_INACTIVE_DISTANCE_PX, 0);
55891        const distancePercentage = moveableDistance === 0 || dragDistance === 0 ? 0 : dragDistance / moveableDistance;
55892        velocityYRef.current = VELOCITY_MULTIPLIER * distancePercentage;
55893      } else if (event.clientY < offsetDragStartPosition) {
55894        // User is dragging upwards.
55895        const moveableDistance = Math.max(offsetDragStartPosition - SCROLL_INACTIVE_DISTANCE_PX, 0);
55896        const dragDistance = Math.max(offsetDragStartPosition - offsetDragPosition - SCROLL_INACTIVE_DISTANCE_PX, 0);
55897        const distancePercentage = moveableDistance === 0 || dragDistance === 0 ? 0 : dragDistance / moveableDistance;
55898        velocityYRef.current = -VELOCITY_MULTIPLIER * distancePercentage;
55899      } else {
55900        velocityYRef.current = 0;
55901      }
55902    }, []);
55903    const stopScrolling = () => {
55904      dragStartYRef.current = null;
55905      scrollParentYRef.current = null;
55906      if (scrollEditorIntervalRef.current) {
55907        clearInterval(scrollEditorIntervalRef.current);
55908        scrollEditorIntervalRef.current = null;
55909      }
55910    };
55911    return [startScrolling, scrollOnDragOver, stopScrolling];
55912  }
55913  
55914  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-draggable/index.js
55915  /**
55916   * WordPress dependencies
55917   */
55918  
55919  
55920  
55921  
55922  
55923  
55924  /**
55925   * Internal dependencies
55926   */
55927  
55928  
55929  
55930  
55931  
55932  
55933  const BlockDraggable = ({
55934    appendToOwnerDocument,
55935    children,
55936    clientIds,
55937    cloneClassname,
55938    elementId,
55939    onDragStart,
55940    onDragEnd,
55941    fadeWhenDisabled = false,
55942    dragComponent
55943  }) => {
55944    const {
55945      srcRootClientId,
55946      isDraggable,
55947      icon,
55948      visibleInserter,
55949      getBlockType
55950    } = (0,external_wp_data_namespaceObject.useSelect)(select => {
55951      const {
55952        canMoveBlocks,
55953        getBlockRootClientId,
55954        getBlockName,
55955        getBlockAttributes,
55956        isBlockInsertionPointVisible
55957      } = select(store);
55958      const {
55959        getBlockType: _getBlockType,
55960        getActiveBlockVariation
55961      } = select(external_wp_blocks_namespaceObject.store);
55962      const rootClientId = getBlockRootClientId(clientIds[0]);
55963      const blockName = getBlockName(clientIds[0]);
55964      const variation = getActiveBlockVariation(blockName, getBlockAttributes(clientIds[0]));
55965      return {
55966        srcRootClientId: rootClientId,
55967        isDraggable: canMoveBlocks(clientIds),
55968        icon: variation?.icon || _getBlockType(blockName)?.icon,
55969        visibleInserter: isBlockInsertionPointVisible(),
55970        getBlockType: _getBlockType
55971      };
55972    }, [clientIds]);
55973    const isDraggingRef = (0,external_wp_element_namespaceObject.useRef)(false);
55974    const [startScrolling, scrollOnDragOver, stopScrolling] = useScrollWhenDragging();
55975    const {
55976      getAllowedBlocks,
55977      getBlockNamesByClientId,
55978      getBlockRootClientId
55979    } = (0,external_wp_data_namespaceObject.useSelect)(store);
55980    const {
55981      startDraggingBlocks,
55982      stopDraggingBlocks
55983    } = (0,external_wp_data_namespaceObject.useDispatch)(store);
55984  
55985    // Stop dragging blocks if the block draggable is unmounted.
55986    (0,external_wp_element_namespaceObject.useEffect)(() => {
55987      return () => {
55988        if (isDraggingRef.current) {
55989          stopDraggingBlocks();
55990        }
55991      };
55992    }, []);
55993  
55994    // Find the root of the editor iframe.
55995    const blockEl = useBlockElement(clientIds[0]);
55996    const editorRoot = blockEl?.closest('body');
55997  
55998    /*
55999     * Add a dragover event listener to the editor root to track the blocks being dragged over.
56000     * The listener has to be inside the editor iframe otherwise the target isn't accessible.
56001     */
56002    (0,external_wp_element_namespaceObject.useEffect)(() => {
56003      if (!editorRoot || !fadeWhenDisabled) {
56004        return;
56005      }
56006      const onDragOver = event => {
56007        if (!event.target.closest('[data-block]')) {
56008          return;
56009        }
56010        const draggedBlockNames = getBlockNamesByClientId(clientIds);
56011        const targetClientId = event.target.closest('[data-block]').getAttribute('data-block');
56012        const allowedBlocks = getAllowedBlocks(targetClientId);
56013        const targetBlockName = getBlockNamesByClientId([targetClientId])[0];
56014  
56015        /*
56016         * Check if the target is valid to drop in.
56017         * If the target's allowedBlocks is an empty array,
56018         * it isn't a container block, in which case we check
56019         * its parent's validity instead.
56020         */
56021        let dropTargetValid;
56022        if (allowedBlocks?.length === 0) {
56023          const targetRootClientId = getBlockRootClientId(targetClientId);
56024          const targetRootBlockName = getBlockNamesByClientId([targetRootClientId])[0];
56025          const rootAllowedBlocks = getAllowedBlocks(targetRootClientId);
56026          dropTargetValid = isDropTargetValid(getBlockType, rootAllowedBlocks, draggedBlockNames, targetRootBlockName);
56027        } else {
56028          dropTargetValid = isDropTargetValid(getBlockType, allowedBlocks, draggedBlockNames, targetBlockName);
56029        }
56030  
56031        /*
56032         * Update the body class to reflect if drop target is valid.
56033         * This has to be done on the document body because the draggable
56034         * chip is rendered outside of the editor iframe.
56035         */
56036        if (!dropTargetValid && !visibleInserter) {
56037          window?.document?.body?.classList?.add('block-draggable-invalid-drag-token');
56038        } else {
56039          window?.document?.body?.classList?.remove('block-draggable-invalid-drag-token');
56040        }
56041      };
56042      const throttledOnDragOver = (0,external_wp_compose_namespaceObject.throttle)(onDragOver, 200);
56043      editorRoot.addEventListener('dragover', throttledOnDragOver);
56044      return () => {
56045        editorRoot.removeEventListener('dragover', throttledOnDragOver);
56046      };
56047    }, [clientIds, editorRoot, fadeWhenDisabled, getAllowedBlocks, getBlockNamesByClientId, getBlockRootClientId, getBlockType, visibleInserter]);
56048    if (!isDraggable) {
56049      return children({
56050        draggable: false
56051      });
56052    }
56053    const transferData = {
56054      type: 'block',
56055      srcClientIds: clientIds,
56056      srcRootClientId
56057    };
56058    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Draggable, {
56059      appendToOwnerDocument: appendToOwnerDocument,
56060      cloneClassname: cloneClassname,
56061      __experimentalTransferDataType: "wp-blocks",
56062      transferData: transferData,
56063      onDragStart: event => {
56064        // Defer hiding the dragged source element to the next
56065        // frame to enable dragging.
56066        window.requestAnimationFrame(() => {
56067          startDraggingBlocks(clientIds);
56068          isDraggingRef.current = true;
56069          startScrolling(event);
56070          if (onDragStart) {
56071            onDragStart();
56072          }
56073        });
56074      },
56075      onDragOver: scrollOnDragOver,
56076      onDragEnd: () => {
56077        stopDraggingBlocks();
56078        isDraggingRef.current = false;
56079        stopScrolling();
56080        if (onDragEnd) {
56081          onDragEnd();
56082        }
56083      },
56084      __experimentalDragComponent:
56085      // Check against `undefined` so that `null` can be used to disable
56086      // the default drag component.
56087      dragComponent !== undefined ? dragComponent : /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockDraggableChip, {
56088        count: clientIds.length,
56089        icon: icon,
56090        fadeWhenDisabled: true
56091      }),
56092      elementId: elementId,
56093      children: ({
56094        onDraggableStart,
56095        onDraggableEnd
56096      }) => {
56097        return children({
56098          draggable: true,
56099          onDragStart: onDraggableStart,
56100          onDragEnd: onDraggableEnd
56101        });
56102      }
56103    });
56104  };
56105  /* harmony default export */ const block_draggable = (BlockDraggable);
56106  
56107  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-mover/mover-description.js
56108  /**
56109   * WordPress dependencies
56110   */
56111  
56112  const getMovementDirection = (moveDirection, orientation) => {
56113    if (moveDirection === 'up') {
56114      if (orientation === 'horizontal') {
56115        return (0,external_wp_i18n_namespaceObject.isRTL)() ? 'right' : 'left';
56116      }
56117      return 'up';
56118    } else if (moveDirection === 'down') {
56119      if (orientation === 'horizontal') {
56120        return (0,external_wp_i18n_namespaceObject.isRTL)() ? 'left' : 'right';
56121      }
56122      return 'down';
56123    }
56124    return null;
56125  };
56126  
56127  /**
56128   * Return a label for the block movement controls depending on block position.
56129   *
56130   * @param {number}  selectedCount Number of blocks selected.
56131   * @param {string}  type          Block type - in the case of a single block, should
56132   *                                define its 'type'. I.e. 'Text', 'Heading', 'Image' etc.
56133   * @param {number}  firstIndex    The index (position - 1) of the first block selected.
56134   * @param {boolean} isFirst       This is the first block.
56135   * @param {boolean} isLast        This is the last block.
56136   * @param {number}  dir           Direction of movement (> 0 is considered to be going
56137   *                                down, < 0 is up).
56138   * @param {string}  orientation   The orientation of the block movers, vertical or
56139   *                                horizontal.
56140   *
56141   * @return {string | undefined} Label for the block movement controls.
56142   */
56143  function getBlockMoverDescription(selectedCount, type, firstIndex, isFirst, isLast, dir, orientation) {
56144    const position = firstIndex + 1;
56145    if (selectedCount > 1) {
56146      return getMultiBlockMoverDescription(selectedCount, firstIndex, isFirst, isLast, dir, orientation);
56147    }
56148    if (isFirst && isLast) {
56149      return (0,external_wp_i18n_namespaceObject.sprintf)(
56150      // translators: %s: Type of block (i.e. Text, Image etc)
56151      (0,external_wp_i18n_namespaceObject.__)('Block %s is the only block, and cannot be moved'), type);
56152    }
56153    if (dir > 0 && !isLast) {
56154      // Moving down.
56155      const movementDirection = getMovementDirection('down', orientation);
56156      if (movementDirection === 'down') {
56157        return (0,external_wp_i18n_namespaceObject.sprintf)(
56158        // translators: 1: Type of block (i.e. Text, Image etc), 2: Position of selected block, 3: New position
56159        (0,external_wp_i18n_namespaceObject.__)('Move %1$s block from position %2$d down to position %3$d'), type, position, position + 1);
56160      }
56161      if (movementDirection === 'left') {
56162        return (0,external_wp_i18n_namespaceObject.sprintf)(
56163        // translators: 1: Type of block (i.e. Text, Image etc), 2: Position of selected block, 3: New position
56164        (0,external_wp_i18n_namespaceObject.__)('Move %1$s block from position %2$d left to position %3$d'), type, position, position + 1);
56165      }
56166      if (movementDirection === 'right') {
56167        return (0,external_wp_i18n_namespaceObject.sprintf)(
56168        // translators: 1: Type of block (i.e. Text, Image etc), 2: Position of selected block, 3: New position
56169        (0,external_wp_i18n_namespaceObject.__)('Move %1$s block from position %2$d right to position %3$d'), type, position, position + 1);
56170      }
56171    }
56172    if (dir > 0 && isLast) {
56173      // Moving down, and is the last item.
56174      const movementDirection = getMovementDirection('down', orientation);
56175      if (movementDirection === 'down') {
56176        return (0,external_wp_i18n_namespaceObject.sprintf)(
56177        // translators: 1: Type of block (i.e. Text, Image etc)
56178        (0,external_wp_i18n_namespaceObject.__)('Block %1$s is at the end of the content and can’t be moved down'), type);
56179      }
56180      if (movementDirection === 'left') {
56181        return (0,external_wp_i18n_namespaceObject.sprintf)(
56182        // translators: 1: Type of block (i.e. Text, Image etc)
56183        (0,external_wp_i18n_namespaceObject.__)('Block %1$s is at the end of the content and can’t be moved left'), type);
56184      }
56185      if (movementDirection === 'right') {
56186        return (0,external_wp_i18n_namespaceObject.sprintf)(
56187        // translators: 1: Type of block (i.e. Text, Image etc)
56188        (0,external_wp_i18n_namespaceObject.__)('Block %1$s is at the end of the content and can’t be moved right'), type);
56189      }
56190    }
56191    if (dir < 0 && !isFirst) {
56192      // Moving up.
56193      const movementDirection = getMovementDirection('up', orientation);
56194      if (movementDirection === 'up') {
56195        return (0,external_wp_i18n_namespaceObject.sprintf)(
56196        // translators: 1: Type of block (i.e. Text, Image etc), 2: Position of selected block, 3: New position
56197        (0,external_wp_i18n_namespaceObject.__)('Move %1$s block from position %2$d up to position %3$d'), type, position, position - 1);
56198      }
56199      if (movementDirection === 'left') {
56200        return (0,external_wp_i18n_namespaceObject.sprintf)(
56201        // translators: 1: Type of block (i.e. Text, Image etc), 2: Position of selected block, 3: New position
56202        (0,external_wp_i18n_namespaceObject.__)('Move %1$s block from position %2$d left to position %3$d'), type, position, position - 1);
56203      }
56204      if (movementDirection === 'right') {
56205        return (0,external_wp_i18n_namespaceObject.sprintf)(
56206        // translators: 1: Type of block (i.e. Text, Image etc), 2: Position of selected block, 3: New position
56207        (0,external_wp_i18n_namespaceObject.__)('Move %1$s block from position %2$d right to position %3$d'), type, position, position - 1);
56208      }
56209    }
56210    if (dir < 0 && isFirst) {
56211      // Moving up, and is the first item.
56212      const movementDirection = getMovementDirection('up', orientation);
56213      if (movementDirection === 'up') {
56214        return (0,external_wp_i18n_namespaceObject.sprintf)(
56215        // translators: 1: Type of block (i.e. Text, Image etc)
56216        (0,external_wp_i18n_namespaceObject.__)('Block %1$s is at the beginning of the content and can’t be moved up'), type);
56217      }
56218      if (movementDirection === 'left') {
56219        return (0,external_wp_i18n_namespaceObject.sprintf)(
56220        // translators: 1: Type of block (i.e. Text, Image etc)
56221        (0,external_wp_i18n_namespaceObject.__)('Block %1$s is at the beginning of the content and can’t be moved left'), type);
56222      }
56223      if (movementDirection === 'right') {
56224        return (0,external_wp_i18n_namespaceObject.sprintf)(
56225        // translators: 1: Type of block (i.e. Text, Image etc)
56226        (0,external_wp_i18n_namespaceObject.__)('Block %1$s is at the beginning of the content and can’t be moved right'), type);
56227      }
56228    }
56229  }
56230  
56231  /**
56232   * Return a label for the block movement controls depending on block position.
56233   *
56234   * @param {number}  selectedCount Number of blocks selected.
56235   * @param {number}  firstIndex    The index (position - 1) of the first block selected.
56236   * @param {boolean} isFirst       This is the first block.
56237   * @param {boolean} isLast        This is the last block.
56238   * @param {number}  dir           Direction of movement (> 0 is considered to be going
56239   *                                down, < 0 is up).
56240   * @param {string}  orientation   The orientation of the block movers, vertical or
56241   *                                horizontal.
56242   *
56243   * @return {string | undefined} Label for the block movement controls.
56244   */
56245  function getMultiBlockMoverDescription(selectedCount, firstIndex, isFirst, isLast, dir, orientation) {
56246    const position = firstIndex + 1;
56247    if (isFirst && isLast) {
56248      // All blocks are selected
56249      return (0,external_wp_i18n_namespaceObject.__)('All blocks are selected, and cannot be moved');
56250    }
56251    if (dir > 0 && !isLast) {
56252      // moving down
56253      const movementDirection = getMovementDirection('down', orientation);
56254      if (movementDirection === 'down') {
56255        return (0,external_wp_i18n_namespaceObject.sprintf)(
56256        // translators: 1: Number of selected blocks, 2: Position of selected blocks
56257        (0,external_wp_i18n_namespaceObject.__)('Move %1$d blocks from position %2$d down by one place'), selectedCount, position);
56258      }
56259      if (movementDirection === 'left') {
56260        return (0,external_wp_i18n_namespaceObject.sprintf)(
56261        // translators: 1: Number of selected blocks, 2: Position of selected blocks
56262        (0,external_wp_i18n_namespaceObject.__)('Move %1$d blocks from position %2$d left by one place'), selectedCount, position);
56263      }
56264      if (movementDirection === 'right') {
56265        return (0,external_wp_i18n_namespaceObject.sprintf)(
56266        // translators: 1: Number of selected blocks, 2: Position of selected blocks
56267        (0,external_wp_i18n_namespaceObject.__)('Move %1$d blocks from position %2$d right by one place'), selectedCount, position);
56268      }
56269    }
56270    if (dir > 0 && isLast) {
56271      // moving down, and the selected blocks are the last item
56272      const movementDirection = getMovementDirection('down', orientation);
56273      if (movementDirection === 'down') {
56274        return (0,external_wp_i18n_namespaceObject.__)('Blocks cannot be moved down as they are already at the bottom');
56275      }
56276      if (movementDirection === 'left') {
56277        return (0,external_wp_i18n_namespaceObject.__)('Blocks cannot be moved left as they are already are at the leftmost position');
56278      }
56279      if (movementDirection === 'right') {
56280        return (0,external_wp_i18n_namespaceObject.__)('Blocks cannot be moved right as they are already are at the rightmost position');
56281      }
56282    }
56283    if (dir < 0 && !isFirst) {
56284      // moving up
56285      const movementDirection = getMovementDirection('up', orientation);
56286      if (movementDirection === 'up') {
56287        return (0,external_wp_i18n_namespaceObject.sprintf)(
56288        // translators: 1: Number of selected blocks, 2: Position of selected blocks
56289        (0,external_wp_i18n_namespaceObject.__)('Move %1$d blocks from position %2$d up by one place'), selectedCount, position);
56290      }
56291      if (movementDirection === 'left') {
56292        return (0,external_wp_i18n_namespaceObject.sprintf)(
56293        // translators: 1: Number of selected blocks, 2: Position of selected blocks
56294        (0,external_wp_i18n_namespaceObject.__)('Move %1$d blocks from position %2$d left by one place'), selectedCount, position);
56295      }
56296      if (movementDirection === 'right') {
56297        return (0,external_wp_i18n_namespaceObject.sprintf)(
56298        // translators: 1: Number of selected blocks, 2: Position of selected blocks
56299        (0,external_wp_i18n_namespaceObject.__)('Move %1$d blocks from position %2$d right by one place'), selectedCount, position);
56300      }
56301    }
56302    if (dir < 0 && isFirst) {
56303      // moving up, and the selected blocks are the first item
56304      const movementDirection = getMovementDirection('up', orientation);
56305      if (movementDirection === 'up') {
56306        return (0,external_wp_i18n_namespaceObject.__)('Blocks cannot be moved up as they are already at the top');
56307      }
56308      if (movementDirection === 'left') {
56309        return (0,external_wp_i18n_namespaceObject.__)('Blocks cannot be moved left as they are already are at the leftmost position');
56310      }
56311      if (movementDirection === 'right') {
56312        return (0,external_wp_i18n_namespaceObject.__)('Blocks cannot be moved right as they are already are at the rightmost position');
56313      }
56314    }
56315  }
56316  
56317  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-mover/button.js
56318  /**
56319   * External dependencies
56320   */
56321  
56322  
56323  /**
56324   * WordPress dependencies
56325   */
56326  
56327  
56328  
56329  
56330  
56331  
56332  
56333  /**
56334   * Internal dependencies
56335   */
56336  
56337  
56338  
56339  
56340  const getArrowIcon = (direction, orientation) => {
56341    if (direction === 'up') {
56342      if (orientation === 'horizontal') {
56343        return (0,external_wp_i18n_namespaceObject.isRTL)() ? chevron_right : chevron_left;
56344      }
56345      return chevron_up;
56346    } else if (direction === 'down') {
56347      if (orientation === 'horizontal') {
56348        return (0,external_wp_i18n_namespaceObject.isRTL)() ? chevron_left : chevron_right;
56349      }
56350      return chevron_down;
56351    }
56352    return null;
56353  };
56354  const getMovementDirectionLabel = (moveDirection, orientation) => {
56355    if (moveDirection === 'up') {
56356      if (orientation === 'horizontal') {
56357        return (0,external_wp_i18n_namespaceObject.isRTL)() ? (0,external_wp_i18n_namespaceObject.__)('Move right') : (0,external_wp_i18n_namespaceObject.__)('Move left');
56358      }
56359      return (0,external_wp_i18n_namespaceObject.__)('Move up');
56360    } else if (moveDirection === 'down') {
56361      if (orientation === 'horizontal') {
56362        return (0,external_wp_i18n_namespaceObject.isRTL)() ? (0,external_wp_i18n_namespaceObject.__)('Move left') : (0,external_wp_i18n_namespaceObject.__)('Move right');
56363      }
56364      return (0,external_wp_i18n_namespaceObject.__)('Move down');
56365    }
56366    return null;
56367  };
56368  const BlockMoverButton = (0,external_wp_element_namespaceObject.forwardRef)(({
56369    clientIds,
56370    direction,
56371    orientation: moverOrientation,
56372    ...props
56373  }, ref) => {
56374    const instanceId = (0,external_wp_compose_namespaceObject.useInstanceId)(BlockMoverButton);
56375    const normalizedClientIds = Array.isArray(clientIds) ? clientIds : [clientIds];
56376    const blocksCount = normalizedClientIds.length;
56377    const {
56378      disabled
56379    } = props;
56380    const {
56381      blockType,
56382      isDisabled,
56383      rootClientId,
56384      isFirst,
56385      isLast,
56386      firstIndex,
56387      orientation = 'vertical'
56388    } = (0,external_wp_data_namespaceObject.useSelect)(select => {
56389      const {
56390        getBlockIndex,
56391        getBlockRootClientId,
56392        getBlockOrder,
56393        getBlock,
56394        getBlockListSettings
56395      } = select(store);
56396      const firstClientId = normalizedClientIds[0];
56397      const blockRootClientId = getBlockRootClientId(firstClientId);
56398      const firstBlockIndex = getBlockIndex(firstClientId);
56399      const lastBlockIndex = getBlockIndex(normalizedClientIds[normalizedClientIds.length - 1]);
56400      const blockOrder = getBlockOrder(blockRootClientId);
56401      const block = getBlock(firstClientId);
56402      const isFirstBlock = firstBlockIndex === 0;
56403      const isLastBlock = lastBlockIndex === blockOrder.length - 1;
56404      const {
56405        orientation: blockListOrientation
56406      } = getBlockListSettings(blockRootClientId) || {};
56407      return {
56408        blockType: block ? (0,external_wp_blocks_namespaceObject.getBlockType)(block.name) : null,
56409        isDisabled: disabled || (direction === 'up' ? isFirstBlock : isLastBlock),
56410        rootClientId: blockRootClientId,
56411        firstIndex: firstBlockIndex,
56412        isFirst: isFirstBlock,
56413        isLast: isLastBlock,
56414        orientation: moverOrientation || blockListOrientation
56415      };
56416    }, [clientIds, direction]);
56417    const {
56418      moveBlocksDown,
56419      moveBlocksUp
56420    } = (0,external_wp_data_namespaceObject.useDispatch)(store);
56421    const moverFunction = direction === 'up' ? moveBlocksUp : moveBlocksDown;
56422    const onClick = event => {
56423      moverFunction(clientIds, rootClientId);
56424      if (props.onClick) {
56425        props.onClick(event);
56426      }
56427    };
56428    const descriptionId = `block-editor-block-mover-button__description-$instanceId}`;
56429    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
56430      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
56431        __next40pxDefaultSize: true,
56432        ref: ref,
56433        className: dist_clsx('block-editor-block-mover-button', `is-$direction}-button`),
56434        icon: getArrowIcon(direction, orientation),
56435        label: getMovementDirectionLabel(direction, orientation),
56436        "aria-describedby": descriptionId,
56437        ...props,
56438        onClick: isDisabled ? null : onClick,
56439        disabled: isDisabled,
56440        accessibleWhenDisabled: true
56441      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.VisuallyHidden, {
56442        id: descriptionId,
56443        children: getBlockMoverDescription(blocksCount, blockType && blockType.title, firstIndex, isFirst, isLast, direction === 'up' ? -1 : 1, orientation)
56444      })]
56445    });
56446  });
56447  const BlockMoverUpButton = (0,external_wp_element_namespaceObject.forwardRef)((props, ref) => {
56448    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockMoverButton, {
56449      direction: "up",
56450      ref: ref,
56451      ...props
56452    });
56453  });
56454  const BlockMoverDownButton = (0,external_wp_element_namespaceObject.forwardRef)((props, ref) => {
56455    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockMoverButton, {
56456      direction: "down",
56457      ref: ref,
56458      ...props
56459    });
56460  });
56461  
56462  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-mover/index.js
56463  /**
56464   * External dependencies
56465   */
56466  
56467  
56468  /**
56469   * WordPress dependencies
56470   */
56471  
56472  
56473  
56474  
56475  
56476  
56477  /**
56478   * Internal dependencies
56479   */
56480  
56481  
56482  
56483  
56484  function BlockMover({
56485    clientIds,
56486    hideDragHandle,
56487    isBlockMoverUpButtonDisabled,
56488    isBlockMoverDownButtonDisabled
56489  }) {
56490    const {
56491      canMove,
56492      rootClientId,
56493      isFirst,
56494      isLast,
56495      orientation,
56496      isManualGrid
56497    } = (0,external_wp_data_namespaceObject.useSelect)(select => {
56498      var _getBlockAttributes;
56499      const {
56500        getBlockIndex,
56501        getBlockListSettings,
56502        canMoveBlocks,
56503        getBlockOrder,
56504        getBlockRootClientId,
56505        getBlockAttributes
56506      } = select(store);
56507      const normalizedClientIds = Array.isArray(clientIds) ? clientIds : [clientIds];
56508      const firstClientId = normalizedClientIds[0];
56509      const _rootClientId = getBlockRootClientId(firstClientId);
56510      const firstIndex = getBlockIndex(firstClientId);
56511      const lastIndex = getBlockIndex(normalizedClientIds[normalizedClientIds.length - 1]);
56512      const blockOrder = getBlockOrder(_rootClientId);
56513      const {
56514        layout = {}
56515      } = (_getBlockAttributes = getBlockAttributes(_rootClientId)) !== null && _getBlockAttributes !== void 0 ? _getBlockAttributes : {};
56516      return {
56517        canMove: canMoveBlocks(clientIds),
56518        rootClientId: _rootClientId,
56519        isFirst: firstIndex === 0,
56520        isLast: lastIndex === blockOrder.length - 1,
56521        orientation: getBlockListSettings(_rootClientId)?.orientation,
56522        isManualGrid: layout.type === 'grid' && layout.isManualPlacement && window.__experimentalEnableGridInteractivity
56523      };
56524    }, [clientIds]);
56525    if (!canMove || isFirst && isLast && !rootClientId || hideDragHandle && isManualGrid) {
56526      return null;
56527    }
56528    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.ToolbarGroup, {
56529      className: dist_clsx('block-editor-block-mover', {
56530        'is-horizontal': orientation === 'horizontal'
56531      }),
56532      children: [!hideDragHandle && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_draggable, {
56533        clientIds: clientIds,
56534        fadeWhenDisabled: true,
56535        children: draggableProps => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
56536          __next40pxDefaultSize: true,
56537          icon: drag_handle,
56538          className: "block-editor-block-mover__drag-handle",
56539          label: (0,external_wp_i18n_namespaceObject.__)('Drag')
56540          // Should not be able to tab to drag handle as this
56541          // button can only be used with a pointer device.
56542          ,
56543          tabIndex: "-1",
56544          ...draggableProps
56545        })
56546      }), !isManualGrid && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
56547        className: "block-editor-block-mover__move-button-container",
56548        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarItem, {
56549          children: itemProps => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockMoverUpButton, {
56550            disabled: isBlockMoverUpButtonDisabled,
56551            clientIds: clientIds,
56552            ...itemProps
56553          })
56554        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarItem, {
56555          children: itemProps => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockMoverDownButton, {
56556            disabled: isBlockMoverDownButtonDisabled,
56557            clientIds: clientIds,
56558            ...itemProps
56559          })
56560        })]
56561      })]
56562    });
56563  }
56564  
56565  /**
56566   * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/block-mover/README.md
56567   */
56568  /* harmony default export */ const block_mover = (BlockMover);
56569  
56570  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-toolbar/utils.js
56571  /**
56572   * WordPress dependencies
56573   */
56574  
56575  
56576  
56577  /**
56578   * Internal dependencies
56579   */
56580  
56581  const {
56582    clearTimeout: utils_clearTimeout,
56583    setTimeout: utils_setTimeout
56584  } = window;
56585  const DEBOUNCE_TIMEOUT = 200;
56586  
56587  /**
56588   * Hook that creates debounced callbacks when the node is hovered or focused.
56589   *
56590   * @param {Object}  props                       Component props.
56591   * @param {Object}  props.ref                   Element reference.
56592   * @param {boolean} props.isFocused             Whether the component has current focus.
56593   * @param {number}  props.highlightParent       Whether to highlight the parent block. It defaults in highlighting the selected block.
56594   * @param {number}  [props.debounceTimeout=250] Debounce timeout in milliseconds.
56595   */
56596  function useDebouncedShowGestures({
56597    ref,
56598    isFocused,
56599    highlightParent,
56600    debounceTimeout = DEBOUNCE_TIMEOUT
56601  }) {
56602    const {
56603      getSelectedBlockClientId,
56604      getBlockRootClientId
56605    } = (0,external_wp_data_namespaceObject.useSelect)(store);
56606    const {
56607      toggleBlockHighlight
56608    } = (0,external_wp_data_namespaceObject.useDispatch)(store);
56609    const timeoutRef = (0,external_wp_element_namespaceObject.useRef)();
56610    const isDistractionFree = (0,external_wp_data_namespaceObject.useSelect)(select => select(store).getSettings().isDistractionFree, []);
56611    const handleOnChange = nextIsFocused => {
56612      if (nextIsFocused && isDistractionFree) {
56613        return;
56614      }
56615      const selectedBlockClientId = getSelectedBlockClientId();
56616      const clientId = highlightParent ? getBlockRootClientId(selectedBlockClientId) : selectedBlockClientId;
56617      toggleBlockHighlight(clientId, nextIsFocused);
56618    };
56619    const getIsHovered = () => {
56620      return ref?.current && ref.current.matches(':hover');
56621    };
56622    const shouldHideGestures = () => {
56623      const isHovered = getIsHovered();
56624      return !isFocused && !isHovered;
56625    };
56626    const clearTimeoutRef = () => {
56627      const timeout = timeoutRef.current;
56628      if (timeout && utils_clearTimeout) {
56629        utils_clearTimeout(timeout);
56630      }
56631    };
56632    const debouncedShowGestures = event => {
56633      if (event) {
56634        event.stopPropagation();
56635      }
56636      clearTimeoutRef();
56637      handleOnChange(true);
56638    };
56639    const debouncedHideGestures = event => {
56640      if (event) {
56641        event.stopPropagation();
56642      }
56643      clearTimeoutRef();
56644      timeoutRef.current = utils_setTimeout(() => {
56645        if (shouldHideGestures()) {
56646          handleOnChange(false);
56647        }
56648      }, debounceTimeout);
56649    };
56650    (0,external_wp_element_namespaceObject.useEffect)(() => () => {
56651      /**
56652       * We need to call the change handler with `isFocused`
56653       * set to false on unmount because we also clear the
56654       * timeout that would handle that.
56655       */
56656      handleOnChange(false);
56657      clearTimeoutRef();
56658    }, []);
56659    return {
56660      debouncedShowGestures,
56661      debouncedHideGestures
56662    };
56663  }
56664  
56665  /**
56666   * Hook that provides gesture events for DOM elements
56667   * that interact with the isFocused state.
56668   *
56669   * @param {Object} props                         Component props.
56670   * @param {Object} props.ref                     Element reference.
56671   * @param {number} [props.highlightParent=false] Whether to highlight the parent block. It defaults to highlighting the selected block.
56672   * @param {number} [props.debounceTimeout=250]   Debounce timeout in milliseconds.
56673   */
56674  function useShowHoveredOrFocusedGestures({
56675    ref,
56676    highlightParent = false,
56677    debounceTimeout = DEBOUNCE_TIMEOUT
56678  }) {
56679    const [isFocused, setIsFocused] = (0,external_wp_element_namespaceObject.useState)(false);
56680    const {
56681      debouncedShowGestures,
56682      debouncedHideGestures
56683    } = useDebouncedShowGestures({
56684      ref,
56685      debounceTimeout,
56686      isFocused,
56687      highlightParent
56688    });
56689    const registerRef = (0,external_wp_element_namespaceObject.useRef)(false);
56690    const isFocusedWithin = () => {
56691      return ref?.current && ref.current.contains(ref.current.ownerDocument.activeElement);
56692    };
56693    (0,external_wp_element_namespaceObject.useEffect)(() => {
56694      const node = ref.current;
56695      const handleOnFocus = () => {
56696        if (isFocusedWithin()) {
56697          setIsFocused(true);
56698          debouncedShowGestures();
56699        }
56700      };
56701      const handleOnBlur = () => {
56702        if (!isFocusedWithin()) {
56703          setIsFocused(false);
56704          debouncedHideGestures();
56705        }
56706      };
56707  
56708      /**
56709       * Events are added via DOM events (vs. React synthetic events),
56710       * as the child React components swallow mouse events.
56711       */
56712      if (node && !registerRef.current) {
56713        node.addEventListener('focus', handleOnFocus, true);
56714        node.addEventListener('blur', handleOnBlur, true);
56715        registerRef.current = true;
56716      }
56717      return () => {
56718        if (node) {
56719          node.removeEventListener('focus', handleOnFocus);
56720          node.removeEventListener('blur', handleOnBlur);
56721        }
56722      };
56723    }, [ref, registerRef, setIsFocused, debouncedShowGestures, debouncedHideGestures]);
56724    return {
56725      onMouseMove: debouncedShowGestures,
56726      onMouseLeave: debouncedHideGestures
56727    };
56728  }
56729  
56730  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-parent-selector/index.js
56731  /**
56732   * WordPress dependencies
56733   */
56734  
56735  
56736  
56737  
56738  
56739  /**
56740   * Internal dependencies
56741   */
56742  
56743  
56744  
56745  
56746  
56747  
56748  /**
56749   * Block parent selector component, displaying the hierarchy of the
56750   * current block selection as a single icon to "go up" a level.
56751   *
56752   * @return {Component} Parent block selector.
56753   */
56754  
56755  function BlockParentSelector() {
56756    const {
56757      selectBlock
56758    } = (0,external_wp_data_namespaceObject.useDispatch)(store);
56759    const {
56760      parentClientId
56761    } = (0,external_wp_data_namespaceObject.useSelect)(select => {
56762      const {
56763        getBlockParents,
56764        getSelectedBlockClientId,
56765        getParentSectionBlock
56766      } = unlock(select(store));
56767      const selectedBlockClientId = getSelectedBlockClientId();
56768      const parentSection = getParentSectionBlock(selectedBlockClientId);
56769      const parents = getBlockParents(selectedBlockClientId);
56770      const _parentClientId = parentSection !== null && parentSection !== void 0 ? parentSection : parents[parents.length - 1];
56771      return {
56772        parentClientId: _parentClientId
56773      };
56774    }, []);
56775    const blockInformation = useBlockDisplayInformation(parentClientId);
56776  
56777    // Allows highlighting the parent block outline when focusing or hovering
56778    // the parent block selector within the child.
56779    const nodeRef = (0,external_wp_element_namespaceObject.useRef)();
56780    const showHoveredOrFocusedGestures = useShowHoveredOrFocusedGestures({
56781      ref: nodeRef,
56782      highlightParent: true
56783    });
56784    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
56785      className: "block-editor-block-parent-selector",
56786      ref: nodeRef,
56787      ...showHoveredOrFocusedGestures,
56788      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarButton, {
56789        className: "block-editor-block-parent-selector__button",
56790        onClick: () => selectBlock(parentClientId),
56791        label: (0,external_wp_i18n_namespaceObject.sprintf)(/* translators: %s: Name of the block's parent. */
56792        (0,external_wp_i18n_namespaceObject.__)('Select parent block: %s'), blockInformation?.title),
56793        showTooltip: true,
56794        icon: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_icon, {
56795          icon: blockInformation?.icon
56796        })
56797      })
56798    }, parentClientId);
56799  }
56800  
56801  ;// ./node_modules/@wordpress/icons/build-module/library/copy.js
56802  /**
56803   * WordPress dependencies
56804   */
56805  
56806  
56807  const copy_copy = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
56808    xmlns: "http://www.w3.org/2000/svg",
56809    viewBox: "0 0 24 24",
56810    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
56811      fillRule: "evenodd",
56812      clipRule: "evenodd",
56813      d: "M5 4.5h11a.5.5 0 0 1 .5.5v11a.5.5 0 0 1-.5.5H5a.5.5 0 0 1-.5-.5V5a.5.5 0 0 1 .5-.5ZM3 5a2 2 0 0 1 2-2h11a2 2 0 0 1 2 2v11a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V5Zm17 3v10.75c0 .69-.56 1.25-1.25 1.25H6v1.5h12.75a2.75 2.75 0 0 0 2.75-2.75V8H20Z"
56814    })
56815  });
56816  /* harmony default export */ const library_copy = (copy_copy);
56817  
56818  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-switcher/preview-block-popover.js
56819  /**
56820   * WordPress dependencies
56821   */
56822  
56823  
56824  
56825  
56826  /**
56827   * Internal dependencies
56828   */
56829  
56830  
56831  function PreviewBlockPopover({
56832    blocks
56833  }) {
56834    const isMobile = (0,external_wp_compose_namespaceObject.useViewportMatch)('medium', '<');
56835    if (isMobile) {
56836      return null;
56837    }
56838    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
56839      className: "block-editor-block-switcher__popover-preview-container",
56840      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Popover, {
56841        className: "block-editor-block-switcher__popover-preview",
56842        placement: "right-start",
56843        focusOnMount: false,
56844        offset: 16,
56845        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
56846          className: "block-editor-block-switcher__preview",
56847          children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
56848            className: "block-editor-block-switcher__preview-title",
56849            children: (0,external_wp_i18n_namespaceObject.__)('Preview')
56850          }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_preview, {
56851            viewportWidth: 500,
56852            blocks: blocks
56853          })]
56854        })
56855      })
56856    });
56857  }
56858  
56859  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-switcher/block-variation-transformations.js
56860  /**
56861   * WordPress dependencies
56862   */
56863  
56864  
56865  
56866  
56867  
56868  /**
56869   * Internal dependencies
56870   */
56871  
56872  
56873  
56874  
56875  const block_variation_transformations_EMPTY_OBJECT = {};
56876  function useBlockVariationTransforms({
56877    clientIds,
56878    blocks
56879  }) {
56880    const {
56881      activeBlockVariation,
56882      blockVariationTransformations
56883    } = (0,external_wp_data_namespaceObject.useSelect)(select => {
56884      const {
56885        getBlockAttributes,
56886        canRemoveBlocks
56887      } = select(store);
56888      const {
56889        getActiveBlockVariation,
56890        getBlockVariations
56891      } = select(external_wp_blocks_namespaceObject.store);
56892      const canRemove = canRemoveBlocks(clientIds);
56893      // Only handle single selected blocks for now.
56894      if (blocks.length !== 1 || !canRemove) {
56895        return block_variation_transformations_EMPTY_OBJECT;
56896      }
56897      const [firstBlock] = blocks;
56898      return {
56899        blockVariationTransformations: getBlockVariations(firstBlock.name, 'transform'),
56900        activeBlockVariation: getActiveBlockVariation(firstBlock.name, getBlockAttributes(firstBlock.clientId))
56901      };
56902    }, [clientIds, blocks]);
56903    const transformations = (0,external_wp_element_namespaceObject.useMemo)(() => {
56904      return blockVariationTransformations?.filter(({
56905        name
56906      }) => name !== activeBlockVariation?.name);
56907    }, [blockVariationTransformations, activeBlockVariation]);
56908    return transformations;
56909  }
56910  const BlockVariationTransformations = ({
56911    transformations,
56912    onSelect,
56913    blocks
56914  }) => {
56915    const [hoveredTransformItemName, setHoveredTransformItemName] = (0,external_wp_element_namespaceObject.useState)();
56916    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
56917      children: [hoveredTransformItemName && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PreviewBlockPopover, {
56918        blocks: (0,external_wp_blocks_namespaceObject.cloneBlock)(blocks[0], transformations.find(({
56919          name
56920        }) => name === hoveredTransformItemName).attributes)
56921      }), transformations?.map(item => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockVariationTransformationItem, {
56922        item: item,
56923        onSelect: onSelect,
56924        setHoveredTransformItemName: setHoveredTransformItemName
56925      }, item.name))]
56926    });
56927  };
56928  function BlockVariationTransformationItem({
56929    item,
56930    onSelect,
56931    setHoveredTransformItemName
56932  }) {
56933    const {
56934      name,
56935      icon,
56936      title
56937    } = item;
56938    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.MenuItem, {
56939      className: (0,external_wp_blocks_namespaceObject.getBlockMenuDefaultClassName)(name),
56940      onClick: event => {
56941        event.preventDefault();
56942        onSelect(name);
56943      },
56944      onMouseLeave: () => setHoveredTransformItemName(null),
56945      onMouseEnter: () => setHoveredTransformItemName(name),
56946      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_icon, {
56947        icon: icon,
56948        showColors: true
56949      }), title]
56950    });
56951  }
56952  /* harmony default export */ const block_variation_transformations = (BlockVariationTransformations);
56953  
56954  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-switcher/block-transformations-menu.js
56955  /**
56956   * WordPress dependencies
56957   */
56958  
56959  
56960  
56961  
56962  
56963  /**
56964   * Internal dependencies
56965   */
56966  
56967  
56968  
56969  
56970  /**
56971   * Helper hook to group transformations to display them in a specific order in the UI.
56972   * For now we group only priority content driven transformations(ex. paragraph -> heading).
56973   *
56974   * Later on we could also group 'layout' transformations(ex. paragraph -> group) and
56975   * display them in different sections.
56976   *
56977   * @param {Object[]} possibleBlockTransformations The available block transformations.
56978   * @return {Record<string, Object[]>} The grouped block transformations.
56979   */
56980  
56981  function useGroupedTransforms(possibleBlockTransformations) {
56982    const priorityContentTransformationBlocks = {
56983      'core/paragraph': 1,
56984      'core/heading': 2,
56985      'core/list': 3,
56986      'core/quote': 4
56987    };
56988    const transformations = (0,external_wp_element_namespaceObject.useMemo)(() => {
56989      const priorityTextTransformsNames = Object.keys(priorityContentTransformationBlocks);
56990      const groupedPossibleTransforms = possibleBlockTransformations.reduce((accumulator, item) => {
56991        const {
56992          name
56993        } = item;
56994        if (priorityTextTransformsNames.includes(name)) {
56995          accumulator.priorityTextTransformations.push(item);
56996        } else {
56997          accumulator.restTransformations.push(item);
56998        }
56999        return accumulator;
57000      }, {
57001        priorityTextTransformations: [],
57002        restTransformations: []
57003      });
57004      /**
57005       * If there is only one priority text transformation and it's a Quote,
57006       * is should move to the rest transformations. This is because Quote can
57007       * be a container for any block type, so in multi-block selection it will
57008       * always be suggested, even for non-text blocks.
57009       */
57010      if (groupedPossibleTransforms.priorityTextTransformations.length === 1 && groupedPossibleTransforms.priorityTextTransformations[0].name === 'core/quote') {
57011        const singleQuote = groupedPossibleTransforms.priorityTextTransformations.pop();
57012        groupedPossibleTransforms.restTransformations.push(singleQuote);
57013      }
57014      return groupedPossibleTransforms;
57015    }, [possibleBlockTransformations]);
57016  
57017    // Order the priority text transformations.
57018    transformations.priorityTextTransformations.sort(({
57019      name: currentName
57020    }, {
57021      name: nextName
57022    }) => {
57023      return priorityContentTransformationBlocks[currentName] < priorityContentTransformationBlocks[nextName] ? -1 : 1;
57024    });
57025    return transformations;
57026  }
57027  const BlockTransformationsMenu = ({
57028    className,
57029    possibleBlockTransformations,
57030    possibleBlockVariationTransformations,
57031    onSelect,
57032    onSelectVariation,
57033    blocks
57034  }) => {
57035    const [hoveredTransformItemName, setHoveredTransformItemName] = (0,external_wp_element_namespaceObject.useState)();
57036    const {
57037      priorityTextTransformations,
57038      restTransformations
57039    } = useGroupedTransforms(possibleBlockTransformations);
57040    // We have to check if both content transformations(priority and rest) are set
57041    // in order to create a separate MenuGroup for them.
57042    const hasBothContentTransformations = priorityTextTransformations.length && restTransformations.length;
57043    const restTransformItems = !!restTransformations.length && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(RestTransformationItems, {
57044      restTransformations: restTransformations,
57045      onSelect: onSelect,
57046      setHoveredTransformItemName: setHoveredTransformItemName
57047    });
57048    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
57049      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.MenuGroup, {
57050        label: (0,external_wp_i18n_namespaceObject.__)('Transform to'),
57051        className: className,
57052        children: [hoveredTransformItemName && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PreviewBlockPopover, {
57053          blocks: (0,external_wp_blocks_namespaceObject.switchToBlockType)(blocks, hoveredTransformItemName)
57054        }), !!possibleBlockVariationTransformations?.length && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_variation_transformations, {
57055          transformations: possibleBlockVariationTransformations,
57056          blocks: blocks,
57057          onSelect: onSelectVariation
57058        }), priorityTextTransformations.map(item => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockTransformationItem, {
57059          item: item,
57060          onSelect: onSelect,
57061          setHoveredTransformItemName: setHoveredTransformItemName
57062        }, item.name)), !hasBothContentTransformations && restTransformItems]
57063      }), !!hasBothContentTransformations && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuGroup, {
57064        className: className,
57065        children: restTransformItems
57066      })]
57067    });
57068  };
57069  function RestTransformationItems({
57070    restTransformations,
57071    onSelect,
57072    setHoveredTransformItemName
57073  }) {
57074    return restTransformations.map(item => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockTransformationItem, {
57075      item: item,
57076      onSelect: onSelect,
57077      setHoveredTransformItemName: setHoveredTransformItemName
57078    }, item.name));
57079  }
57080  function BlockTransformationItem({
57081    item,
57082    onSelect,
57083    setHoveredTransformItemName
57084  }) {
57085    const {
57086      name,
57087      icon,
57088      title,
57089      isDisabled
57090    } = item;
57091    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.MenuItem, {
57092      className: (0,external_wp_blocks_namespaceObject.getBlockMenuDefaultClassName)(name),
57093      onClick: event => {
57094        event.preventDefault();
57095        onSelect(name);
57096      },
57097      disabled: isDisabled,
57098      onMouseLeave: () => setHoveredTransformItemName(null),
57099      onMouseEnter: () => setHoveredTransformItemName(name),
57100      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_icon, {
57101        icon: icon,
57102        showColors: true
57103      }), title]
57104    });
57105  }
57106  /* harmony default export */ const block_transformations_menu = (BlockTransformationsMenu);
57107  
57108  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-styles/utils.js
57109  /**
57110   * WordPress dependencies
57111   */
57112  
57113  
57114  
57115  /**
57116   * Returns the active style from the given className.
57117   *
57118   * @param {Array}  styles    Block styles.
57119   * @param {string} className Class name
57120   *
57121   * @return {?Object} The active style.
57122   */
57123  function getActiveStyle(styles, className) {
57124    for (const style of new (external_wp_tokenList_default())(className).values()) {
57125      if (style.indexOf('is-style-') === -1) {
57126        continue;
57127      }
57128      const potentialStyleName = style.substring(9);
57129      const activeStyle = styles?.find(({
57130        name
57131      }) => name === potentialStyleName);
57132      if (activeStyle) {
57133        return activeStyle;
57134      }
57135    }
57136    return getDefaultStyle(styles);
57137  }
57138  
57139  /**
57140   * Replaces the active style in the block's className.
57141   *
57142   * @param {string}  className   Class name.
57143   * @param {?Object} activeStyle The replaced style.
57144   * @param {Object}  newStyle    The replacing style.
57145   *
57146   * @return {string} The updated className.
57147   */
57148  function replaceActiveStyle(className, activeStyle, newStyle) {
57149    const list = new (external_wp_tokenList_default())(className);
57150    if (activeStyle) {
57151      list.remove('is-style-' + activeStyle.name);
57152    }
57153    list.add('is-style-' + newStyle.name);
57154    return list.value;
57155  }
57156  
57157  /**
57158   * Returns a collection of styles that can be represented on the frontend.
57159   * The function checks a style collection for a default style. If none is found, it adds one to
57160   * act as a fallback for when there is no active style applied to a block. The default item also serves
57161   * as a switch on the frontend to deactivate non-default styles.
57162   *
57163   * @param {Array} styles Block styles.
57164   *
57165   * @return {Array<Object?>}        The style collection.
57166   */
57167  function getRenderedStyles(styles) {
57168    if (!styles || styles.length === 0) {
57169      return [];
57170    }
57171    return getDefaultStyle(styles) ? styles : [{
57172      name: 'default',
57173      label: (0,external_wp_i18n_namespaceObject._x)('Default', 'block style'),
57174      isDefault: true
57175    }, ...styles];
57176  }
57177  
57178  /**
57179   * Returns a style object from a collection of styles where that style object is the default block style.
57180   *
57181   * @param {Array} styles Block styles.
57182   *
57183   * @return {?Object}        The default style object, if found.
57184   */
57185  function getDefaultStyle(styles) {
57186    return styles?.find(style => style.isDefault);
57187  }
57188  
57189  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-styles/use-styles-for-block.js
57190  /**
57191   * WordPress dependencies
57192   */
57193  
57194  
57195  
57196  
57197  /**
57198   * Internal dependencies
57199   */
57200  
57201  
57202  
57203  /**
57204   *
57205   * @param {WPBlock}     block Block object.
57206   * @param {WPBlockType} type  Block type settings.
57207   * @return {WPBlock}          A generic block ready for styles preview.
57208   */
57209  function useGenericPreviewBlock(block, type) {
57210    return (0,external_wp_element_namespaceObject.useMemo)(() => {
57211      const example = type?.example;
57212      const blockName = type?.name;
57213      if (example && blockName) {
57214        return (0,external_wp_blocks_namespaceObject.getBlockFromExample)(blockName, {
57215          attributes: example.attributes,
57216          innerBlocks: example.innerBlocks
57217        });
57218      }
57219      if (block) {
57220        return (0,external_wp_blocks_namespaceObject.cloneBlock)(block);
57221      }
57222    }, [type?.example ? block?.name : block, type]);
57223  }
57224  
57225  /**
57226   * @typedef useStylesForBlocksArguments
57227   * @property {string}     clientId Block client ID.
57228   * @property {() => void} onSwitch Block style switch callback function.
57229   */
57230  
57231  /**
57232   *
57233   * @param {useStylesForBlocksArguments} useStylesForBlocks arguments.
57234   * @return {Object}                                         Results of the select methods.
57235   */
57236  function useStylesForBlocks({
57237    clientId,
57238    onSwitch
57239  }) {
57240    const selector = select => {
57241      const {
57242        getBlock
57243      } = select(store);
57244      const block = getBlock(clientId);
57245      if (!block) {
57246        return {};
57247      }
57248      const blockType = (0,external_wp_blocks_namespaceObject.getBlockType)(block.name);
57249      const {
57250        getBlockStyles
57251      } = select(external_wp_blocks_namespaceObject.store);
57252      return {
57253        block,
57254        blockType,
57255        styles: getBlockStyles(block.name),
57256        className: block.attributes.className || ''
57257      };
57258    };
57259    const {
57260      styles,
57261      block,
57262      blockType,
57263      className
57264    } = (0,external_wp_data_namespaceObject.useSelect)(selector, [clientId]);
57265    const {
57266      updateBlockAttributes
57267    } = (0,external_wp_data_namespaceObject.useDispatch)(store);
57268    const stylesToRender = getRenderedStyles(styles);
57269    const activeStyle = getActiveStyle(stylesToRender, className);
57270    const genericPreviewBlock = useGenericPreviewBlock(block, blockType);
57271    const onSelect = style => {
57272      const styleClassName = replaceActiveStyle(className, activeStyle, style);
57273      updateBlockAttributes(clientId, {
57274        className: styleClassName
57275      });
57276      onSwitch();
57277    };
57278    return {
57279      onSelect,
57280      stylesToRender,
57281      activeStyle,
57282      genericPreviewBlock,
57283      className
57284    };
57285  }
57286  
57287  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-styles/menu-items.js
57288  /**
57289   * WordPress dependencies
57290   */
57291  
57292  
57293  
57294  /**
57295   * Internal dependencies
57296   */
57297  
57298  
57299  const menu_items_noop = () => {};
57300  function BlockStylesMenuItems({
57301    clientId,
57302    onSwitch = menu_items_noop
57303  }) {
57304    const {
57305      onSelect,
57306      stylesToRender,
57307      activeStyle
57308    } = useStylesForBlocks({
57309      clientId,
57310      onSwitch
57311    });
57312    if (!stylesToRender || stylesToRender.length === 0) {
57313      return null;
57314    }
57315    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_ReactJSXRuntime_namespaceObject.Fragment, {
57316      children: stylesToRender.map(style => {
57317        const menuItemText = style.label || style.name;
57318        return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, {
57319          icon: activeStyle.name === style.name ? library_check : null,
57320          onClick: () => onSelect(style),
57321          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalText, {
57322            as: "span",
57323            limit: 18,
57324            ellipsizeMode: "tail",
57325            truncate: true,
57326            children: menuItemText
57327          })
57328        }, style.name);
57329      })
57330    });
57331  }
57332  
57333  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-switcher/block-styles-menu.js
57334  /**
57335   * WordPress dependencies
57336   */
57337  
57338  
57339  
57340  /**
57341   * Internal dependencies
57342   */
57343  
57344  
57345  function BlockStylesMenu({
57346    hoveredBlock,
57347    onSwitch
57348  }) {
57349    const {
57350      clientId
57351    } = hoveredBlock;
57352    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuGroup, {
57353      label: (0,external_wp_i18n_namespaceObject.__)('Styles'),
57354      className: "block-editor-block-switcher__styles__menugroup",
57355      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockStylesMenuItems, {
57356        clientId: clientId,
57357        onSwitch: onSwitch
57358      })
57359    });
57360  }
57361  
57362  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-switcher/utils.js
57363  /**
57364   * WordPress dependencies
57365   */
57366  
57367  
57368  /**
57369   * Try to find a matching block by a block's name in a provided
57370   * block. We recurse through InnerBlocks and return the reference
57371   * of the matched block (it could be an InnerBlock).
57372   * If no match is found return nothing.
57373   *
57374   * @param {WPBlock} block             The block to try to find a match.
57375   * @param {string}  selectedBlockName The block's name to use for matching condition.
57376   * @param {Set}     consumedBlocks    A set holding the previously matched/consumed blocks.
57377   *
57378   * @return {WPBlock | undefined} The matched block if found or nothing(`undefined`).
57379   */
57380  const getMatchingBlockByName = (block, selectedBlockName, consumedBlocks = new Set()) => {
57381    const {
57382      clientId,
57383      name,
57384      innerBlocks = []
57385    } = block;
57386    // Check if block has been consumed already.
57387    if (consumedBlocks.has(clientId)) {
57388      return;
57389    }
57390    if (name === selectedBlockName) {
57391      return block;
57392    }
57393    // Try to find a matching block from InnerBlocks recursively.
57394    for (const innerBlock of innerBlocks) {
57395      const match = getMatchingBlockByName(innerBlock, selectedBlockName, consumedBlocks);
57396      if (match) {
57397        return match;
57398      }
57399    }
57400  };
57401  
57402  /**
57403   * Find and return the block attributes to retain through
57404   * the transformation, based on Block Type's `role:content`
57405   * attributes. If no `role:content` attributes exist,
57406   * return selected block's attributes.
57407   *
57408   * @param {string} name       Block type's namespaced name.
57409   * @param {Object} attributes Selected block's attributes.
57410   * @return {Object} The block's attributes to retain.
57411   */
57412  const getRetainedBlockAttributes = (name, attributes) => {
57413    const contentAttributes = (0,external_wp_blocks_namespaceObject.getBlockAttributesNamesByRole)(name, 'content');
57414    if (!contentAttributes?.length) {
57415      return attributes;
57416    }
57417    return contentAttributes.reduce((_accumulator, attribute) => {
57418      if (attributes[attribute]) {
57419        _accumulator[attribute] = attributes[attribute];
57420      }
57421      return _accumulator;
57422    }, {});
57423  };
57424  
57425  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-switcher/use-transformed-patterns.js
57426  /**
57427   * WordPress dependencies
57428   */
57429  
57430  
57431  
57432  /**
57433   * Internal dependencies
57434   */
57435  
57436  
57437  /**
57438   * Mutate the matched block's attributes by getting
57439   * which block type's attributes to retain and prioritize
57440   * them in the merging of the attributes.
57441   *
57442   * @param {WPBlock} match         The matched block.
57443   * @param {WPBlock} selectedBlock The selected block.
57444   * @return {void}
57445   */
57446  const transformMatchingBlock = (match, selectedBlock) => {
57447    // Get the block attributes to retain through the transformation.
57448    const retainedBlockAttributes = getRetainedBlockAttributes(selectedBlock.name, selectedBlock.attributes);
57449    match.attributes = {
57450      ...match.attributes,
57451      ...retainedBlockAttributes
57452    };
57453  };
57454  
57455  /**
57456   * By providing the selected blocks and pattern's blocks
57457   * find the matching blocks, transform them and return them.
57458   * If not all selected blocks are matched, return nothing.
57459   *
57460   * @param {WPBlock[]} selectedBlocks The selected blocks.
57461   * @param {WPBlock[]} patternBlocks  The pattern's blocks.
57462   * @return {WPBlock[]|void} The transformed pattern's blocks or undefined if not all selected blocks have been matched.
57463   */
57464  const getPatternTransformedBlocks = (selectedBlocks, patternBlocks) => {
57465    // Clone Pattern's blocks to produce new clientIds and be able to mutate the matches.
57466    const _patternBlocks = patternBlocks.map(block => (0,external_wp_blocks_namespaceObject.cloneBlock)(block));
57467    /**
57468     * Keep track of the consumed pattern blocks.
57469     * This is needed because we loop the selected blocks
57470     * and for example we may have selected two paragraphs and
57471     * the pattern's blocks could have more `paragraphs`.
57472     */
57473    const consumedBlocks = new Set();
57474    for (const selectedBlock of selectedBlocks) {
57475      let isMatch = false;
57476      for (const patternBlock of _patternBlocks) {
57477        const match = getMatchingBlockByName(patternBlock, selectedBlock.name, consumedBlocks);
57478        if (!match) {
57479          continue;
57480        }
57481        isMatch = true;
57482        consumedBlocks.add(match.clientId);
57483        // We update (mutate) the matching pattern block.
57484        transformMatchingBlock(match, selectedBlock);
57485        // No need to loop through other pattern's blocks.
57486        break;
57487      }
57488      // Bail early if a selected block has not been matched.
57489      if (!isMatch) {
57490        return;
57491      }
57492    }
57493    return _patternBlocks;
57494  };
57495  
57496  /**
57497   * @typedef {WPBlockPattern & {transformedBlocks: WPBlock[]}} TransformedBlockPattern
57498   */
57499  
57500  /**
57501   * Custom hook that accepts patterns from state and the selected
57502   * blocks and tries to match these with the pattern's blocks.
57503   * If all selected blocks are matched with a Pattern's block,
57504   * we transform them by retaining block's attributes with `role:content`.
57505   * The transformed pattern's blocks are set to a new pattern
57506   * property `transformedBlocks`.
57507   *
57508   * @param {WPBlockPattern[]} patterns       Patterns from state.
57509   * @param {WPBlock[]}        selectedBlocks The currently selected blocks.
57510   * @return {TransformedBlockPattern[]} Returns the eligible matched patterns with all the selected blocks.
57511   */
57512  const useTransformedPatterns = (patterns, selectedBlocks) => {
57513    return (0,external_wp_element_namespaceObject.useMemo)(() => patterns.reduce((accumulator, _pattern) => {
57514      const transformedBlocks = getPatternTransformedBlocks(selectedBlocks, _pattern.blocks);
57515      if (transformedBlocks) {
57516        accumulator.push({
57517          ..._pattern,
57518          transformedBlocks
57519        });
57520      }
57521      return accumulator;
57522    }, []), [patterns, selectedBlocks]);
57523  };
57524  /* harmony default export */ const use_transformed_patterns = (useTransformedPatterns);
57525  
57526  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-switcher/pattern-transformations-menu.js
57527  /**
57528   * WordPress dependencies
57529   */
57530  
57531  
57532  
57533  
57534  
57535  
57536  /**
57537   * Internal dependencies
57538   */
57539  
57540  
57541  
57542  function PatternTransformationsMenu({
57543    blocks,
57544    patterns: statePatterns,
57545    onSelect
57546  }) {
57547    const [showTransforms, setShowTransforms] = (0,external_wp_element_namespaceObject.useState)(false);
57548    const patterns = use_transformed_patterns(statePatterns, blocks);
57549    if (!patterns.length) {
57550      return null;
57551    }
57552    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.MenuGroup, {
57553      className: "block-editor-block-switcher__pattern__transforms__menugroup",
57554      children: [showTransforms && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PreviewPatternsPopover, {
57555        patterns: patterns,
57556        onSelect: onSelect
57557      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, {
57558        onClick: event => {
57559          event.preventDefault();
57560          setShowTransforms(!showTransforms);
57561        },
57562        icon: chevron_right,
57563        children: (0,external_wp_i18n_namespaceObject.__)('Patterns')
57564      })]
57565    });
57566  }
57567  function PreviewPatternsPopover({
57568    patterns,
57569    onSelect
57570  }) {
57571    const isMobile = (0,external_wp_compose_namespaceObject.useViewportMatch)('medium', '<');
57572    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
57573      className: "block-editor-block-switcher__popover-preview-container",
57574      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Popover, {
57575        className: "block-editor-block-switcher__popover-preview",
57576        placement: isMobile ? 'bottom' : 'right-start',
57577        offset: 16,
57578        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
57579          className: "block-editor-block-switcher__preview is-pattern-list-preview",
57580          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(pattern_transformations_menu_BlockPatternsList, {
57581            patterns: patterns,
57582            onSelect: onSelect
57583          })
57584        })
57585      })
57586    });
57587  }
57588  function pattern_transformations_menu_BlockPatternsList({
57589    patterns,
57590    onSelect
57591  }) {
57592    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Composite, {
57593      role: "listbox",
57594      className: "block-editor-block-switcher__preview-patterns-container",
57595      "aria-label": (0,external_wp_i18n_namespaceObject.__)('Patterns list'),
57596      children: patterns.map(pattern => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(pattern_transformations_menu_BlockPattern, {
57597        pattern: pattern,
57598        onSelect: onSelect
57599      }, pattern.name))
57600    });
57601  }
57602  function pattern_transformations_menu_BlockPattern({
57603    pattern,
57604    onSelect
57605  }) {
57606    // TODO check pattern/preview width...
57607    const baseClassName = 'block-editor-block-switcher__preview-patterns-container';
57608    const descriptionId = (0,external_wp_compose_namespaceObject.useInstanceId)(pattern_transformations_menu_BlockPattern, `$baseClassName}-list__item-description`);
57609    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
57610      className: `$baseClassName}-list__list-item`,
57611      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.Composite.Item, {
57612        render: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
57613          role: "option",
57614          "aria-label": pattern.title,
57615          "aria-describedby": pattern.description ? descriptionId : undefined,
57616          className: `$baseClassName}-list__item`
57617        }),
57618        onClick: () => onSelect(pattern.transformedBlocks),
57619        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_preview, {
57620          blocks: pattern.transformedBlocks,
57621          viewportWidth: pattern.viewportWidth || 500
57622        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
57623          className: `$baseClassName}-list__item-title`,
57624          children: pattern.title
57625        })]
57626      }), !!pattern.description && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.VisuallyHidden, {
57627        id: descriptionId,
57628        children: pattern.description
57629      })]
57630    });
57631  }
57632  /* harmony default export */ const pattern_transformations_menu = (PatternTransformationsMenu);
57633  
57634  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-switcher/index.js
57635  /**
57636   * WordPress dependencies
57637   */
57638  
57639  
57640  
57641  
57642  
57643  
57644  
57645  /**
57646   * Internal dependencies
57647   */
57648  
57649  
57650  
57651  
57652  
57653  
57654  
57655  
57656  function BlockSwitcherDropdownMenuContents({
57657    onClose,
57658    clientIds,
57659    hasBlockStyles,
57660    canRemove
57661  }) {
57662    const {
57663      replaceBlocks,
57664      multiSelect,
57665      updateBlockAttributes
57666    } = (0,external_wp_data_namespaceObject.useDispatch)(store);
57667    const {
57668      possibleBlockTransformations,
57669      patterns,
57670      blocks,
57671      isUsingBindings
57672    } = (0,external_wp_data_namespaceObject.useSelect)(select => {
57673      const {
57674        getBlockAttributes,
57675        getBlocksByClientId,
57676        getBlockRootClientId,
57677        getBlockTransformItems,
57678        __experimentalGetPatternTransformItems
57679      } = select(store);
57680      const rootClientId = getBlockRootClientId(clientIds[0]);
57681      const _blocks = getBlocksByClientId(clientIds);
57682      return {
57683        blocks: _blocks,
57684        possibleBlockTransformations: getBlockTransformItems(_blocks, rootClientId),
57685        patterns: __experimentalGetPatternTransformItems(_blocks, rootClientId),
57686        isUsingBindings: clientIds.every(clientId => !!getBlockAttributes(clientId)?.metadata?.bindings)
57687      };
57688    }, [clientIds]);
57689    const blockVariationTransformations = useBlockVariationTransforms({
57690      clientIds,
57691      blocks
57692    });
57693    function selectForMultipleBlocks(insertedBlocks) {
57694      if (insertedBlocks.length > 1) {
57695        multiSelect(insertedBlocks[0].clientId, insertedBlocks[insertedBlocks.length - 1].clientId);
57696      }
57697    }
57698    // Simple block transformation based on the `Block Transforms` API.
57699    function onBlockTransform(name) {
57700      const newBlocks = (0,external_wp_blocks_namespaceObject.switchToBlockType)(blocks, name);
57701      replaceBlocks(clientIds, newBlocks);
57702      selectForMultipleBlocks(newBlocks);
57703    }
57704    function onBlockVariationTransform(name) {
57705      updateBlockAttributes(blocks[0].clientId, {
57706        ...blockVariationTransformations.find(({
57707          name: variationName
57708        }) => variationName === name).attributes
57709      });
57710    }
57711    // Pattern transformation through the `Patterns` API.
57712    function onPatternTransform(transformedBlocks) {
57713      replaceBlocks(clientIds, transformedBlocks);
57714      selectForMultipleBlocks(transformedBlocks);
57715    }
57716    /**
57717     * The `isTemplate` check is a stopgap solution here.
57718     * Ideally, the Transforms API should handle this
57719     * by allowing to exclude blocks from wildcard transformations.
57720     */
57721    const isSingleBlock = blocks.length === 1;
57722    const isTemplate = isSingleBlock && (0,external_wp_blocks_namespaceObject.isTemplatePart)(blocks[0]);
57723    const hasPossibleBlockTransformations = !!possibleBlockTransformations.length && canRemove && !isTemplate;
57724    const hasPossibleBlockVariationTransformations = !!blockVariationTransformations?.length;
57725    const hasPatternTransformation = !!patterns?.length && canRemove;
57726    const hasBlockOrBlockVariationTransforms = hasPossibleBlockTransformations || hasPossibleBlockVariationTransformations;
57727    const hasContents = hasBlockStyles || hasBlockOrBlockVariationTransforms || hasPatternTransformation;
57728    if (!hasContents) {
57729      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("p", {
57730        className: "block-editor-block-switcher__no-transforms",
57731        children: (0,external_wp_i18n_namespaceObject.__)('No transforms.')
57732      });
57733    }
57734    const connectedBlockDescription = isSingleBlock ? (0,external_wp_i18n_namespaceObject._x)('This block is connected.', 'block toolbar button label and description') : (0,external_wp_i18n_namespaceObject._x)('These blocks are connected.', 'block toolbar button label and description');
57735    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
57736      className: "block-editor-block-switcher__container",
57737      children: [hasPatternTransformation && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(pattern_transformations_menu, {
57738        blocks: blocks,
57739        patterns: patterns,
57740        onSelect: transformedBlocks => {
57741          onPatternTransform(transformedBlocks);
57742          onClose();
57743        }
57744      }), hasBlockOrBlockVariationTransforms && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_transformations_menu, {
57745        className: "block-editor-block-switcher__transforms__menugroup",
57746        possibleBlockTransformations: possibleBlockTransformations,
57747        possibleBlockVariationTransformations: blockVariationTransformations,
57748        blocks: blocks,
57749        onSelect: name => {
57750          onBlockTransform(name);
57751          onClose();
57752        },
57753        onSelectVariation: name => {
57754          onBlockVariationTransform(name);
57755          onClose();
57756        }
57757      }), hasBlockStyles && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockStylesMenu, {
57758        hoveredBlock: blocks[0],
57759        onSwitch: onClose
57760      }), isUsingBindings && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuGroup, {
57761        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalText, {
57762          className: "block-editor-block-switcher__binding-indicator",
57763          children: connectedBlockDescription
57764        })
57765      })]
57766    });
57767  }
57768  const BlockSwitcher = ({
57769    clientIds
57770  }) => {
57771    const {
57772      hasContentOnlyLocking,
57773      canRemove,
57774      hasBlockStyles,
57775      icon,
57776      invalidBlocks,
57777      isReusable,
57778      isTemplate,
57779      isDisabled
57780    } = (0,external_wp_data_namespaceObject.useSelect)(select => {
57781      const {
57782        getTemplateLock,
57783        getBlocksByClientId,
57784        getBlockAttributes,
57785        canRemoveBlocks,
57786        getBlockEditingMode
57787      } = select(store);
57788      const {
57789        getBlockStyles,
57790        getBlockType,
57791        getActiveBlockVariation
57792      } = select(external_wp_blocks_namespaceObject.store);
57793      const _blocks = getBlocksByClientId(clientIds);
57794      if (!_blocks.length || _blocks.some(block => !block)) {
57795        return {
57796          invalidBlocks: true
57797        };
57798      }
57799      const [{
57800        name: firstBlockName
57801      }] = _blocks;
57802      const _isSingleBlockSelected = _blocks.length === 1;
57803      const blockType = getBlockType(firstBlockName);
57804      const editingMode = getBlockEditingMode(clientIds[0]);
57805      let _icon;
57806      let _hasTemplateLock;
57807      if (_isSingleBlockSelected) {
57808        const match = getActiveBlockVariation(firstBlockName, getBlockAttributes(clientIds[0]));
57809        // Take into account active block variations.
57810        _icon = match?.icon || blockType.icon;
57811        _hasTemplateLock = getTemplateLock(clientIds[0]) === 'contentOnly';
57812      } else {
57813        const isSelectionOfSameType = new Set(_blocks.map(({
57814          name
57815        }) => name)).size === 1;
57816        _hasTemplateLock = clientIds.some(id => getTemplateLock(id) === 'contentOnly');
57817        // When selection consists of blocks of multiple types, display an
57818        // appropriate icon to communicate the non-uniformity.
57819        _icon = isSelectionOfSameType ? blockType.icon : library_copy;
57820      }
57821      return {
57822        canRemove: canRemoveBlocks(clientIds),
57823        hasBlockStyles: _isSingleBlockSelected && !!getBlockStyles(firstBlockName)?.length,
57824        icon: _icon,
57825        isReusable: _isSingleBlockSelected && (0,external_wp_blocks_namespaceObject.isReusableBlock)(_blocks[0]),
57826        isTemplate: _isSingleBlockSelected && (0,external_wp_blocks_namespaceObject.isTemplatePart)(_blocks[0]),
57827        hasContentOnlyLocking: _hasTemplateLock,
57828        isDisabled: editingMode !== 'default'
57829      };
57830    }, [clientIds]);
57831    const blockTitle = useBlockDisplayTitle({
57832      clientId: clientIds?.[0],
57833      maximumLength: 35
57834    });
57835    const showIconLabels = (0,external_wp_data_namespaceObject.useSelect)(select => select(external_wp_preferences_namespaceObject.store).get('core', 'showIconLabels'), []);
57836    if (invalidBlocks) {
57837      return null;
57838    }
57839    const isSingleBlock = clientIds.length === 1;
57840    const blockSwitcherLabel = isSingleBlock ? blockTitle : (0,external_wp_i18n_namespaceObject.__)('Multiple blocks selected');
57841    const blockIndicatorText = (isReusable || isTemplate) && !showIconLabels && blockTitle ? blockTitle : undefined;
57842    const hideDropdown = isDisabled || !hasBlockStyles && !canRemove || hasContentOnlyLocking;
57843    if (hideDropdown) {
57844      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarGroup, {
57845        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarButton, {
57846          disabled: true,
57847          className: "block-editor-block-switcher__no-switcher-icon",
57848          title: blockSwitcherLabel,
57849          icon: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_icon, {
57850            className: "block-editor-block-switcher__toggle",
57851            icon: icon,
57852            showColors: true
57853          }),
57854          text: blockIndicatorText
57855        })
57856      });
57857    }
57858    const blockSwitcherDescription = isSingleBlock ? (0,external_wp_i18n_namespaceObject.__)('Change block type or style') : (0,external_wp_i18n_namespaceObject.sprintf)(/* translators: %d: number of blocks. */
57859    (0,external_wp_i18n_namespaceObject._n)('Change type of %d block', 'Change type of %d blocks', clientIds.length), clientIds.length);
57860    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarGroup, {
57861      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarItem, {
57862        children: toggleProps => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.DropdownMenu, {
57863          className: "block-editor-block-switcher",
57864          label: blockSwitcherLabel,
57865          popoverProps: {
57866            placement: 'bottom-start',
57867            className: 'block-editor-block-switcher__popover'
57868          },
57869          icon: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_icon, {
57870            className: "block-editor-block-switcher__toggle",
57871            icon: icon,
57872            showColors: true
57873          }),
57874          text: blockIndicatorText,
57875          toggleProps: {
57876            description: blockSwitcherDescription,
57877            ...toggleProps
57878          },
57879          menuProps: {
57880            orientation: 'both'
57881          },
57882          children: ({
57883            onClose
57884          }) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockSwitcherDropdownMenuContents, {
57885            onClose: onClose,
57886            clientIds: clientIds,
57887            hasBlockStyles: hasBlockStyles,
57888            canRemove: canRemove
57889          })
57890        })
57891      })
57892    });
57893  };
57894  /* harmony default export */ const block_switcher = (BlockSwitcher);
57895  
57896  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-toolbar/block-toolbar-last-item.js
57897  /**
57898   * WordPress dependencies
57899   */
57900  
57901  const {
57902    Fill: __unstableBlockToolbarLastItem,
57903    Slot: block_toolbar_last_item_Slot
57904  } = (0,external_wp_components_namespaceObject.createSlotFill)('__unstableBlockToolbarLastItem');
57905  __unstableBlockToolbarLastItem.Slot = block_toolbar_last_item_Slot;
57906  /* harmony default export */ const block_toolbar_last_item = (__unstableBlockToolbarLastItem);
57907  
57908  ;// ./node_modules/@wordpress/block-editor/build-module/hooks/supports.js
57909  /**
57910   * WordPress dependencies
57911   */
57912  
57913  
57914  const ALIGN_SUPPORT_KEY = 'align';
57915  const ALIGN_WIDE_SUPPORT_KEY = 'alignWide';
57916  const supports_BORDER_SUPPORT_KEY = '__experimentalBorder';
57917  const supports_COLOR_SUPPORT_KEY = 'color';
57918  const CUSTOM_CLASS_NAME_SUPPORT_KEY = 'customClassName';
57919  const supports_FONT_FAMILY_SUPPORT_KEY = 'typography.__experimentalFontFamily';
57920  const supports_FONT_SIZE_SUPPORT_KEY = 'typography.fontSize';
57921  const supports_LINE_HEIGHT_SUPPORT_KEY = 'typography.lineHeight';
57922  /**
57923   * Key within block settings' support array indicating support for font style.
57924   */
57925  const supports_FONT_STYLE_SUPPORT_KEY = 'typography.__experimentalFontStyle';
57926  /**
57927   * Key within block settings' support array indicating support for font weight.
57928   */
57929  const supports_FONT_WEIGHT_SUPPORT_KEY = 'typography.__experimentalFontWeight';
57930  /**
57931   * Key within block settings' supports array indicating support for text
57932   * align e.g. settings found in `block.json`.
57933   */
57934  const supports_TEXT_ALIGN_SUPPORT_KEY = 'typography.textAlign';
57935  /**
57936   * Key within block settings' supports array indicating support for text
57937   * columns e.g. settings found in `block.json`.
57938   */
57939  const supports_TEXT_COLUMNS_SUPPORT_KEY = 'typography.textColumns';
57940  /**
57941   * Key within block settings' supports array indicating support for text
57942   * decorations e.g. settings found in `block.json`.
57943   */
57944  const supports_TEXT_DECORATION_SUPPORT_KEY = 'typography.__experimentalTextDecoration';
57945  /**
57946   * Key within block settings' supports array indicating support for writing mode
57947   * e.g. settings found in `block.json`.
57948   */
57949  const supports_WRITING_MODE_SUPPORT_KEY = 'typography.__experimentalWritingMode';
57950  /**
57951   * Key within block settings' supports array indicating support for text
57952   * transforms e.g. settings found in `block.json`.
57953   */
57954  const supports_TEXT_TRANSFORM_SUPPORT_KEY = 'typography.__experimentalTextTransform';
57955  
57956  /**
57957   * Key within block settings' supports array indicating support for letter-spacing
57958   * e.g. settings found in `block.json`.
57959   */
57960  const supports_LETTER_SPACING_SUPPORT_KEY = 'typography.__experimentalLetterSpacing';
57961  const LAYOUT_SUPPORT_KEY = 'layout';
57962  const supports_TYPOGRAPHY_SUPPORT_KEYS = [supports_LINE_HEIGHT_SUPPORT_KEY, supports_FONT_SIZE_SUPPORT_KEY, supports_FONT_STYLE_SUPPORT_KEY, supports_FONT_WEIGHT_SUPPORT_KEY, supports_FONT_FAMILY_SUPPORT_KEY, supports_TEXT_ALIGN_SUPPORT_KEY, supports_TEXT_COLUMNS_SUPPORT_KEY, supports_TEXT_DECORATION_SUPPORT_KEY, supports_TEXT_TRANSFORM_SUPPORT_KEY, supports_WRITING_MODE_SUPPORT_KEY, supports_LETTER_SPACING_SUPPORT_KEY];
57963  const EFFECTS_SUPPORT_KEYS = ['shadow'];
57964  const supports_SPACING_SUPPORT_KEY = 'spacing';
57965  const supports_styleSupportKeys = [...EFFECTS_SUPPORT_KEYS, ...supports_TYPOGRAPHY_SUPPORT_KEYS, supports_BORDER_SUPPORT_KEY, supports_COLOR_SUPPORT_KEY, supports_SPACING_SUPPORT_KEY];
57966  
57967  /**
57968   * Returns true if the block defines support for align.
57969   *
57970   * @param {string|Object} nameOrType Block name or type object.
57971   * @return {boolean} Whether the block supports the feature.
57972   */
57973  const hasAlignSupport = nameOrType => (0,external_wp_blocks_namespaceObject.hasBlockSupport)(nameOrType, ALIGN_SUPPORT_KEY);
57974  
57975  /**
57976   * Returns the block support value for align, if defined.
57977   *
57978   * @param {string|Object} nameOrType Block name or type object.
57979   * @return {unknown} The block support value.
57980   */
57981  const getAlignSupport = nameOrType => getBlockSupport(nameOrType, ALIGN_SUPPORT_KEY);
57982  
57983  /**
57984   * Returns true if the block defines support for align wide.
57985   *
57986   * @param {string|Object} nameOrType Block name or type object.
57987   * @return {boolean} Whether the block supports the feature.
57988   */
57989  const hasAlignWideSupport = nameOrType => hasBlockSupport(nameOrType, ALIGN_WIDE_SUPPORT_KEY);
57990  
57991  /**
57992   * Returns the block support value for align wide, if defined.
57993   *
57994   * @param {string|Object} nameOrType Block name or type object.
57995   * @return {unknown} The block support value.
57996   */
57997  const getAlignWideSupport = nameOrType => getBlockSupport(nameOrType, ALIGN_WIDE_SUPPORT_KEY);
57998  
57999  /**
58000   * Determine whether there is block support for border properties.
58001   *
58002   * @param {string|Object} nameOrType Block name or type object.
58003   * @param {string}        feature    Border feature to check support for.
58004   *
58005   * @return {boolean} Whether there is support.
58006   */
58007  function supports_hasBorderSupport(nameOrType, feature = 'any') {
58008    if (external_wp_element_namespaceObject.Platform.OS !== 'web') {
58009      return false;
58010    }
58011    const support = (0,external_wp_blocks_namespaceObject.getBlockSupport)(nameOrType, supports_BORDER_SUPPORT_KEY);
58012    if (support === true) {
58013      return true;
58014    }
58015    if (feature === 'any') {
58016      return !!(support?.color || support?.radius || support?.width || support?.style);
58017    }
58018    return !!support?.[feature];
58019  }
58020  
58021  /**
58022   * Get block support for border properties.
58023   *
58024   * @param {string|Object} nameOrType Block name or type object.
58025   * @param {string}        feature    Border feature to get.
58026   *
58027   * @return {unknown} The block support.
58028   */
58029  const getBorderSupport = (nameOrType, feature) => getBlockSupport(nameOrType, [supports_BORDER_SUPPORT_KEY, feature]);
58030  
58031  /**
58032   * Returns true if the block defines support for color.
58033   *
58034   * @param {string|Object} nameOrType Block name or type object.
58035   * @return {boolean} Whether the block supports the feature.
58036   */
58037  const supports_hasColorSupport = nameOrType => {
58038    const colorSupport = getBlockSupport(nameOrType, supports_COLOR_SUPPORT_KEY);
58039    return colorSupport && (colorSupport.link === true || colorSupport.gradient === true || colorSupport.background !== false || colorSupport.text !== false);
58040  };
58041  
58042  /**
58043   * Returns true if the block defines support for link color.
58044   *
58045   * @param {string|Object} nameOrType Block name or type object.
58046   * @return {boolean} Whether the block supports the feature.
58047   */
58048  const supports_hasLinkColorSupport = nameOrType => {
58049    if (Platform.OS !== 'web') {
58050      return false;
58051    }
58052    const colorSupport = getBlockSupport(nameOrType, supports_COLOR_SUPPORT_KEY);
58053    return colorSupport !== null && typeof colorSupport === 'object' && !!colorSupport.link;
58054  };
58055  
58056  /**
58057   * Returns true if the block defines support for gradient color.
58058   *
58059   * @param {string|Object} nameOrType Block name or type object.
58060   * @return {boolean} Whether the block supports the feature.
58061   */
58062  const supports_hasGradientSupport = nameOrType => {
58063    const colorSupport = (0,external_wp_blocks_namespaceObject.getBlockSupport)(nameOrType, supports_COLOR_SUPPORT_KEY);
58064    return colorSupport !== null && typeof colorSupport === 'object' && !!colorSupport.gradients;
58065  };
58066  
58067  /**
58068   * Returns true if the block defines support for background color.
58069   *
58070   * @param {string|Object} nameOrType Block name or type object.
58071   * @return {boolean} Whether the block supports the feature.
58072   */
58073  const supports_hasBackgroundColorSupport = nameOrType => {
58074    const colorSupport = (0,external_wp_blocks_namespaceObject.getBlockSupport)(nameOrType, supports_COLOR_SUPPORT_KEY);
58075    return colorSupport && colorSupport.background !== false;
58076  };
58077  
58078  /**
58079   * Returns true if the block defines support for text-align.
58080   *
58081   * @param {string|Object} nameOrType Block name or type object.
58082   * @return {boolean} Whether the block supports the feature.
58083   */
58084  const hasTextAlignSupport = nameOrType => (0,external_wp_blocks_namespaceObject.hasBlockSupport)(nameOrType, supports_TEXT_ALIGN_SUPPORT_KEY);
58085  
58086  /**
58087   * Returns the block support value for text-align, if defined.
58088   *
58089   * @param {string|Object} nameOrType Block name or type object.
58090   * @return {unknown} The block support value.
58091   */
58092  const getTextAlignSupport = nameOrType => getBlockSupport(nameOrType, supports_TEXT_ALIGN_SUPPORT_KEY);
58093  
58094  /**
58095   * Returns true if the block defines support for background color.
58096   *
58097   * @param {string|Object} nameOrType Block name or type object.
58098   * @return {boolean} Whether the block supports the feature.
58099   */
58100  const supports_hasTextColorSupport = nameOrType => {
58101    const colorSupport = (0,external_wp_blocks_namespaceObject.getBlockSupport)(nameOrType, supports_COLOR_SUPPORT_KEY);
58102    return colorSupport && colorSupport.text !== false;
58103  };
58104  
58105  /**
58106   * Get block support for color properties.
58107   *
58108   * @param {string|Object} nameOrType Block name or type object.
58109   * @param {string}        feature    Color feature to get.
58110   *
58111   * @return {unknown} The block support.
58112   */
58113  const getColorSupport = (nameOrType, feature) => getBlockSupport(nameOrType, [supports_COLOR_SUPPORT_KEY, feature]);
58114  
58115  /**
58116   * Returns true if the block defines support for custom class name.
58117   *
58118   * @param {string|Object} nameOrType Block name or type object.
58119   * @return {boolean} Whether the block supports the feature.
58120   */
58121  const hasCustomClassNameSupport = nameOrType => (0,external_wp_blocks_namespaceObject.hasBlockSupport)(nameOrType, CUSTOM_CLASS_NAME_SUPPORT_KEY, true);
58122  
58123  /**
58124   * Returns the block support value for custom class name, if defined.
58125   *
58126   * @param {string|Object} nameOrType Block name or type object.
58127   * @return {unknown} The block support value.
58128   */
58129  const getCustomClassNameSupport = nameOrType => getBlockSupport(nameOrType, CUSTOM_CLASS_NAME_SUPPORT_KEY, true);
58130  
58131  /**
58132   * Returns true if the block defines support for font family.
58133   *
58134   * @param {string|Object} nameOrType Block name or type object.
58135   * @return {boolean} Whether the block supports the feature.
58136   */
58137  const hasFontFamilySupport = nameOrType => (0,external_wp_blocks_namespaceObject.hasBlockSupport)(nameOrType, supports_FONT_FAMILY_SUPPORT_KEY);
58138  
58139  /**
58140   * Returns the block support value for font family, if defined.
58141   *
58142   * @param {string|Object} nameOrType Block name or type object.
58143   * @return {unknown} The block support value.
58144   */
58145  const getFontFamilySupport = nameOrType => getBlockSupport(nameOrType, supports_FONT_FAMILY_SUPPORT_KEY);
58146  
58147  /**
58148   * Returns true if the block defines support for font size.
58149   *
58150   * @param {string|Object} nameOrType Block name or type object.
58151   * @return {boolean} Whether the block supports the feature.
58152   */
58153  const hasFontSizeSupport = nameOrType => (0,external_wp_blocks_namespaceObject.hasBlockSupport)(nameOrType, supports_FONT_SIZE_SUPPORT_KEY);
58154  
58155  /**
58156   * Returns the block support value for font size, if defined.
58157   *
58158   * @param {string|Object} nameOrType Block name or type object.
58159   * @return {unknown} The block support value.
58160   */
58161  const getFontSizeSupport = nameOrType => getBlockSupport(nameOrType, supports_FONT_SIZE_SUPPORT_KEY);
58162  
58163  /**
58164   * Returns true if the block defines support for layout.
58165   *
58166   * @param {string|Object} nameOrType Block name or type object.
58167   * @return {boolean} Whether the block supports the feature.
58168   */
58169  const hasLayoutSupport = nameOrType => (0,external_wp_blocks_namespaceObject.hasBlockSupport)(nameOrType, LAYOUT_SUPPORT_KEY);
58170  
58171  /**
58172   * Returns the block support value for layout, if defined.
58173   *
58174   * @param {string|Object} nameOrType Block name or type object.
58175   * @return {unknown} The block support value.
58176   */
58177  const getLayoutSupport = nameOrType => getBlockSupport(nameOrType, LAYOUT_SUPPORT_KEY);
58178  
58179  /**
58180   * Returns true if the block defines support for style.
58181   *
58182   * @param {string|Object} nameOrType Block name or type object.
58183   * @return {boolean} Whether the block supports the feature.
58184   */
58185  const supports_hasStyleSupport = nameOrType => supports_styleSupportKeys.some(key => (0,external_wp_blocks_namespaceObject.hasBlockSupport)(nameOrType, key));
58186  
58187  ;// ./node_modules/@wordpress/block-editor/build-module/components/use-paste-styles/index.js
58188  /**
58189   * WordPress dependencies
58190   */
58191  
58192  
58193  
58194  
58195  
58196  
58197  /**
58198   * Internal dependencies
58199   */
58200  
58201  
58202  
58203  /**
58204   * Determine if the copied text looks like serialized blocks or not.
58205   * Since plain text will always get parsed into a freeform block,
58206   * we check that if the parsed blocks is anything other than that.
58207   *
58208   * @param {string} text The copied text.
58209   * @return {boolean} True if the text looks like serialized blocks, false otherwise.
58210   */
58211  function hasSerializedBlocks(text) {
58212    try {
58213      const blocks = (0,external_wp_blocks_namespaceObject.parse)(text, {
58214        __unstableSkipMigrationLogs: true,
58215        __unstableSkipAutop: true
58216      });
58217      if (blocks.length === 1 && blocks[0].name === 'core/freeform') {
58218        // It's likely that the text is just plain text and not serialized blocks.
58219        return false;
58220      }
58221      return true;
58222    } catch (err) {
58223      // Parsing error, the text is not serialized blocks.
58224      // (Even though that it technically won't happen)
58225      return false;
58226    }
58227  }
58228  
58229  /**
58230   * Style attributes are attributes being added in `block-editor/src/hooks/*`.
58231   * (Except for some unrelated to style like `anchor` or `settings`.)
58232   * They generally represent the default block supports.
58233   */
58234  const STYLE_ATTRIBUTES = {
58235    align: hasAlignSupport,
58236    borderColor: nameOrType => supports_hasBorderSupport(nameOrType, 'color'),
58237    backgroundColor: supports_hasBackgroundColorSupport,
58238    textAlign: hasTextAlignSupport,
58239    textColor: supports_hasTextColorSupport,
58240    gradient: supports_hasGradientSupport,
58241    className: hasCustomClassNameSupport,
58242    fontFamily: hasFontFamilySupport,
58243    fontSize: hasFontSizeSupport,
58244    layout: hasLayoutSupport,
58245    style: supports_hasStyleSupport
58246  };
58247  
58248  /**
58249   * Get the "style attributes" from a given block to a target block.
58250   *
58251   * @param {WPBlock} sourceBlock The source block.
58252   * @param {WPBlock} targetBlock The target block.
58253   * @return {Object} the filtered attributes object.
58254   */
58255  function getStyleAttributes(sourceBlock, targetBlock) {
58256    return Object.entries(STYLE_ATTRIBUTES).reduce((attributes, [attributeKey, hasSupport]) => {
58257      // Only apply the attribute if both blocks support it.
58258      if (hasSupport(sourceBlock.name) && hasSupport(targetBlock.name)) {
58259        // Override attributes that are not present in the block to their defaults.
58260        attributes[attributeKey] = sourceBlock.attributes[attributeKey];
58261      }
58262      return attributes;
58263    }, {});
58264  }
58265  
58266  /**
58267   * Update the target blocks with style attributes recursively.
58268   *
58269   * @param {WPBlock[]} targetBlocks          The target blocks to be updated.
58270   * @param {WPBlock[]} sourceBlocks          The source blocks to get th style attributes from.
58271   * @param {Function}  updateBlockAttributes The function to update the attributes.
58272   */
58273  function recursivelyUpdateBlockAttributes(targetBlocks, sourceBlocks, updateBlockAttributes) {
58274    for (let index = 0; index < Math.min(sourceBlocks.length, targetBlocks.length); index += 1) {
58275      updateBlockAttributes(targetBlocks[index].clientId, getStyleAttributes(sourceBlocks[index], targetBlocks[index]));
58276      recursivelyUpdateBlockAttributes(targetBlocks[index].innerBlocks, sourceBlocks[index].innerBlocks, updateBlockAttributes);
58277    }
58278  }
58279  
58280  /**
58281   * A hook to return a pasteStyles event function for handling pasting styles to blocks.
58282   *
58283   * @return {Function} A function to update the styles to the blocks.
58284   */
58285  function usePasteStyles() {
58286    const registry = (0,external_wp_data_namespaceObject.useRegistry)();
58287    const {
58288      updateBlockAttributes
58289    } = (0,external_wp_data_namespaceObject.useDispatch)(store);
58290    const {
58291      createSuccessNotice,
58292      createWarningNotice,
58293      createErrorNotice
58294    } = (0,external_wp_data_namespaceObject.useDispatch)(external_wp_notices_namespaceObject.store);
58295    return (0,external_wp_element_namespaceObject.useCallback)(async targetBlocks => {
58296      let html = '';
58297      try {
58298        // `http:` sites won't have the clipboard property on navigator.
58299        // (with the exception of localhost.)
58300        if (!window.navigator.clipboard) {
58301          createErrorNotice((0,external_wp_i18n_namespaceObject.__)('Unable to paste styles. This feature is only available on secure (https) sites in supporting browsers.'), {
58302            type: 'snackbar'
58303          });
58304          return;
58305        }
58306        html = await window.navigator.clipboard.readText();
58307      } catch (error) {
58308        // Possibly the permission is denied.
58309        createErrorNotice((0,external_wp_i18n_namespaceObject.__)('Unable to paste styles. Please allow browser clipboard permissions before continuing.'), {
58310          type: 'snackbar'
58311        });
58312        return;
58313      }
58314  
58315      // Abort if the copied text is empty or doesn't look like serialized blocks.
58316      if (!html || !hasSerializedBlocks(html)) {
58317        createWarningNotice((0,external_wp_i18n_namespaceObject.__)("Unable to paste styles. Block styles couldn't be found within the copied content."), {
58318          type: 'snackbar'
58319        });
58320        return;
58321      }
58322      const copiedBlocks = (0,external_wp_blocks_namespaceObject.parse)(html);
58323      if (copiedBlocks.length === 1) {
58324        // Apply styles of the block to all the target blocks.
58325        registry.batch(() => {
58326          recursivelyUpdateBlockAttributes(targetBlocks, targetBlocks.map(() => copiedBlocks[0]), updateBlockAttributes);
58327        });
58328      } else {
58329        registry.batch(() => {
58330          recursivelyUpdateBlockAttributes(targetBlocks, copiedBlocks, updateBlockAttributes);
58331        });
58332      }
58333      if (targetBlocks.length === 1) {
58334        const title = (0,external_wp_blocks_namespaceObject.getBlockType)(targetBlocks[0].name)?.title;
58335        createSuccessNotice((0,external_wp_i18n_namespaceObject.sprintf)(
58336        // Translators: Name of the block being pasted, e.g. "Paragraph".
58337        (0,external_wp_i18n_namespaceObject.__)('Pasted styles to %s.'), title), {
58338          type: 'snackbar'
58339        });
58340      } else {
58341        createSuccessNotice((0,external_wp_i18n_namespaceObject.sprintf)(
58342        // Translators: The number of the blocks.
58343        (0,external_wp_i18n_namespaceObject.__)('Pasted styles to %d blocks.'), targetBlocks.length), {
58344          type: 'snackbar'
58345        });
58346      }
58347    }, [registry.batch, updateBlockAttributes, createSuccessNotice, createWarningNotice, createErrorNotice]);
58348  }
58349  
58350  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-actions/index.js
58351  /**
58352   * WordPress dependencies
58353   */
58354  
58355  
58356  
58357  /**
58358   * Internal dependencies
58359   */
58360  
58361  
58362  function BlockActions({
58363    clientIds,
58364    children,
58365    __experimentalUpdateSelection: updateSelection
58366  }) {
58367    const {
58368      getDefaultBlockName,
58369      getGroupingBlockName
58370    } = (0,external_wp_data_namespaceObject.useSelect)(external_wp_blocks_namespaceObject.store);
58371    const selected = (0,external_wp_data_namespaceObject.useSelect)(select => {
58372      const {
58373        canInsertBlockType,
58374        getBlockRootClientId,
58375        getBlocksByClientId,
58376        getDirectInsertBlock,
58377        canRemoveBlocks
58378      } = select(store);
58379      const blocks = getBlocksByClientId(clientIds);
58380      const rootClientId = getBlockRootClientId(clientIds[0]);
58381      const canInsertDefaultBlock = canInsertBlockType(getDefaultBlockName(), rootClientId);
58382      const directInsertBlock = rootClientId ? getDirectInsertBlock(rootClientId) : null;
58383      return {
58384        canRemove: canRemoveBlocks(clientIds),
58385        canInsertBlock: canInsertDefaultBlock || !!directInsertBlock,
58386        canCopyStyles: blocks.every(block => {
58387          return !!block && ((0,external_wp_blocks_namespaceObject.hasBlockSupport)(block.name, 'color') || (0,external_wp_blocks_namespaceObject.hasBlockSupport)(block.name, 'typography'));
58388        }),
58389        canDuplicate: blocks.every(block => {
58390          return !!block && (0,external_wp_blocks_namespaceObject.hasBlockSupport)(block.name, 'multiple', true) && canInsertBlockType(block.name, rootClientId);
58391        })
58392      };
58393    }, [clientIds, getDefaultBlockName]);
58394    const {
58395      getBlocksByClientId,
58396      getBlocks
58397    } = (0,external_wp_data_namespaceObject.useSelect)(store);
58398    const {
58399      canRemove,
58400      canInsertBlock,
58401      canCopyStyles,
58402      canDuplicate
58403    } = selected;
58404    const {
58405      removeBlocks,
58406      replaceBlocks,
58407      duplicateBlocks,
58408      insertAfterBlock,
58409      insertBeforeBlock,
58410      flashBlock
58411    } = (0,external_wp_data_namespaceObject.useDispatch)(store);
58412    const pasteStyles = usePasteStyles();
58413    return children({
58414      canCopyStyles,
58415      canDuplicate,
58416      canInsertBlock,
58417      canRemove,
58418      onDuplicate() {
58419        return duplicateBlocks(clientIds, updateSelection);
58420      },
58421      onRemove() {
58422        return removeBlocks(clientIds, updateSelection);
58423      },
58424      onInsertBefore() {
58425        insertBeforeBlock(clientIds[0]);
58426      },
58427      onInsertAfter() {
58428        insertAfterBlock(clientIds[clientIds.length - 1]);
58429      },
58430      onGroup() {
58431        if (!clientIds.length) {
58432          return;
58433        }
58434        const groupingBlockName = getGroupingBlockName();
58435  
58436        // Activate the `transform` on `core/group` which does the conversion.
58437        const newBlocks = (0,external_wp_blocks_namespaceObject.switchToBlockType)(getBlocksByClientId(clientIds), groupingBlockName);
58438        if (!newBlocks) {
58439          return;
58440        }
58441        replaceBlocks(clientIds, newBlocks);
58442      },
58443      onUngroup() {
58444        if (!clientIds.length) {
58445          return;
58446        }
58447        const innerBlocks = getBlocks(clientIds[0]);
58448        if (!innerBlocks.length) {
58449          return;
58450        }
58451        replaceBlocks(clientIds, innerBlocks);
58452      },
58453      onCopy() {
58454        if (clientIds.length === 1) {
58455          flashBlock(clientIds[0]);
58456        }
58457      },
58458      async onPasteStyles() {
58459        await pasteStyles(getBlocksByClientId(clientIds));
58460      }
58461    });
58462  }
58463  
58464  ;// ./node_modules/@wordpress/block-editor/build-module/components/collab/block-comment-icon-slot.js
58465  /**
58466   * WordPress dependencies
58467   */
58468  
58469  const CommentIconSlotFill = (0,external_wp_components_namespaceObject.createSlotFill)(Symbol('CommentIconSlotFill'));
58470  /* harmony default export */ const block_comment_icon_slot = (CommentIconSlotFill);
58471  
58472  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-settings-menu/block-html-convert-button.js
58473  /**
58474   * WordPress dependencies
58475   */
58476  
58477  
58478  
58479  
58480  
58481  /**
58482   * Internal dependencies
58483   */
58484  
58485  
58486  function BlockHTMLConvertButton({
58487    clientId
58488  }) {
58489    const block = (0,external_wp_data_namespaceObject.useSelect)(select => select(store).getBlock(clientId), [clientId]);
58490    const {
58491      replaceBlocks
58492    } = (0,external_wp_data_namespaceObject.useDispatch)(store);
58493    if (!block || block.name !== 'core/html') {
58494      return null;
58495    }
58496    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, {
58497      onClick: () => replaceBlocks(clientId, (0,external_wp_blocks_namespaceObject.rawHandler)({
58498        HTML: (0,external_wp_blocks_namespaceObject.getBlockContent)(block)
58499      })),
58500      children: (0,external_wp_i18n_namespaceObject.__)('Convert to Blocks')
58501    });
58502  }
58503  /* harmony default export */ const block_html_convert_button = (BlockHTMLConvertButton);
58504  
58505  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-settings-menu/block-settings-menu-first-item.js
58506  /**
58507   * WordPress dependencies
58508   */
58509  
58510  const {
58511    Fill: __unstableBlockSettingsMenuFirstItem,
58512    Slot: block_settings_menu_first_item_Slot
58513  } = (0,external_wp_components_namespaceObject.createSlotFill)('__unstableBlockSettingsMenuFirstItem');
58514  __unstableBlockSettingsMenuFirstItem.Slot = block_settings_menu_first_item_Slot;
58515  /* harmony default export */ const block_settings_menu_first_item = (__unstableBlockSettingsMenuFirstItem);
58516  
58517  ;// ./node_modules/@wordpress/block-editor/build-module/components/convert-to-group-buttons/use-convert-to-group-button-props.js
58518  /**
58519   * WordPress dependencies
58520   */
58521  
58522  
58523  
58524  /**
58525   * Internal dependencies
58526   */
58527  
58528  
58529  /**
58530   * Contains the properties `ConvertToGroupButton` component needs.
58531   *
58532   * @typedef {Object} ConvertToGroupButtonProps
58533   * @property {string[]}  clientIds         An array of the selected client ids.
58534   * @property {boolean}   isGroupable       Indicates if the selected blocks can be grouped.
58535   * @property {boolean}   isUngroupable     Indicates if the selected blocks can be ungrouped.
58536   * @property {WPBlock[]} blocksSelection   An array of the selected blocks.
58537   * @property {string}    groupingBlockName The name of block used for handling grouping interactions.
58538   */
58539  
58540  /**
58541   * Returns the properties `ConvertToGroupButton` component needs to work properly.
58542   * It is used in `BlockSettingsMenuControls` to know if `ConvertToGroupButton`
58543   * should be rendered, to avoid ending up with an empty MenuGroup.
58544   *
58545   * @param {?string[]} selectedClientIds An optional array of clientIds to group. The selected blocks
58546   *                                      from the block editor store are used if this is not provided.
58547   *
58548   * @return {ConvertToGroupButtonProps} Returns the properties needed by `ConvertToGroupButton`.
58549   */
58550  function useConvertToGroupButtonProps(selectedClientIds) {
58551    return (0,external_wp_data_namespaceObject.useSelect)(select => {
58552      const {
58553        getBlocksByClientId,
58554        getSelectedBlockClientIds,
58555        isUngroupable,
58556        isGroupable
58557      } = select(store);
58558      const {
58559        getGroupingBlockName,
58560        getBlockType
58561      } = select(external_wp_blocks_namespaceObject.store);
58562      const clientIds = selectedClientIds?.length ? selectedClientIds : getSelectedBlockClientIds();
58563      const blocksSelection = getBlocksByClientId(clientIds);
58564      const [firstSelectedBlock] = blocksSelection;
58565      const _isUngroupable = clientIds.length === 1 && isUngroupable(clientIds[0]);
58566      return {
58567        clientIds,
58568        isGroupable: isGroupable(clientIds),
58569        isUngroupable: _isUngroupable,
58570        blocksSelection,
58571        groupingBlockName: getGroupingBlockName(),
58572        onUngroup: _isUngroupable && getBlockType(firstSelectedBlock.name)?.transforms?.ungroup
58573      };
58574    }, [selectedClientIds]);
58575  }
58576  
58577  ;// ./node_modules/@wordpress/block-editor/build-module/components/convert-to-group-buttons/index.js
58578  /**
58579   * WordPress dependencies
58580   */
58581  
58582  
58583  
58584  
58585  
58586  
58587  /**
58588   * Internal dependencies
58589   */
58590  
58591  
58592  
58593  
58594  function ConvertToGroupButton({
58595    clientIds,
58596    isGroupable,
58597    isUngroupable,
58598    onUngroup,
58599    blocksSelection,
58600    groupingBlockName,
58601    onClose = () => {}
58602  }) {
58603    const {
58604      getSelectedBlockClientIds
58605    } = (0,external_wp_data_namespaceObject.useSelect)(store);
58606    const {
58607      replaceBlocks
58608    } = (0,external_wp_data_namespaceObject.useDispatch)(store);
58609    const onConvertToGroup = () => {
58610      // Activate the `transform` on the Grouping Block which does the conversion.
58611      const newBlocks = (0,external_wp_blocks_namespaceObject.switchToBlockType)(blocksSelection, groupingBlockName);
58612      if (newBlocks) {
58613        replaceBlocks(clientIds, newBlocks);
58614      }
58615    };
58616    const onConvertFromGroup = () => {
58617      let innerBlocks = blocksSelection[0].innerBlocks;
58618      if (!innerBlocks.length) {
58619        return;
58620      }
58621      if (onUngroup) {
58622        innerBlocks = onUngroup(blocksSelection[0].attributes, blocksSelection[0].innerBlocks);
58623      }
58624      replaceBlocks(clientIds, innerBlocks);
58625    };
58626    if (!isGroupable && !isUngroupable) {
58627      return null;
58628    }
58629    const selectedBlockClientIds = getSelectedBlockClientIds();
58630    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
58631      children: [isGroupable && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, {
58632        shortcut: selectedBlockClientIds.length > 1 ? external_wp_keycodes_namespaceObject.displayShortcut.primary('g') : undefined,
58633        onClick: () => {
58634          onConvertToGroup();
58635          onClose();
58636        },
58637        children: (0,external_wp_i18n_namespaceObject._x)('Group', 'verb')
58638      }), isUngroupable && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, {
58639        onClick: () => {
58640          onConvertFromGroup();
58641          onClose();
58642        },
58643        children: (0,external_wp_i18n_namespaceObject._x)('Ungroup', 'Ungrouping blocks from within a grouping block back into individual blocks within the Editor')
58644      })]
58645    });
58646  }
58647  
58648  
58649  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-lock/use-block-lock.js
58650  /**
58651   * WordPress dependencies
58652   */
58653  
58654  
58655  /**
58656   * Internal dependencies
58657   */
58658  
58659  
58660  /**
58661   * Return details about the block lock status.
58662   *
58663   * @param {string} clientId The block client Id.
58664   *
58665   * @return {Object} Block lock status
58666   */
58667  function useBlockLock(clientId) {
58668    return (0,external_wp_data_namespaceObject.useSelect)(select => {
58669      const {
58670        canEditBlock,
58671        canMoveBlock,
58672        canRemoveBlock,
58673        canLockBlockType,
58674        getBlockName,
58675        getTemplateLock
58676      } = select(store);
58677      const canEdit = canEditBlock(clientId);
58678      const canMove = canMoveBlock(clientId);
58679      const canRemove = canRemoveBlock(clientId);
58680      return {
58681        canEdit,
58682        canMove,
58683        canRemove,
58684        canLock: canLockBlockType(getBlockName(clientId)),
58685        isContentLocked: getTemplateLock(clientId) === 'contentOnly',
58686        isLocked: !canEdit || !canMove || !canRemove
58687      };
58688    }, [clientId]);
58689  }
58690  
58691  ;// ./node_modules/@wordpress/icons/build-module/library/unlock.js
58692  /**
58693   * WordPress dependencies
58694   */
58695  
58696  
58697  const unlock_unlock = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
58698    viewBox: "0 0 24 24",
58699    xmlns: "http://www.w3.org/2000/svg",
58700    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
58701      d: "M17 10h-1.2V7c0-2.1-1.7-3.8-3.8-3.8-2.1 0-3.8 1.7-3.8 3.8h1.5c0-1.2 1-2.2 2.2-2.2s2.2 1 2.2 2.2v3H7c-.6 0-1 .4-1 1v8c0 .6.4 1 1 1h10c.6 0 1-.4 1-1v-8c0-.6-.4-1-1-1z"
58702    })
58703  });
58704  /* harmony default export */ const library_unlock = (unlock_unlock);
58705  
58706  ;// ./node_modules/@wordpress/icons/build-module/library/lock-outline.js
58707  /**
58708   * WordPress dependencies
58709   */
58710  
58711  
58712  const lockOutline = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
58713    viewBox: "0 0 24 24",
58714    xmlns: "http://www.w3.org/2000/svg",
58715    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
58716      d: "M17 10h-1.2V7c0-2.1-1.7-3.8-3.8-3.8-2.1 0-3.8 1.7-3.8 3.8v3H7c-.6 0-1 .4-1 1v8c0 .6.4 1 1 1h10c.6 0 1-.4 1-1v-8c0-.6-.4-1-1-1zM9.8 7c0-1.2 1-2.2 2.2-2.2 1.2 0 2.2 1 2.2 2.2v3H9.8V7zm6.7 11.5h-9v-7h9v7z"
58717    })
58718  });
58719  /* harmony default export */ const lock_outline = (lockOutline);
58720  
58721  ;// ./node_modules/@wordpress/icons/build-module/library/lock.js
58722  /**
58723   * WordPress dependencies
58724   */
58725  
58726  
58727  const lock_lock = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
58728    viewBox: "0 0 24 24",
58729    xmlns: "http://www.w3.org/2000/svg",
58730    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
58731      d: "M17 10h-1.2V7c0-2.1-1.7-3.8-3.8-3.8-2.1 0-3.8 1.7-3.8 3.8v3H7c-.6 0-1 .4-1 1v8c0 .6.4 1 1 1h10c.6 0 1-.4 1-1v-8c0-.6-.4-1-1-1zm-2.8 0H9.8V7c0-1.2 1-2.2 2.2-2.2s2.2 1 2.2 2.2v3z"
58732    })
58733  });
58734  /* harmony default export */ const library_lock = (lock_lock);
58735  
58736  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-lock/modal.js
58737  /**
58738   * WordPress dependencies
58739   */
58740  
58741  
58742  
58743  
58744  
58745  
58746  
58747  /**
58748   * Internal dependencies
58749   */
58750  
58751  
58752  
58753  
58754  // Entity based blocks which allow edit locking
58755  
58756  const ALLOWS_EDIT_LOCKING = ['core/navigation'];
58757  function getTemplateLockValue(lock) {
58758    // Prevents all operations.
58759    if (lock.remove && lock.move) {
58760      return 'all';
58761    }
58762  
58763    // Prevents inserting or removing blocks, but allows moving existing blocks.
58764    if (lock.remove && !lock.move) {
58765      return 'insert';
58766    }
58767    return false;
58768  }
58769  function BlockLockModal({
58770    clientId,
58771    onClose
58772  }) {
58773    const [lock, setLock] = (0,external_wp_element_namespaceObject.useState)({
58774      move: false,
58775      remove: false
58776    });
58777    const {
58778      canEdit,
58779      canMove,
58780      canRemove
58781    } = useBlockLock(clientId);
58782    const {
58783      allowsEditLocking,
58784      templateLock,
58785      hasTemplateLock
58786    } = (0,external_wp_data_namespaceObject.useSelect)(select => {
58787      const {
58788        getBlockName,
58789        getBlockAttributes
58790      } = select(store);
58791      const blockName = getBlockName(clientId);
58792      const blockType = (0,external_wp_blocks_namespaceObject.getBlockType)(blockName);
58793      return {
58794        allowsEditLocking: ALLOWS_EDIT_LOCKING.includes(blockName),
58795        templateLock: getBlockAttributes(clientId)?.templateLock,
58796        hasTemplateLock: !!blockType?.attributes?.templateLock
58797      };
58798    }, [clientId]);
58799    const [applyTemplateLock, setApplyTemplateLock] = (0,external_wp_element_namespaceObject.useState)(!!templateLock);
58800    const {
58801      updateBlockAttributes
58802    } = (0,external_wp_data_namespaceObject.useDispatch)(store);
58803    const blockInformation = useBlockDisplayInformation(clientId);
58804    (0,external_wp_element_namespaceObject.useEffect)(() => {
58805      setLock({
58806        move: !canMove,
58807        remove: !canRemove,
58808        ...(allowsEditLocking ? {
58809          edit: !canEdit
58810        } : {})
58811      });
58812    }, [canEdit, canMove, canRemove, allowsEditLocking]);
58813    const isAllChecked = Object.values(lock).every(Boolean);
58814    const isMixed = Object.values(lock).some(Boolean) && !isAllChecked;
58815    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Modal, {
58816      title: (0,external_wp_i18n_namespaceObject.sprintf)(/* translators: %s: Name of the block. */
58817      (0,external_wp_i18n_namespaceObject.__)('Lock %s'), blockInformation.title),
58818      overlayClassName: "block-editor-block-lock-modal",
58819      onRequestClose: onClose,
58820      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("form", {
58821        onSubmit: event => {
58822          event.preventDefault();
58823          updateBlockAttributes([clientId], {
58824            lock,
58825            templateLock: applyTemplateLock ? getTemplateLockValue(lock) : undefined
58826          });
58827          onClose();
58828        },
58829        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("fieldset", {
58830          className: "block-editor-block-lock-modal__options",
58831          children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("legend", {
58832            children: (0,external_wp_i18n_namespaceObject.__)('Select the features you want to lock')
58833          }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("ul", {
58834            role: "list",
58835            className: "block-editor-block-lock-modal__checklist",
58836            children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("li", {
58837              children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.CheckboxControl, {
58838                __nextHasNoMarginBottom: true,
58839                className: "block-editor-block-lock-modal__options-all",
58840                label: (0,external_wp_i18n_namespaceObject.__)('Lock all'),
58841                checked: isAllChecked,
58842                indeterminate: isMixed,
58843                onChange: newValue => setLock({
58844                  move: newValue,
58845                  remove: newValue,
58846                  ...(allowsEditLocking ? {
58847                    edit: newValue
58848                  } : {})
58849                })
58850              }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("ul", {
58851                role: "list",
58852                className: "block-editor-block-lock-modal__checklist",
58853                children: [allowsEditLocking && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("li", {
58854                  className: "block-editor-block-lock-modal__checklist-item",
58855                  children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.CheckboxControl, {
58856                    __nextHasNoMarginBottom: true,
58857                    label: (0,external_wp_i18n_namespaceObject.__)('Lock editing'),
58858                    checked: !!lock.edit,
58859                    onChange: edit => setLock(prevLock => ({
58860                      ...prevLock,
58861                      edit
58862                    }))
58863                  }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Icon, {
58864                    className: "block-editor-block-lock-modal__lock-icon",
58865                    icon: lock.edit ? library_lock : library_unlock
58866                  })]
58867                }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("li", {
58868                  className: "block-editor-block-lock-modal__checklist-item",
58869                  children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.CheckboxControl, {
58870                    __nextHasNoMarginBottom: true,
58871                    label: (0,external_wp_i18n_namespaceObject.__)('Lock movement'),
58872                    checked: lock.move,
58873                    onChange: move => setLock(prevLock => ({
58874                      ...prevLock,
58875                      move
58876                    }))
58877                  }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Icon, {
58878                    className: "block-editor-block-lock-modal__lock-icon",
58879                    icon: lock.move ? library_lock : library_unlock
58880                  })]
58881                }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("li", {
58882                  className: "block-editor-block-lock-modal__checklist-item",
58883                  children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.CheckboxControl, {
58884                    __nextHasNoMarginBottom: true,
58885                    label: (0,external_wp_i18n_namespaceObject.__)('Lock removal'),
58886                    checked: lock.remove,
58887                    onChange: remove => setLock(prevLock => ({
58888                      ...prevLock,
58889                      remove
58890                    }))
58891                  }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Icon, {
58892                    className: "block-editor-block-lock-modal__lock-icon",
58893                    icon: lock.remove ? library_lock : library_unlock
58894                  })]
58895                })]
58896              })]
58897            })
58898          }), hasTemplateLock && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToggleControl, {
58899            __nextHasNoMarginBottom: true,
58900            className: "block-editor-block-lock-modal__template-lock",
58901            label: (0,external_wp_i18n_namespaceObject.__)('Apply to all blocks inside'),
58902            checked: applyTemplateLock,
58903            disabled: lock.move && !lock.remove,
58904            onChange: () => setApplyTemplateLock(!applyTemplateLock)
58905          })]
58906        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.Flex, {
58907          className: "block-editor-block-lock-modal__actions",
58908          justify: "flex-end",
58909          expanded: false,
58910          children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FlexItem, {
58911            children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
58912              variant: "tertiary",
58913              onClick: onClose,
58914              __next40pxDefaultSize: true,
58915              children: (0,external_wp_i18n_namespaceObject.__)('Cancel')
58916            })
58917          }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FlexItem, {
58918            children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
58919              variant: "primary",
58920              type: "submit",
58921              __next40pxDefaultSize: true,
58922              children: (0,external_wp_i18n_namespaceObject.__)('Apply')
58923            })
58924          })]
58925        })]
58926      })
58927    });
58928  }
58929  
58930  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-lock/menu-item.js
58931  /**
58932   * WordPress dependencies
58933   */
58934  
58935  
58936  
58937  
58938  
58939  /**
58940   * Internal dependencies
58941   */
58942  
58943  
58944  
58945  function BlockLockMenuItem({
58946    clientId
58947  }) {
58948    const {
58949      canLock,
58950      isLocked
58951    } = useBlockLock(clientId);
58952    const [isModalOpen, toggleModal] = (0,external_wp_element_namespaceObject.useReducer)(isActive => !isActive, false);
58953    if (!canLock) {
58954      return null;
58955    }
58956    const label = isLocked ? (0,external_wp_i18n_namespaceObject.__)('Unlock') : (0,external_wp_i18n_namespaceObject.__)('Lock');
58957    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
58958      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, {
58959        icon: isLocked ? library_unlock : lock_outline,
58960        onClick: toggleModal,
58961        "aria-expanded": isModalOpen,
58962        "aria-haspopup": "dialog",
58963        children: label
58964      }), isModalOpen && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockLockModal, {
58965        clientId: clientId,
58966        onClose: toggleModal
58967      })]
58968    });
58969  }
58970  
58971  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-settings-menu/block-mode-toggle.js
58972  /**
58973   * WordPress dependencies
58974   */
58975  
58976  
58977  
58978  
58979  
58980  /**
58981   * Internal dependencies
58982   */
58983  
58984  
58985  const block_mode_toggle_noop = () => {};
58986  function BlockModeToggle({
58987    clientId,
58988    onToggle = block_mode_toggle_noop
58989  }) {
58990    const {
58991      blockType,
58992      mode,
58993      isCodeEditingEnabled
58994    } = (0,external_wp_data_namespaceObject.useSelect)(select => {
58995      const {
58996        getBlock,
58997        getBlockMode,
58998        getSettings
58999      } = select(store);
59000      const block = getBlock(clientId);
59001      return {
59002        mode: getBlockMode(clientId),
59003        blockType: block ? (0,external_wp_blocks_namespaceObject.getBlockType)(block.name) : null,
59004        isCodeEditingEnabled: getSettings().codeEditingEnabled
59005      };
59006    }, [clientId]);
59007    const {
59008      toggleBlockMode
59009    } = (0,external_wp_data_namespaceObject.useDispatch)(store);
59010    if (!blockType || !(0,external_wp_blocks_namespaceObject.hasBlockSupport)(blockType, 'html', true) || !isCodeEditingEnabled) {
59011      return null;
59012    }
59013    const label = mode === 'visual' ? (0,external_wp_i18n_namespaceObject.__)('Edit as HTML') : (0,external_wp_i18n_namespaceObject.__)('Edit visually');
59014    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, {
59015      onClick: () => {
59016        toggleBlockMode(clientId);
59017        onToggle();
59018      },
59019      children: label
59020    });
59021  }
59022  
59023  ;// ./node_modules/@wordpress/block-editor/build-module/components/content-lock/modify-content-lock-menu-item.js
59024  /**
59025   * WordPress dependencies
59026   */
59027  
59028  
59029  
59030  
59031  /**
59032   * Internal dependencies
59033   */
59034  
59035  
59036  
59037  // The implementation of content locking is mainly in this file, although the mechanism
59038  // to stop temporarily editing as blocks when an outside block is selected is on component StopEditingAsBlocksOnOutsideSelect
59039  // at block-editor/src/components/block-list/index.js.
59040  // Besides the components on this file and the file referenced above the implementation
59041  // also includes artifacts on the store (actions, reducers, and selector).
59042  
59043  function ModifyContentLockMenuItem({
59044    clientId,
59045    onClose
59046  }) {
59047    const {
59048      templateLock,
59049      isLockedByParent,
59050      isEditingAsBlocks
59051    } = (0,external_wp_data_namespaceObject.useSelect)(select => {
59052      const {
59053        getContentLockingParent,
59054        getTemplateLock,
59055        getTemporarilyEditingAsBlocks
59056      } = unlock(select(store));
59057      return {
59058        templateLock: getTemplateLock(clientId),
59059        isLockedByParent: !!getContentLockingParent(clientId),
59060        isEditingAsBlocks: getTemporarilyEditingAsBlocks() === clientId
59061      };
59062    }, [clientId]);
59063    const blockEditorActions = (0,external_wp_data_namespaceObject.useDispatch)(store);
59064    const isContentLocked = !isLockedByParent && templateLock === 'contentOnly';
59065    if (!isContentLocked && !isEditingAsBlocks) {
59066      return null;
59067    }
59068    const {
59069      modifyContentLockBlock
59070    } = unlock(blockEditorActions);
59071    const showStartEditingAsBlocks = !isEditingAsBlocks && isContentLocked;
59072    return showStartEditingAsBlocks && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, {
59073      onClick: () => {
59074        modifyContentLockBlock(clientId);
59075        onClose();
59076      },
59077      children: (0,external_wp_i18n_namespaceObject._x)('Modify', 'Unlock content locked blocks')
59078    });
59079  }
59080  
59081  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-rename/use-block-rename.js
59082  /**
59083   * WordPress dependencies
59084   */
59085  
59086  function useBlockRename(name) {
59087    return {
59088      canRename: (0,external_wp_blocks_namespaceObject.getBlockSupport)(name, 'renaming', true)
59089    };
59090  }
59091  
59092  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-rename/is-empty-string.js
59093  function isEmptyString(testString) {
59094    return testString?.trim()?.length === 0;
59095  }
59096  
59097  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-rename/modal.js
59098  /**
59099   * WordPress dependencies
59100   */
59101  
59102  
59103  
59104  
59105  
59106  
59107  /**
59108   * Internal dependencies
59109   */
59110  
59111  
59112  
59113  
59114  function BlockRenameModal({
59115    clientId,
59116    onClose
59117  }) {
59118    const [editedBlockName, setEditedBlockName] = (0,external_wp_element_namespaceObject.useState)();
59119    const blockInformation = useBlockDisplayInformation(clientId);
59120    const {
59121      metadata
59122    } = (0,external_wp_data_namespaceObject.useSelect)(select => {
59123      const {
59124        getBlockAttributes
59125      } = select(store);
59126      return {
59127        metadata: getBlockAttributes(clientId)?.metadata
59128      };
59129    }, [clientId]);
59130    const {
59131      updateBlockAttributes
59132    } = (0,external_wp_data_namespaceObject.useDispatch)(store);
59133    const blockName = metadata?.name || '';
59134    const originalBlockName = blockInformation?.title;
59135    // Pattern Overrides is a WordPress-only feature but it also uses the Block Binding API.
59136    // Ideally this should not be inside the block editor package, but we keep it here for simplicity.
59137    const hasOverridesWarning = !!blockName && !!metadata?.bindings && Object.values(metadata.bindings).some(binding => binding.source === 'core/pattern-overrides');
59138    const nameHasChanged = editedBlockName !== undefined && editedBlockName !== blockName;
59139    const nameIsOriginal = editedBlockName === originalBlockName;
59140    const nameIsEmpty = isEmptyString(editedBlockName);
59141    const isNameValid = nameHasChanged || nameIsOriginal;
59142    const autoSelectInputText = event => event.target.select();
59143    const handleSubmit = () => {
59144      const newName = nameIsOriginal || nameIsEmpty ? undefined : editedBlockName;
59145      const message = nameIsOriginal || nameIsEmpty ? (0,external_wp_i18n_namespaceObject.sprintf)(/* translators: %s: new name/label for the block */
59146      (0,external_wp_i18n_namespaceObject.__)('Block name reset to: "%s".'), editedBlockName) : (0,external_wp_i18n_namespaceObject.sprintf)(/* translators: %s: new name/label for the block */
59147      (0,external_wp_i18n_namespaceObject.__)('Block name changed to: "%s".'), editedBlockName);
59148  
59149      // Must be assertive to immediately announce change.
59150      (0,external_wp_a11y_namespaceObject.speak)(message, 'assertive');
59151      updateBlockAttributes([clientId], {
59152        metadata: {
59153          ...metadata,
59154          name: newName
59155        }
59156      });
59157  
59158      // Immediate close avoids ability to hit save multiple times.
59159      onClose();
59160    };
59161    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Modal, {
59162      title: (0,external_wp_i18n_namespaceObject.__)('Rename'),
59163      onRequestClose: onClose,
59164      overlayClassName: "block-editor-block-rename-modal",
59165      focusOnMount: "firstContentElement",
59166      size: "small",
59167      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("form", {
59168        onSubmit: e => {
59169          e.preventDefault();
59170          if (!isNameValid) {
59171            return;
59172          }
59173          handleSubmit();
59174        },
59175        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalVStack, {
59176          spacing: "3",
59177          children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.TextControl, {
59178            __nextHasNoMarginBottom: true,
59179            __next40pxDefaultSize: true,
59180            value: editedBlockName !== null && editedBlockName !== void 0 ? editedBlockName : blockName,
59181            label: (0,external_wp_i18n_namespaceObject.__)('Name'),
59182            help: hasOverridesWarning ? (0,external_wp_i18n_namespaceObject.__)('This block allows overrides. Changing the name can cause problems with content entered into instances of this pattern.') : undefined,
59183            placeholder: originalBlockName,
59184            onChange: setEditedBlockName,
59185            onFocus: autoSelectInputText
59186          }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalHStack, {
59187            justify: "right",
59188            children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
59189              __next40pxDefaultSize: true,
59190              variant: "tertiary",
59191              onClick: onClose,
59192              children: (0,external_wp_i18n_namespaceObject.__)('Cancel')
59193            }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
59194              __next40pxDefaultSize: true,
59195              accessibleWhenDisabled: true,
59196              disabled: !isNameValid,
59197              variant: "primary",
59198              type: "submit",
59199              children: (0,external_wp_i18n_namespaceObject.__)('Save')
59200            })]
59201          })]
59202        })
59203      })
59204    });
59205  }
59206  
59207  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-rename/rename-control.js
59208  /**
59209   * WordPress dependencies
59210   */
59211  
59212  
59213  
59214  
59215  /**
59216   * Internal dependencies
59217   */
59218  
59219  
59220  function BlockRenameControl({
59221    clientId
59222  }) {
59223    const [renamingBlock, setRenamingBlock] = (0,external_wp_element_namespaceObject.useState)(false);
59224    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
59225      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, {
59226        onClick: () => {
59227          setRenamingBlock(true);
59228        },
59229        "aria-expanded": renamingBlock,
59230        "aria-haspopup": "dialog",
59231        children: (0,external_wp_i18n_namespaceObject.__)('Rename')
59232      }), renamingBlock && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockRenameModal, {
59233        clientId: clientId,
59234        onClose: () => setRenamingBlock(false)
59235      })]
59236    });
59237  }
59238  
59239  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-settings-menu-controls/index.js
59240  /**
59241   * WordPress dependencies
59242   */
59243  
59244  
59245  
59246  /**
59247   * Internal dependencies
59248   */
59249  
59250  
59251  
59252  
59253  
59254  
59255  
59256  const {
59257    Fill,
59258    Slot: block_settings_menu_controls_Slot
59259  } = (0,external_wp_components_namespaceObject.createSlotFill)('BlockSettingsMenuControls');
59260  const BlockSettingsMenuControlsSlot = ({
59261    fillProps,
59262    clientIds = null
59263  }) => {
59264    const {
59265      selectedBlocks,
59266      selectedClientIds,
59267      isContentOnly
59268    } = (0,external_wp_data_namespaceObject.useSelect)(select => {
59269      const {
59270        getBlockNamesByClientId,
59271        getSelectedBlockClientIds,
59272        getBlockEditingMode
59273      } = select(store);
59274      const ids = clientIds !== null ? clientIds : getSelectedBlockClientIds();
59275      return {
59276        selectedBlocks: getBlockNamesByClientId(ids),
59277        selectedClientIds: ids,
59278        isContentOnly: getBlockEditingMode(ids[0]) === 'contentOnly'
59279      };
59280    }, [clientIds]);
59281    const {
59282      canLock
59283    } = useBlockLock(selectedClientIds[0]);
59284    const {
59285      canRename
59286    } = useBlockRename(selectedBlocks[0]);
59287    const showLockButton = selectedClientIds.length === 1 && canLock && !isContentOnly;
59288    const showRenameButton = selectedClientIds.length === 1 && canRename && !isContentOnly;
59289  
59290    // Check if current selection of blocks is Groupable or Ungroupable
59291    // and pass this props down to ConvertToGroupButton.
59292    const convertToGroupButtonProps = useConvertToGroupButtonProps(selectedClientIds);
59293    const {
59294      isGroupable,
59295      isUngroupable
59296    } = convertToGroupButtonProps;
59297    const showConvertToGroupButton = (isGroupable || isUngroupable) && !isContentOnly;
59298    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_settings_menu_controls_Slot, {
59299      fillProps: {
59300        ...fillProps,
59301        selectedBlocks,
59302        selectedClientIds
59303      },
59304      children: fills => {
59305        if (!fills?.length > 0 && !showConvertToGroupButton && !showLockButton) {
59306          return null;
59307        }
59308        return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.MenuGroup, {
59309          children: [showConvertToGroupButton && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ConvertToGroupButton, {
59310            ...convertToGroupButtonProps,
59311            onClose: fillProps?.onClose
59312          }), showLockButton && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockLockMenuItem, {
59313            clientId: selectedClientIds[0]
59314          }), showRenameButton && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockRenameControl, {
59315            clientId: selectedClientIds[0]
59316          }), fills, selectedClientIds.length === 1 && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ModifyContentLockMenuItem, {
59317            clientId: selectedClientIds[0],
59318            onClose: fillProps?.onClose
59319          }), fillProps?.count === 1 && !isContentOnly && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockModeToggle, {
59320            clientId: fillProps?.firstBlockClientId,
59321            onToggle: fillProps?.onClose
59322          })]
59323        });
59324      }
59325    });
59326  };
59327  
59328  /**
59329   * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/block-settings-menu-controls/README.md
59330   *
59331   * @param {Object} props Fill props.
59332   * @return {Element} Element.
59333   */
59334  function BlockSettingsMenuControls({
59335    ...props
59336  }) {
59337    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalStyleProvider, {
59338      document: document,
59339      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Fill, {
59340        ...props
59341      })
59342    });
59343  }
59344  BlockSettingsMenuControls.Slot = BlockSettingsMenuControlsSlot;
59345  /* harmony default export */ const block_settings_menu_controls = (BlockSettingsMenuControls);
59346  
59347  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-settings-menu/block-parent-selector-menu-item.js
59348  /**
59349   * WordPress dependencies
59350   */
59351  
59352  
59353  
59354  
59355  
59356  
59357  /**
59358   * Internal dependencies
59359   */
59360  
59361  
59362  
59363  
59364  function BlockParentSelectorMenuItem({
59365    parentClientId,
59366    parentBlockType
59367  }) {
59368    const isSmallViewport = (0,external_wp_compose_namespaceObject.useViewportMatch)('medium', '<');
59369    const {
59370      selectBlock
59371    } = (0,external_wp_data_namespaceObject.useDispatch)(store);
59372  
59373    // Allows highlighting the parent block outline when focusing or hovering
59374    // the parent block selector within the child.
59375    const menuItemRef = (0,external_wp_element_namespaceObject.useRef)();
59376    const gesturesProps = useShowHoveredOrFocusedGestures({
59377      ref: menuItemRef,
59378      highlightParent: true
59379    });
59380    if (!isSmallViewport) {
59381      return null;
59382    }
59383    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, {
59384      ...gesturesProps,
59385      ref: menuItemRef,
59386      icon: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_icon, {
59387        icon: parentBlockType.icon
59388      }),
59389      onClick: () => selectBlock(parentClientId),
59390      children: (0,external_wp_i18n_namespaceObject.sprintf)(/* translators: %s: Name of the block's parent. */
59391      (0,external_wp_i18n_namespaceObject.__)('Select parent block (%s)'), parentBlockType.title)
59392    });
59393  }
59394  
59395  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-settings-menu/block-settings-dropdown.js
59396  /**
59397   * WordPress dependencies
59398   */
59399  
59400  
59401  
59402  
59403  
59404  
59405  
59406  
59407  
59408  /**
59409   * Internal dependencies
59410   */
59411  
59412  
59413  
59414  
59415  
59416  
59417  
59418  
59419  
59420  
59421  const block_settings_dropdown_POPOVER_PROPS = {
59422    className: 'block-editor-block-settings-menu__popover',
59423    placement: 'bottom-start'
59424  };
59425  function CopyMenuItem({
59426    clientIds,
59427    onCopy,
59428    label,
59429    shortcut,
59430    eventType = 'copy',
59431    __experimentalUpdateSelection: updateSelection = false
59432  }) {
59433    const {
59434      getBlocksByClientId
59435    } = (0,external_wp_data_namespaceObject.useSelect)(store);
59436    const {
59437      removeBlocks
59438    } = (0,external_wp_data_namespaceObject.useDispatch)(store);
59439    const notifyCopy = useNotifyCopy();
59440    const ref = (0,external_wp_compose_namespaceObject.useCopyToClipboard)(() => (0,external_wp_blocks_namespaceObject.serialize)(getBlocksByClientId(clientIds)), () => {
59441      switch (eventType) {
59442        case 'copy':
59443        case 'copyStyles':
59444          onCopy();
59445          notifyCopy(eventType, clientIds);
59446          break;
59447        case 'cut':
59448          notifyCopy(eventType, clientIds);
59449          removeBlocks(clientIds, updateSelection);
59450          break;
59451        default:
59452          break;
59453      }
59454    });
59455    const copyMenuItemLabel = label ? label : (0,external_wp_i18n_namespaceObject.__)('Copy');
59456    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, {
59457      ref: ref,
59458      shortcut: shortcut,
59459      children: copyMenuItemLabel
59460    });
59461  }
59462  function BlockSettingsDropdown({
59463    block,
59464    clientIds,
59465    children,
59466    __experimentalSelectBlock,
59467    ...props
59468  }) {
59469    // Get the client id of the current block for this menu, if one is set.
59470    const currentClientId = block?.clientId;
59471    const count = clientIds.length;
59472    const firstBlockClientId = clientIds[0];
59473    const {
59474      firstParentClientId,
59475      parentBlockType,
59476      previousBlockClientId,
59477      selectedBlockClientIds,
59478      openedBlockSettingsMenu,
59479      isContentOnly
59480    } = (0,external_wp_data_namespaceObject.useSelect)(select => {
59481      const {
59482        getBlockName,
59483        getBlockRootClientId,
59484        getPreviousBlockClientId,
59485        getSelectedBlockClientIds,
59486        getBlockAttributes,
59487        getOpenedBlockSettingsMenu,
59488        getBlockEditingMode
59489      } = unlock(select(store));
59490      const {
59491        getActiveBlockVariation
59492      } = select(external_wp_blocks_namespaceObject.store);
59493      const _firstParentClientId = getBlockRootClientId(firstBlockClientId);
59494      const parentBlockName = _firstParentClientId && getBlockName(_firstParentClientId);
59495      return {
59496        firstParentClientId: _firstParentClientId,
59497        parentBlockType: _firstParentClientId && (getActiveBlockVariation(parentBlockName, getBlockAttributes(_firstParentClientId)) || (0,external_wp_blocks_namespaceObject.getBlockType)(parentBlockName)),
59498        previousBlockClientId: getPreviousBlockClientId(firstBlockClientId),
59499        selectedBlockClientIds: getSelectedBlockClientIds(),
59500        openedBlockSettingsMenu: getOpenedBlockSettingsMenu(),
59501        isContentOnly: getBlockEditingMode(firstBlockClientId) === 'contentOnly'
59502      };
59503    }, [firstBlockClientId]);
59504    const {
59505      getBlockOrder,
59506      getSelectedBlockClientIds
59507    } = (0,external_wp_data_namespaceObject.useSelect)(store);
59508    const {
59509      setOpenedBlockSettingsMenu
59510    } = unlock((0,external_wp_data_namespaceObject.useDispatch)(store));
59511    const shortcuts = (0,external_wp_data_namespaceObject.useSelect)(select => {
59512      const {
59513        getShortcutRepresentation
59514      } = select(external_wp_keyboardShortcuts_namespaceObject.store);
59515      return {
59516        copy: getShortcutRepresentation('core/block-editor/copy'),
59517        cut: getShortcutRepresentation('core/block-editor/cut'),
59518        duplicate: getShortcutRepresentation('core/block-editor/duplicate'),
59519        remove: getShortcutRepresentation('core/block-editor/remove'),
59520        insertAfter: getShortcutRepresentation('core/block-editor/insert-after'),
59521        insertBefore: getShortcutRepresentation('core/block-editor/insert-before')
59522      };
59523    }, []);
59524    const hasSelectedBlocks = selectedBlockClientIds.length > 0;
59525    async function updateSelectionAfterDuplicate(clientIdsPromise) {
59526      if (!__experimentalSelectBlock) {
59527        return;
59528      }
59529      const ids = await clientIdsPromise;
59530      if (ids && ids[0]) {
59531        __experimentalSelectBlock(ids[0], false);
59532      }
59533    }
59534    function updateSelectionAfterRemove() {
59535      if (!__experimentalSelectBlock) {
59536        return;
59537      }
59538      let blockToFocus = previousBlockClientId || firstParentClientId;
59539  
59540      // Focus the first block if there's no previous block nor parent block.
59541      if (!blockToFocus) {
59542        blockToFocus = getBlockOrder()[0];
59543      }
59544  
59545      // Only update the selection if the original selection is removed.
59546      const shouldUpdateSelection = hasSelectedBlocks && getSelectedBlockClientIds().length === 0;
59547      __experimentalSelectBlock(blockToFocus, shouldUpdateSelection);
59548    }
59549  
59550    // This can occur when the selected block (the parent)
59551    // displays child blocks within a List View.
59552    const parentBlockIsSelected = selectedBlockClientIds?.includes(firstParentClientId);
59553  
59554    // When a currentClientId is in use, treat the menu as a controlled component.
59555    // This ensures that only one block settings menu is open at a time.
59556    // This is a temporary solution to work around an issue with `onFocusOutside`
59557    // where it does not allow a dropdown to be closed if focus was never within
59558    // the dropdown to begin with. Examples include a user either CMD+Clicking or
59559    // right clicking into an inactive window.
59560    // See: https://github.com/WordPress/gutenberg/pull/54083
59561    const open = !currentClientId ? undefined : openedBlockSettingsMenu === currentClientId || false;
59562    function onToggle(localOpen) {
59563      if (localOpen && openedBlockSettingsMenu !== currentClientId) {
59564        setOpenedBlockSettingsMenu(currentClientId);
59565      } else if (!localOpen && openedBlockSettingsMenu && openedBlockSettingsMenu === currentClientId) {
59566        setOpenedBlockSettingsMenu(undefined);
59567      }
59568    }
59569    const shouldShowBlockParentMenuItem = !parentBlockIsSelected && !!firstParentClientId;
59570    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockActions, {
59571      clientIds: clientIds,
59572      __experimentalUpdateSelection: !__experimentalSelectBlock,
59573      children: ({
59574        canCopyStyles,
59575        canDuplicate,
59576        canInsertBlock,
59577        canRemove,
59578        onDuplicate,
59579        onInsertAfter,
59580        onInsertBefore,
59581        onRemove,
59582        onCopy,
59583        onPasteStyles
59584      }) => {
59585        // It is possible that some plugins register fills for this menu
59586        // even if Core doesn't render anything in the block settings menu.
59587        // in which case, we may want to render the menu anyway.
59588        // That said for now, we can start more conservative.
59589        const isEmpty = !canRemove && !canDuplicate && !canInsertBlock && isContentOnly;
59590        if (isEmpty) {
59591          return null;
59592        }
59593        return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.DropdownMenu, {
59594          icon: more_vertical,
59595          label: (0,external_wp_i18n_namespaceObject.__)('Options'),
59596          className: "block-editor-block-settings-menu",
59597          popoverProps: block_settings_dropdown_POPOVER_PROPS,
59598          open: open,
59599          onToggle: onToggle,
59600          noIcons: true,
59601          ...props,
59602          children: ({
59603            onClose
59604          }) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
59605            children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.MenuGroup, {
59606              children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_settings_menu_first_item.Slot, {
59607                fillProps: {
59608                  onClose
59609                }
59610              }), shouldShowBlockParentMenuItem && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockParentSelectorMenuItem, {
59611                parentClientId: firstParentClientId,
59612                parentBlockType: parentBlockType
59613              }), count === 1 && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_html_convert_button, {
59614                clientId: firstBlockClientId
59615              }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(CopyMenuItem, {
59616                clientIds: clientIds,
59617                onCopy: onCopy,
59618                shortcut: shortcuts.copy
59619              }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(CopyMenuItem, {
59620                clientIds: clientIds,
59621                label: (0,external_wp_i18n_namespaceObject.__)('Cut'),
59622                eventType: "cut",
59623                shortcut: shortcuts.cut,
59624                __experimentalUpdateSelection: !__experimentalSelectBlock
59625              }), canDuplicate && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, {
59626                onClick: (0,external_wp_compose_namespaceObject.pipe)(onClose, onDuplicate, updateSelectionAfterDuplicate),
59627                shortcut: shortcuts.duplicate,
59628                children: (0,external_wp_i18n_namespaceObject.__)('Duplicate')
59629              }), canInsertBlock && !isContentOnly && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
59630                children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, {
59631                  onClick: (0,external_wp_compose_namespaceObject.pipe)(onClose, onInsertBefore),
59632                  shortcut: shortcuts.insertBefore,
59633                  children: (0,external_wp_i18n_namespaceObject.__)('Add before')
59634                }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, {
59635                  onClick: (0,external_wp_compose_namespaceObject.pipe)(onClose, onInsertAfter),
59636                  shortcut: shortcuts.insertAfter,
59637                  children: (0,external_wp_i18n_namespaceObject.__)('Add after')
59638                })]
59639              }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_comment_icon_slot.Slot, {
59640                fillProps: {
59641                  onClose
59642                }
59643              })]
59644            }), canCopyStyles && !isContentOnly && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.MenuGroup, {
59645              children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(CopyMenuItem, {
59646                clientIds: clientIds,
59647                onCopy: onCopy,
59648                label: (0,external_wp_i18n_namespaceObject.__)('Copy styles'),
59649                eventType: "copyStyles"
59650              }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, {
59651                onClick: onPasteStyles,
59652                children: (0,external_wp_i18n_namespaceObject.__)('Paste styles')
59653              })]
59654            }), !isContentOnly && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_settings_menu_controls.Slot, {
59655              fillProps: {
59656                onClose,
59657                count,
59658                firstBlockClientId
59659              },
59660              clientIds: clientIds
59661            }), typeof children === 'function' ? children({
59662              onClose
59663            }) : external_wp_element_namespaceObject.Children.map(child => (0,external_wp_element_namespaceObject.cloneElement)(child, {
59664              onClose
59665            })), canRemove && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuGroup, {
59666              children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, {
59667                onClick: (0,external_wp_compose_namespaceObject.pipe)(onClose, onRemove, updateSelectionAfterRemove),
59668                shortcut: shortcuts.remove,
59669                children: (0,external_wp_i18n_namespaceObject.__)('Delete')
59670              })
59671            })]
59672          })
59673        });
59674      }
59675    });
59676  }
59677  /* harmony default export */ const block_settings_dropdown = (BlockSettingsDropdown);
59678  
59679  ;// ./node_modules/@wordpress/block-editor/build-module/components/collab/block-comment-icon-toolbar-slot.js
59680  /**
59681   * WordPress dependencies
59682   */
59683  
59684  const CommentIconToolbarSlotFill = (0,external_wp_components_namespaceObject.createSlotFill)(Symbol('CommentIconToolbarSlotFill'));
59685  /* harmony default export */ const block_comment_icon_toolbar_slot = (CommentIconToolbarSlotFill);
59686  
59687  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-settings-menu/index.js
59688  /**
59689   * WordPress dependencies
59690   */
59691  
59692  
59693  /**
59694   * Internal dependencies
59695   */
59696  
59697  
59698  
59699  function BlockSettingsMenu({
59700    clientIds,
59701    ...props
59702  }) {
59703    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.ToolbarGroup, {
59704      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_comment_icon_toolbar_slot.Slot, {}), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarItem, {
59705        children: toggleProps => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_settings_dropdown, {
59706          clientIds: clientIds,
59707          toggleProps: toggleProps,
59708          ...props
59709        })
59710      })]
59711    });
59712  }
59713  /* harmony default export */ const block_settings_menu = (BlockSettingsMenu);
59714  
59715  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-lock/toolbar.js
59716  /**
59717   * WordPress dependencies
59718   */
59719  
59720  
59721  
59722  
59723  
59724  /**
59725   * Internal dependencies
59726   */
59727  
59728  
59729  
59730  function BlockLockToolbar({
59731    clientId
59732  }) {
59733    const {
59734      canLock,
59735      isLocked
59736    } = useBlockLock(clientId);
59737    const [isModalOpen, toggleModal] = (0,external_wp_element_namespaceObject.useReducer)(isActive => !isActive, false);
59738    const hasLockButtonShownRef = (0,external_wp_element_namespaceObject.useRef)(false);
59739  
59740    // If the block lock button has been shown, we don't want to remove it
59741    // from the toolbar until the toolbar is rendered again without it.
59742    // Removing it beforehand can cause focus loss issues, such as when
59743    // unlocking the block from the modal. It needs to return focus from
59744    // whence it came, and to do that, we need to leave the button in the toolbar.
59745    (0,external_wp_element_namespaceObject.useEffect)(() => {
59746      if (isLocked) {
59747        hasLockButtonShownRef.current = true;
59748      }
59749    }, [isLocked]);
59750    if (!isLocked && !hasLockButtonShownRef.current) {
59751      return null;
59752    }
59753    let label = isLocked ? (0,external_wp_i18n_namespaceObject.__)('Unlock') : (0,external_wp_i18n_namespaceObject.__)('Lock');
59754    if (!canLock && isLocked) {
59755      label = (0,external_wp_i18n_namespaceObject.__)('Locked');
59756    }
59757    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
59758      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarGroup, {
59759        className: "block-editor-block-lock-toolbar",
59760        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarButton, {
59761          disabled: !canLock,
59762          icon: isLocked ? library_lock : library_unlock,
59763          label: label,
59764          onClick: toggleModal,
59765          "aria-expanded": isModalOpen,
59766          "aria-haspopup": "dialog"
59767        })
59768      }), isModalOpen && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockLockModal, {
59769        clientId: clientId,
59770        onClose: toggleModal
59771      })]
59772    });
59773  }
59774  
59775  ;// ./node_modules/@wordpress/icons/build-module/library/group.js
59776  /**
59777   * WordPress dependencies
59778   */
59779  
59780  
59781  const group_group = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
59782    viewBox: "0 0 24 24",
59783    xmlns: "http://www.w3.org/2000/svg",
59784    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
59785      d: "M18 4h-7c-1.1 0-2 .9-2 2v3H6c-1.1 0-2 .9-2 2v7c0 1.1.9 2 2 2h7c1.1 0 2-.9 2-2v-3h3c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2zm-4.5 14c0 .3-.2.5-.5.5H6c-.3 0-.5-.2-.5-.5v-7c0-.3.2-.5.5-.5h3V13c0 1.1.9 2 2 2h2.5v3zm0-4.5H11c-.3 0-.5-.2-.5-.5v-2.5H13c.3 0 .5.2.5.5v2.5zm5-.5c0 .3-.2.5-.5.5h-3V11c0-1.1-.9-2-2-2h-2.5V6c0-.3.2-.5.5-.5h7c.3 0 .5.2.5.5v7z"
59786    })
59787  });
59788  /* harmony default export */ const library_group = (group_group);
59789  
59790  ;// ./node_modules/@wordpress/icons/build-module/library/row.js
59791  /**
59792   * WordPress dependencies
59793   */
59794  
59795  
59796  const row = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
59797    xmlns: "http://www.w3.org/2000/svg",
59798    viewBox: "0 0 24 24",
59799    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
59800      d: "M4 6.5h5a2 2 0 0 1 2 2v7a2 2 0 0 1-2 2H4V16h5a.5.5 0 0 0 .5-.5v-7A.5.5 0 0 0 9 8H4V6.5Zm16 0h-5a2 2 0 0 0-2 2v7a2 2 0 0 0 2 2h5V16h-5a.5.5 0 0 1-.5-.5v-7A.5.5 0 0 1 15 8h5V6.5Z"
59801    })
59802  });
59803  /* harmony default export */ const library_row = (row);
59804  
59805  ;// ./node_modules/@wordpress/icons/build-module/library/stack.js
59806  /**
59807   * WordPress dependencies
59808   */
59809  
59810  
59811  const stack = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
59812    xmlns: "http://www.w3.org/2000/svg",
59813    viewBox: "0 0 24 24",
59814    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
59815      d: "M17.5 4v5a2 2 0 0 1-2 2h-7a2 2 0 0 1-2-2V4H8v5a.5.5 0 0 0 .5.5h7A.5.5 0 0 0 16 9V4h1.5Zm0 16v-5a2 2 0 0 0-2-2h-7a2 2 0 0 0-2 2v5H8v-5a.5.5 0 0 1 .5-.5h7a.5.5 0 0 1 .5.5v5h1.5Z"
59816    })
59817  });
59818  /* harmony default export */ const library_stack = (stack);
59819  
59820  ;// ./node_modules/@wordpress/icons/build-module/library/grid.js
59821  /**
59822   * WordPress dependencies
59823   */
59824  
59825  
59826  const grid_grid = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
59827    xmlns: "http://www.w3.org/2000/svg",
59828    viewBox: "0 0 24 24",
59829    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
59830      d: "m3 5c0-1.10457.89543-2 2-2h13.5c1.1046 0 2 .89543 2 2v13.5c0 1.1046-.8954 2-2 2h-13.5c-1.10457 0-2-.8954-2-2zm2-.5h6v6.5h-6.5v-6c0-.27614.22386-.5.5-.5zm-.5 8v6c0 .2761.22386.5.5.5h6v-6.5zm8 0v6.5h6c.2761 0 .5-.2239.5-.5v-6zm0-8v6.5h6.5v-6c0-.27614-.2239-.5-.5-.5z",
59831      fillRule: "evenodd",
59832      clipRule: "evenodd"
59833    })
59834  });
59835  /* harmony default export */ const library_grid = (grid_grid);
59836  
59837  ;// ./node_modules/@wordpress/block-editor/build-module/components/convert-to-group-buttons/toolbar.js
59838  /**
59839   * WordPress dependencies
59840   */
59841  
59842  
59843  
59844  
59845  
59846  
59847  /**
59848   * Internal dependencies
59849   */
59850  
59851  
59852  
59853  const layouts = {
59854    group: {
59855      type: 'constrained'
59856    },
59857    row: {
59858      type: 'flex',
59859      flexWrap: 'nowrap'
59860    },
59861    stack: {
59862      type: 'flex',
59863      orientation: 'vertical'
59864    },
59865    grid: {
59866      type: 'grid'
59867    }
59868  };
59869  function BlockGroupToolbar() {
59870    const {
59871      blocksSelection,
59872      clientIds,
59873      groupingBlockName,
59874      isGroupable
59875    } = useConvertToGroupButtonProps();
59876    const {
59877      replaceBlocks
59878    } = (0,external_wp_data_namespaceObject.useDispatch)(store);
59879    const {
59880      canRemove,
59881      variations
59882    } = (0,external_wp_data_namespaceObject.useSelect)(select => {
59883      const {
59884        canRemoveBlocks
59885      } = select(store);
59886      const {
59887        getBlockVariations
59888      } = select(external_wp_blocks_namespaceObject.store);
59889      return {
59890        canRemove: canRemoveBlocks(clientIds),
59891        variations: getBlockVariations(groupingBlockName, 'transform')
59892      };
59893    }, [clientIds, groupingBlockName]);
59894    const onConvertToGroup = layout => {
59895      const newBlocks = (0,external_wp_blocks_namespaceObject.switchToBlockType)(blocksSelection, groupingBlockName);
59896      if (typeof layout !== 'string') {
59897        layout = 'group';
59898      }
59899      if (newBlocks && newBlocks.length > 0) {
59900        // Because the block is not in the store yet we can't use
59901        // updateBlockAttributes so need to manually update attributes.
59902        newBlocks[0].attributes.layout = layouts[layout];
59903        replaceBlocks(clientIds, newBlocks);
59904      }
59905    };
59906    const onConvertToRow = () => onConvertToGroup('row');
59907    const onConvertToStack = () => onConvertToGroup('stack');
59908    const onConvertToGrid = () => onConvertToGroup('grid');
59909  
59910    // Don't render the button if the current selection cannot be grouped.
59911    // A good example is selecting multiple button blocks within a Buttons block:
59912    // The group block is not a valid child of Buttons, so we should not show the button.
59913    // Any blocks that are locked against removal also cannot be grouped.
59914    if (!isGroupable || !canRemove) {
59915      return null;
59916    }
59917    const canInsertRow = !!variations.find(({
59918      name
59919    }) => name === 'group-row');
59920    const canInsertStack = !!variations.find(({
59921      name
59922    }) => name === 'group-stack');
59923    const canInsertGrid = !!variations.find(({
59924      name
59925    }) => name === 'group-grid');
59926    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.ToolbarGroup, {
59927      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarButton, {
59928        icon: library_group,
59929        label: (0,external_wp_i18n_namespaceObject._x)('Group', 'action: convert blocks to group'),
59930        onClick: onConvertToGroup
59931      }), canInsertRow && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarButton, {
59932        icon: library_row,
59933        label: (0,external_wp_i18n_namespaceObject._x)('Row', 'action: convert blocks to row'),
59934        onClick: onConvertToRow
59935      }), canInsertStack && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarButton, {
59936        icon: library_stack,
59937        label: (0,external_wp_i18n_namespaceObject._x)('Stack', 'action: convert blocks to stack'),
59938        onClick: onConvertToStack
59939      }), canInsertGrid && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarButton, {
59940        icon: library_grid,
59941        label: (0,external_wp_i18n_namespaceObject._x)('Grid', 'action: convert blocks to grid'),
59942        onClick: onConvertToGrid
59943      })]
59944    });
59945  }
59946  /* harmony default export */ const toolbar = (BlockGroupToolbar);
59947  
59948  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-edit-visually-button/index.js
59949  /**
59950   * WordPress dependencies
59951   */
59952  
59953  
59954  
59955  
59956  /**
59957   * Internal dependencies
59958   */
59959  
59960  
59961  function BlockEditVisuallyButton({
59962    clientIds
59963  }) {
59964    // Edit visually only works for single block selection.
59965    const clientId = clientIds.length === 1 ? clientIds[0] : undefined;
59966    const canEditVisually = (0,external_wp_data_namespaceObject.useSelect)(select => !!clientId && select(store).getBlockMode(clientId) === 'html', [clientId]);
59967    const {
59968      toggleBlockMode
59969    } = (0,external_wp_data_namespaceObject.useDispatch)(store);
59970    if (!canEditVisually) {
59971      return null;
59972    }
59973    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarGroup, {
59974      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarButton, {
59975        onClick: () => {
59976          toggleBlockMode(clientId);
59977        },
59978        children: (0,external_wp_i18n_namespaceObject.__)('Edit visually')
59979      })
59980    });
59981  }
59982  
59983  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-toolbar/block-name-context.js
59984  /**
59985   * WordPress dependencies
59986   */
59987  
59988  const __unstableBlockNameContext = (0,external_wp_element_namespaceObject.createContext)('');
59989  /* harmony default export */ const block_name_context = (__unstableBlockNameContext);
59990  
59991  ;// ./node_modules/@wordpress/block-editor/build-module/components/navigable-toolbar/index.js
59992  /**
59993   * WordPress dependencies
59994   */
59995  
59996  
59997  
59998  
59999  
60000  
60001  
60002  
60003  /**
60004   * Internal dependencies
60005   */
60006  
60007  
60008  
60009  function hasOnlyToolbarItem(elements) {
60010    const dataProp = 'toolbarItem';
60011    return !elements.some(element => !(dataProp in element.dataset));
60012  }
60013  function getAllFocusableToolbarItemsIn(container) {
60014    return Array.from(container.querySelectorAll('[data-toolbar-item]:not([disabled])'));
60015  }
60016  function hasFocusWithin(container) {
60017    return container.contains(container.ownerDocument.activeElement);
60018  }
60019  function focusFirstTabbableIn(container) {
60020    const [firstTabbable] = external_wp_dom_namespaceObject.focus.tabbable.find(container);
60021    if (firstTabbable) {
60022      firstTabbable.focus({
60023        // When focusing newly mounted toolbars,
60024        // the position of the popover is often not right on the first render
60025        // This prevents the layout shifts when focusing the dialogs.
60026        preventScroll: true
60027      });
60028    }
60029  }
60030  function useIsAccessibleToolbar(toolbarRef) {
60031    /*
60032     * By default, we'll assume the starting accessible state of the Toolbar
60033     * is true, as it seems to be the most common case.
60034     *
60035     * Transitioning from an (initial) false to true state causes the
60036     * <Toolbar /> component to mount twice, which is causing undesired
60037     * side-effects. These side-effects appear to only affect certain
60038     * E2E tests.
60039     *
60040     * This was initial discovered in this pull-request:
60041     * https://github.com/WordPress/gutenberg/pull/23425
60042     */
60043    const initialAccessibleToolbarState = true;
60044  
60045    // By default, it's gonna render NavigableMenu. If all the tabbable elements
60046    // inside the toolbar are ToolbarItem components (or derived components like
60047    // ToolbarButton), then we can wrap them with the accessible Toolbar
60048    // component.
60049    const [isAccessibleToolbar, setIsAccessibleToolbar] = (0,external_wp_element_namespaceObject.useState)(initialAccessibleToolbarState);
60050    const determineIsAccessibleToolbar = (0,external_wp_element_namespaceObject.useCallback)(() => {
60051      const tabbables = external_wp_dom_namespaceObject.focus.tabbable.find(toolbarRef.current);
60052      const onlyToolbarItem = hasOnlyToolbarItem(tabbables);
60053      if (!onlyToolbarItem) {
60054        external_wp_deprecated_default()('Using custom components as toolbar controls', {
60055          since: '5.6',
60056          alternative: 'ToolbarItem, ToolbarButton or ToolbarDropdownMenu components',
60057          link: 'https://developer.wordpress.org/block-editor/components/toolbar-button/#inside-blockcontrols'
60058        });
60059      }
60060      setIsAccessibleToolbar(onlyToolbarItem);
60061    }, [toolbarRef]);
60062    (0,external_wp_element_namespaceObject.useLayoutEffect)(() => {
60063      // Toolbar buttons may be rendered asynchronously, so we use
60064      // MutationObserver to check if the toolbar subtree has been modified.
60065      const observer = new window.MutationObserver(determineIsAccessibleToolbar);
60066      observer.observe(toolbarRef.current, {
60067        childList: true,
60068        subtree: true
60069      });
60070      return () => observer.disconnect();
60071    }, [determineIsAccessibleToolbar, isAccessibleToolbar, toolbarRef]);
60072    return isAccessibleToolbar;
60073  }
60074  function useToolbarFocus({
60075    toolbarRef,
60076    focusOnMount,
60077    isAccessibleToolbar,
60078    defaultIndex,
60079    onIndexChange,
60080    shouldUseKeyboardFocusShortcut,
60081    focusEditorOnEscape
60082  }) {
60083    // Make sure we don't use modified versions of this prop.
60084    const [initialFocusOnMount] = (0,external_wp_element_namespaceObject.useState)(focusOnMount);
60085    const [initialIndex] = (0,external_wp_element_namespaceObject.useState)(defaultIndex);
60086    const focusToolbar = (0,external_wp_element_namespaceObject.useCallback)(() => {
60087      focusFirstTabbableIn(toolbarRef.current);
60088    }, [toolbarRef]);
60089    const focusToolbarViaShortcut = () => {
60090      if (shouldUseKeyboardFocusShortcut) {
60091        focusToolbar();
60092      }
60093    };
60094  
60095    // Focus on toolbar when pressing alt+F10 when the toolbar is visible.
60096    (0,external_wp_keyboardShortcuts_namespaceObject.useShortcut)('core/block-editor/focus-toolbar', focusToolbarViaShortcut);
60097    (0,external_wp_element_namespaceObject.useEffect)(() => {
60098      if (initialFocusOnMount) {
60099        focusToolbar();
60100      }
60101    }, [isAccessibleToolbar, initialFocusOnMount, focusToolbar]);
60102    (0,external_wp_element_namespaceObject.useEffect)(() => {
60103      // Store ref so we have access on useEffect cleanup: https://legacy.reactjs.org/blog/2020/08/10/react-v17-rc.html#effect-cleanup-timing
60104      const navigableToolbarRef = toolbarRef.current;
60105      // If initialIndex is passed, we focus on that toolbar item when the
60106      // toolbar gets mounted and initial focus is not forced.
60107      // We have to wait for the next browser paint because block controls aren't
60108      // rendered right away when the toolbar gets mounted.
60109      let raf = 0;
60110  
60111      // If the toolbar already had focus before the render, we don't want to move it.
60112      // https://github.com/WordPress/gutenberg/issues/58511
60113      if (!initialFocusOnMount && !hasFocusWithin(navigableToolbarRef)) {
60114        raf = window.requestAnimationFrame(() => {
60115          const items = getAllFocusableToolbarItemsIn(navigableToolbarRef);
60116          const index = initialIndex || 0;
60117          if (items[index] && hasFocusWithin(navigableToolbarRef)) {
60118            items[index].focus({
60119              // When focusing newly mounted toolbars,
60120              // the position of the popover is often not right on the first render
60121              // This prevents the layout shifts when focusing the dialogs.
60122              preventScroll: true
60123            });
60124          }
60125        });
60126      }
60127      return () => {
60128        window.cancelAnimationFrame(raf);
60129        if (!onIndexChange || !navigableToolbarRef) {
60130          return;
60131        }
60132        // When the toolbar element is unmounted and onIndexChange is passed, we
60133        // pass the focused toolbar item index so it can be hydrated later.
60134        const items = getAllFocusableToolbarItemsIn(navigableToolbarRef);
60135        const index = items.findIndex(item => item.tabIndex === 0);
60136        onIndexChange(index);
60137      };
60138    }, [initialIndex, initialFocusOnMount, onIndexChange, toolbarRef]);
60139    const {
60140      getLastFocus
60141    } = unlock((0,external_wp_data_namespaceObject.useSelect)(store));
60142    /**
60143     * Handles returning focus to the block editor canvas when pressing escape.
60144     */
60145    (0,external_wp_element_namespaceObject.useEffect)(() => {
60146      const navigableToolbarRef = toolbarRef.current;
60147      if (focusEditorOnEscape) {
60148        const handleKeyDown = event => {
60149          const lastFocus = getLastFocus();
60150          if (event.keyCode === external_wp_keycodes_namespaceObject.ESCAPE && lastFocus?.current) {
60151            // Focus the last focused element when pressing escape.
60152            event.preventDefault();
60153            lastFocus.current.focus();
60154          }
60155        };
60156        navigableToolbarRef.addEventListener('keydown', handleKeyDown);
60157        return () => {
60158          navigableToolbarRef.removeEventListener('keydown', handleKeyDown);
60159        };
60160      }
60161    }, [focusEditorOnEscape, getLastFocus, toolbarRef]);
60162  }
60163  function NavigableToolbar({
60164    children,
60165    focusOnMount,
60166    focusEditorOnEscape = false,
60167    shouldUseKeyboardFocusShortcut = true,
60168    __experimentalInitialIndex: initialIndex,
60169    __experimentalOnIndexChange: onIndexChange,
60170    orientation = 'horizontal',
60171    ...props
60172  }) {
60173    const toolbarRef = (0,external_wp_element_namespaceObject.useRef)();
60174    const isAccessibleToolbar = useIsAccessibleToolbar(toolbarRef);
60175    useToolbarFocus({
60176      toolbarRef,
60177      focusOnMount,
60178      defaultIndex: initialIndex,
60179      onIndexChange,
60180      isAccessibleToolbar,
60181      shouldUseKeyboardFocusShortcut,
60182      focusEditorOnEscape
60183    });
60184    if (isAccessibleToolbar) {
60185      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Toolbar, {
60186        label: props['aria-label'],
60187        ref: toolbarRef,
60188        orientation: orientation,
60189        ...props,
60190        children: children
60191      });
60192    }
60193    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.NavigableMenu, {
60194      orientation: orientation,
60195      role: "toolbar",
60196      ref: toolbarRef,
60197      ...props,
60198      children: children
60199    });
60200  }
60201  
60202  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-toolbar/use-has-block-toolbar.js
60203  /**
60204   * WordPress dependencies
60205   */
60206  
60207  
60208  /**
60209   * Internal dependencies
60210   */
60211  
60212  
60213  /**
60214   * Returns true if the block toolbar should be shown.
60215   *
60216   * @return {boolean} Whether the block toolbar component will be rendered.
60217   */
60218  function useHasBlockToolbar() {
60219    const {
60220      isToolbarEnabled,
60221      isBlockDisabled
60222    } = (0,external_wp_data_namespaceObject.useSelect)(select => {
60223      const {
60224        getBlockEditingMode,
60225        getBlockName,
60226        getBlockSelectionStart
60227      } = select(store);
60228  
60229      // we only care about the 1st selected block
60230      // for the toolbar, so we use getBlockSelectionStart
60231      // instead of getSelectedBlockClientIds
60232      const selectedBlockClientId = getBlockSelectionStart();
60233      const blockType = selectedBlockClientId && (0,external_wp_blocks_namespaceObject.getBlockType)(getBlockName(selectedBlockClientId));
60234      return {
60235        isToolbarEnabled: blockType && (0,external_wp_blocks_namespaceObject.hasBlockSupport)(blockType, '__experimentalToolbar', true),
60236        isBlockDisabled: getBlockEditingMode(selectedBlockClientId) === 'disabled'
60237      };
60238    }, []);
60239    if (!isToolbarEnabled || isBlockDisabled) {
60240      return false;
60241    }
60242    return true;
60243  }
60244  
60245  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-toolbar/change-design.js
60246  /**
60247   * WordPress dependencies
60248   */
60249  
60250  
60251  
60252  
60253  
60254  
60255  /**
60256   * Internal dependencies
60257   */
60258  
60259  
60260  
60261  const change_design_EMPTY_ARRAY = [];
60262  const MAX_PATTERNS_TO_SHOW = 6;
60263  const change_design_POPOVER_PROPS = {
60264    placement: 'bottom-start'
60265  };
60266  function ChangeDesign({
60267    clientId
60268  }) {
60269    const {
60270      categories,
60271      currentPatternName,
60272      patterns
60273    } = (0,external_wp_data_namespaceObject.useSelect)(select => {
60274      const {
60275        getBlockAttributes,
60276        getBlockRootClientId,
60277        __experimentalGetAllowedPatterns
60278      } = select(store);
60279      const attributes = getBlockAttributes(clientId);
60280      const _categories = attributes?.metadata?.categories || change_design_EMPTY_ARRAY;
60281      const rootBlock = getBlockRootClientId(clientId);
60282  
60283      // Calling `__experimentalGetAllowedPatterns` is expensive.
60284      // Checking if the block can be changed prevents unnecessary selector calls.
60285      // See: https://github.com/WordPress/gutenberg/pull/64736.
60286      const _patterns = _categories.length > 0 ? __experimentalGetAllowedPatterns(rootBlock) : change_design_EMPTY_ARRAY;
60287      return {
60288        categories: _categories,
60289        currentPatternName: attributes?.metadata?.patternName,
60290        patterns: _patterns
60291      };
60292    }, [clientId]);
60293    const {
60294      replaceBlocks
60295    } = (0,external_wp_data_namespaceObject.useDispatch)(store);
60296    const sameCategoryPatternsWithSingleWrapper = (0,external_wp_element_namespaceObject.useMemo)(() => {
60297      if (categories.length === 0 || !patterns || patterns.length === 0) {
60298        return change_design_EMPTY_ARRAY;
60299      }
60300      return patterns.filter(pattern => {
60301        const isCorePattern = pattern.source === 'core' || pattern.source?.startsWith('pattern-directory') && pattern.source !== 'pattern-directory/theme';
60302        return (
60303          // Check if the pattern has only one top level block,
60304          // otherwise we may switch to a pattern that doesn't have replacement suggestions.
60305          pattern.blocks.length === 1 &&
60306          // We exclude the core patterns and pattern directory patterns that are not theme patterns.
60307          !isCorePattern &&
60308          // Exclude current pattern.
60309          currentPatternName !== pattern.name && pattern.categories?.some(category => {
60310            return categories.includes(category);
60311          }) && (
60312          // Check if the pattern is not a synced pattern.
60313          pattern.syncStatus === 'unsynced' || !pattern.id)
60314        );
60315      }).slice(0, MAX_PATTERNS_TO_SHOW);
60316    }, [categories, currentPatternName, patterns]);
60317    if (sameCategoryPatternsWithSingleWrapper.length < 2) {
60318      return null;
60319    }
60320    const onClickPattern = pattern => {
60321      var _pattern$blocks;
60322      const newBlocks = ((_pattern$blocks = pattern.blocks) !== null && _pattern$blocks !== void 0 ? _pattern$blocks : []).map(block => {
60323        return (0,external_wp_blocks_namespaceObject.cloneBlock)(block);
60324      });
60325      newBlocks[0].attributes.metadata = {
60326        ...newBlocks[0].attributes.metadata,
60327        categories
60328      };
60329      replaceBlocks(clientId, newBlocks);
60330    };
60331    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Dropdown, {
60332      popoverProps: change_design_POPOVER_PROPS,
60333      renderToggle: ({
60334        onToggle,
60335        isOpen
60336      }) => {
60337        return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarGroup, {
60338          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarButton, {
60339            onClick: () => onToggle(!isOpen),
60340            "aria-expanded": isOpen,
60341            children: (0,external_wp_i18n_namespaceObject.__)('Change design')
60342          })
60343        });
60344      },
60345      renderContent: () => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalDropdownContentWrapper, {
60346        className: "block-editor-block-toolbar-change-design-content-wrapper",
60347        paddingSize: "none",
60348        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_patterns_list, {
60349          blockPatterns: sameCategoryPatternsWithSingleWrapper,
60350          onClickPattern: onClickPattern,
60351          showTitlesAsTooltip: true
60352        })
60353      })
60354    });
60355  }
60356  
60357  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-toolbar/switch-section-style.js
60358  /**
60359   * WordPress dependencies
60360   */
60361  
60362  
60363  
60364  
60365  
60366  /**
60367   * Internal dependencies
60368   */
60369  
60370  
60371  
60372  
60373  
60374  
60375  
60376  const styleIcon = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.SVG, {
60377    viewBox: "0 0 24 24",
60378    xmlns: "http://www.w3.org/2000/svg",
60379    width: "24",
60380    height: "24",
60381    "aria-hidden": "true",
60382    focusable: "false",
60383    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Path, {
60384      d: "M17.2 10.9c-.5-1-1.2-2.1-2.1-3.2-.6-.9-1.3-1.7-2.1-2.6L12 4l-1 1.1c-.6.9-1.3 1.7-2 2.6-.8 1.2-1.5 2.3-2 3.2-.6 1.2-1 2.2-1 3 0 3.4 2.7 6.1 6.1 6.1s6.1-2.7 6.1-6.1c0-.8-.3-1.8-1-3z"
60385    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Path, {
60386      stroke: "currentColor",
60387      strokeWidth: "1.5",
60388      d: "M17.2 10.9c-.5-1-1.2-2.1-2.1-3.2-.6-.9-1.3-1.7-2.1-2.6L12 4l-1 1.1c-.6.9-1.3 1.7-2 2.6-.8 1.2-1.5 2.3-2 3.2-.6 1.2-1 2.2-1 3 0 3.4 2.7 6.1 6.1 6.1s6.1-2.7 6.1-6.1c0-.8-.3-1.8-1-3z"
60389    })]
60390  });
60391  function SwitchSectionStyle({
60392    clientId
60393  }) {
60394    var _mergedConfig$setting, _mergedConfig$styles;
60395    const {
60396      stylesToRender,
60397      activeStyle,
60398      className
60399    } = useStylesForBlocks({
60400      clientId
60401    });
60402    const {
60403      updateBlockAttributes
60404    } = (0,external_wp_data_namespaceObject.useDispatch)(store);
60405  
60406    // Get global styles data
60407    const {
60408      merged: mergedConfig
60409    } = (0,external_wp_element_namespaceObject.useContext)(GlobalStylesContext);
60410    const {
60411      globalSettings,
60412      globalStyles,
60413      blockName
60414    } = (0,external_wp_data_namespaceObject.useSelect)(select => {
60415      const settings = select(store).getSettings();
60416      return {
60417        globalSettings: settings.__experimentalFeatures,
60418        globalStyles: settings[globalStylesDataKey],
60419        blockName: select(store).getBlockName(clientId)
60420      };
60421    }, [clientId]);
60422  
60423    // Get the background color for the active style
60424    const activeStyleBackground = activeStyle?.name ? getVariationStylesWithRefValues({
60425      settings: (_mergedConfig$setting = mergedConfig?.settings) !== null && _mergedConfig$setting !== void 0 ? _mergedConfig$setting : globalSettings,
60426      styles: (_mergedConfig$styles = mergedConfig?.styles) !== null && _mergedConfig$styles !== void 0 ? _mergedConfig$styles : globalStyles
60427    }, blockName, activeStyle.name)?.color?.background : undefined;
60428    if (!stylesToRender || stylesToRender.length === 0) {
60429      return null;
60430    }
60431    const handleStyleSwitch = () => {
60432      const currentIndex = stylesToRender.findIndex(style => style.name === activeStyle.name);
60433      const nextIndex = (currentIndex + 1) % stylesToRender.length;
60434      const nextStyle = stylesToRender[nextIndex];
60435      const styleClassName = replaceActiveStyle(className, activeStyle, nextStyle);
60436      updateBlockAttributes(clientId, {
60437        className: styleClassName
60438      });
60439    };
60440    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarGroup, {
60441      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarButton, {
60442        onClick: handleStyleSwitch,
60443        label: (0,external_wp_i18n_namespaceObject.__)('Shuffle styles'),
60444        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Icon, {
60445          icon: styleIcon,
60446          style: {
60447            fill: activeStyleBackground || 'transparent'
60448          }
60449        })
60450      })
60451    });
60452  }
60453  /* harmony default export */ const switch_section_style = (SwitchSectionStyle);
60454  
60455  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-toolbar/index.js
60456  /**
60457   * External dependencies
60458   */
60459  
60460  
60461  /**
60462   * WordPress dependencies
60463   */
60464  
60465  
60466  
60467  
60468  
60469  
60470  
60471  /**
60472   * Internal dependencies
60473   */
60474  
60475  
60476  
60477  
60478  
60479  
60480  
60481  
60482  
60483  
60484  
60485  
60486  
60487  
60488  
60489  
60490  
60491  
60492  /**
60493   * Renders the block toolbar.
60494   *
60495   * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/block-toolbar/README.md
60496   *
60497   * @param {Object}   props                             Components props.
60498   * @param {boolean}  props.hideDragHandle              Show or hide the Drag Handle for drag and drop functionality.
60499   * @param {boolean}  props.focusOnMount                Focus the toolbar when mounted.
60500   * @param {number}   props.__experimentalInitialIndex  The initial index of the toolbar item to focus.
60501   * @param {Function} props.__experimentalOnIndexChange Callback function to be called when the index of the focused toolbar item changes.
60502   * @param {string}   props.variant                     Style variant of the toolbar, also passed to the Dropdowns rendered from Block Toolbar Buttons.
60503   */
60504  
60505  function PrivateBlockToolbar({
60506    hideDragHandle,
60507    focusOnMount,
60508    __experimentalInitialIndex,
60509    __experimentalOnIndexChange,
60510    variant = 'unstyled'
60511  }) {
60512    const {
60513      blockClientId,
60514      blockClientIds,
60515      isDefaultEditingMode,
60516      blockType,
60517      toolbarKey,
60518      shouldShowVisualToolbar,
60519      showParentSelector,
60520      isUsingBindings,
60521      hasParentPattern,
60522      hasContentOnlyLocking,
60523      showShuffleButton,
60524      showSlots,
60525      showGroupButtons,
60526      showLockButtons,
60527      showSwitchSectionStyleButton,
60528      hasFixedToolbar,
60529      isNavigationMode
60530    } = (0,external_wp_data_namespaceObject.useSelect)(select => {
60531      const {
60532        getBlockName,
60533        getBlockMode,
60534        getBlockParents,
60535        getSelectedBlockClientIds,
60536        isBlockValid,
60537        getBlockEditingMode,
60538        getBlockAttributes,
60539        getBlockParentsByBlockName,
60540        getTemplateLock,
60541        getSettings,
60542        getParentSectionBlock,
60543        isZoomOut,
60544        isNavigationMode: _isNavigationMode
60545      } = unlock(select(store));
60546      const selectedBlockClientIds = getSelectedBlockClientIds();
60547      const selectedBlockClientId = selectedBlockClientIds[0];
60548      const parents = getBlockParents(selectedBlockClientId);
60549      const parentSection = getParentSectionBlock(selectedBlockClientId);
60550      const parentClientId = parentSection !== null && parentSection !== void 0 ? parentSection : parents[parents.length - 1];
60551      const parentBlockName = getBlockName(parentClientId);
60552      const parentBlockType = (0,external_wp_blocks_namespaceObject.getBlockType)(parentBlockName);
60553      const editingMode = getBlockEditingMode(selectedBlockClientId);
60554      const _isDefaultEditingMode = editingMode === 'default';
60555      const _blockName = getBlockName(selectedBlockClientId);
60556      const isValid = selectedBlockClientIds.every(id => isBlockValid(id));
60557      const isVisual = selectedBlockClientIds.every(id => getBlockMode(id) === 'visual');
60558      const _isUsingBindings = selectedBlockClientIds.every(clientId => !!getBlockAttributes(clientId)?.metadata?.bindings);
60559      const _hasParentPattern = selectedBlockClientIds.every(clientId => getBlockParentsByBlockName(clientId, 'core/block', true).length > 0);
60560  
60561      // If one or more selected blocks are locked, do not show the BlockGroupToolbar.
60562      const _hasTemplateLock = selectedBlockClientIds.some(id => getTemplateLock(id) === 'contentOnly');
60563      const _isZoomOut = isZoomOut();
60564      return {
60565        blockClientId: selectedBlockClientId,
60566        blockClientIds: selectedBlockClientIds,
60567        isDefaultEditingMode: _isDefaultEditingMode,
60568        blockType: selectedBlockClientId && (0,external_wp_blocks_namespaceObject.getBlockType)(_blockName),
60569        shouldShowVisualToolbar: isValid && isVisual,
60570        toolbarKey: `$selectedBlockClientId}$parentClientId}`,
60571        showParentSelector: !_isZoomOut && parentBlockType && editingMode !== 'contentOnly' && getBlockEditingMode(parentClientId) !== 'disabled' && (0,external_wp_blocks_namespaceObject.hasBlockSupport)(parentBlockType, '__experimentalParentSelector', true) && selectedBlockClientIds.length === 1,
60572        isUsingBindings: _isUsingBindings,
60573        hasParentPattern: _hasParentPattern,
60574        hasContentOnlyLocking: _hasTemplateLock,
60575        showShuffleButton: _isZoomOut,
60576        showSlots: !_isZoomOut,
60577        showGroupButtons: !_isZoomOut,
60578        showLockButtons: !_isZoomOut,
60579        showSwitchSectionStyleButton: _isZoomOut,
60580        hasFixedToolbar: getSettings().hasFixedToolbar,
60581        isNavigationMode: _isNavigationMode()
60582      };
60583    }, []);
60584    const toolbarWrapperRef = (0,external_wp_element_namespaceObject.useRef)(null);
60585  
60586    // Handles highlighting the current block outline on hover or focus of the
60587    // block type toolbar area.
60588    const nodeRef = (0,external_wp_element_namespaceObject.useRef)();
60589    const showHoveredOrFocusedGestures = useShowHoveredOrFocusedGestures({
60590      ref: nodeRef
60591    });
60592    const isLargeViewport = !(0,external_wp_compose_namespaceObject.useViewportMatch)('medium', '<');
60593    const hasBlockToolbar = useHasBlockToolbar();
60594    if (!hasBlockToolbar) {
60595      return null;
60596    }
60597    const isMultiToolbar = blockClientIds.length > 1;
60598    const isSynced = (0,external_wp_blocks_namespaceObject.isReusableBlock)(blockType) || (0,external_wp_blocks_namespaceObject.isTemplatePart)(blockType);
60599  
60600    // Shifts the toolbar to make room for the parent block selector.
60601    const classes = dist_clsx('block-editor-block-contextual-toolbar', {
60602      'has-parent': showParentSelector,
60603      'is-inverted-toolbar': isNavigationMode && !hasFixedToolbar
60604    });
60605    const innerClasses = dist_clsx('block-editor-block-toolbar', {
60606      'is-synced': isSynced,
60607      'is-connected': isUsingBindings
60608    });
60609    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(NavigableToolbar, {
60610      focusEditorOnEscape: true,
60611      className: classes
60612      /* translators: accessibility text for the block toolbar */,
60613      "aria-label": (0,external_wp_i18n_namespaceObject.__)('Block tools')
60614      // The variant is applied as "toolbar" when undefined, which is the black border style of the dropdown from the toolbar popover.
60615      ,
60616      variant: variant === 'toolbar' ? undefined : variant,
60617      focusOnMount: focusOnMount,
60618      __experimentalInitialIndex: __experimentalInitialIndex,
60619      __experimentalOnIndexChange: __experimentalOnIndexChange
60620      // Resets the index whenever the active block changes so
60621      // this is not persisted. See https://github.com/WordPress/gutenberg/pull/25760#issuecomment-717906169
60622      ,
60623      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
60624        ref: toolbarWrapperRef,
60625        className: innerClasses,
60626        children: [showParentSelector && !isMultiToolbar && isLargeViewport && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockParentSelector, {}), (shouldShowVisualToolbar || isMultiToolbar) && !hasParentPattern && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
60627          ref: nodeRef,
60628          ...showHoveredOrFocusedGestures,
60629          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.ToolbarGroup, {
60630            className: "block-editor-block-toolbar__block-controls",
60631            children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_switcher, {
60632              clientIds: blockClientIds
60633            }), !isMultiToolbar && isDefaultEditingMode && showLockButtons && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockLockToolbar, {
60634              clientId: blockClientId
60635            }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_mover, {
60636              clientIds: blockClientIds,
60637              hideDragHandle: hideDragHandle
60638            })]
60639          })
60640        }), !hasContentOnlyLocking && shouldShowVisualToolbar && isMultiToolbar && showGroupButtons && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(toolbar, {}), showShuffleButton && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ChangeDesign, {
60641          clientId: blockClientIds[0]
60642        }), showSwitchSectionStyleButton && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(switch_section_style, {
60643          clientId: blockClientIds[0]
60644        }), shouldShowVisualToolbar && showSlots && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
60645          children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_controls.Slot, {
60646            group: "parent",
60647            className: "block-editor-block-toolbar__slot"
60648          }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_controls.Slot, {
60649            group: "block",
60650            className: "block-editor-block-toolbar__slot"
60651          }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_controls.Slot, {
60652            className: "block-editor-block-toolbar__slot"
60653          }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_controls.Slot, {
60654            group: "inline",
60655            className: "block-editor-block-toolbar__slot"
60656          }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_controls.Slot, {
60657            group: "other",
60658            className: "block-editor-block-toolbar__slot"
60659          }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_name_context.Provider, {
60660            value: blockType?.name,
60661            children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_toolbar_last_item.Slot, {})
60662          })]
60663        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockEditVisuallyButton, {
60664          clientIds: blockClientIds
60665        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_settings_menu, {
60666          clientIds: blockClientIds
60667        })]
60668      })
60669    }, toolbarKey);
60670  }
60671  
60672  /**
60673   * Renders the block toolbar.
60674   *
60675   * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/block-toolbar/README.md
60676   *
60677   * @param {Object}  props                Components props.
60678   * @param {boolean} props.hideDragHandle Show or hide the Drag Handle for drag and drop functionality.
60679   * @param {string}  props.variant        Style variant of the toolbar, also passed to the Dropdowns rendered from Block Toolbar Buttons.
60680   */
60681  function BlockToolbar({
60682    hideDragHandle,
60683    variant
60684  }) {
60685    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PrivateBlockToolbar, {
60686      hideDragHandle: hideDragHandle,
60687      variant: variant,
60688      focusOnMount: undefined,
60689      __experimentalInitialIndex: undefined,
60690      __experimentalOnIndexChange: undefined
60691    });
60692  }
60693  
60694  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-tools/block-toolbar-popover.js
60695  /**
60696   * External dependencies
60697   */
60698  
60699  /**
60700   * WordPress dependencies
60701   */
60702  
60703  
60704  
60705  /**
60706   * Internal dependencies
60707   */
60708  
60709  
60710  
60711  
60712  
60713  
60714  function BlockToolbarPopover({
60715    clientId,
60716    isTyping,
60717    __unstableContentRef
60718  }) {
60719    const {
60720      capturingClientId,
60721      isInsertionPointVisible,
60722      lastClientId
60723    } = useSelectedBlockToolProps(clientId);
60724  
60725    // Stores the active toolbar item index so the block toolbar can return focus
60726    // to it when re-mounting.
60727    const initialToolbarItemIndexRef = (0,external_wp_element_namespaceObject.useRef)();
60728    (0,external_wp_element_namespaceObject.useEffect)(() => {
60729      // Resets the index whenever the active block changes so this is not
60730      // persisted. See https://github.com/WordPress/gutenberg/pull/25760#issuecomment-717906169
60731      initialToolbarItemIndexRef.current = undefined;
60732    }, [clientId]);
60733    const {
60734      stopTyping
60735    } = (0,external_wp_data_namespaceObject.useDispatch)(store);
60736    const isToolbarForcedRef = (0,external_wp_element_namespaceObject.useRef)(false);
60737    (0,external_wp_keyboardShortcuts_namespaceObject.useShortcut)('core/block-editor/focus-toolbar', () => {
60738      isToolbarForcedRef.current = true;
60739      stopTyping(true);
60740    });
60741    (0,external_wp_element_namespaceObject.useEffect)(() => {
60742      isToolbarForcedRef.current = false;
60743    });
60744  
60745    // If the block has a parent with __experimentalCaptureToolbars enabled,
60746    // the toolbar should be positioned over the topmost capturing parent.
60747    const clientIdToPositionOver = capturingClientId || clientId;
60748    const popoverProps = useBlockToolbarPopoverProps({
60749      contentElement: __unstableContentRef?.current,
60750      clientId: clientIdToPositionOver
60751    });
60752    return !isTyping && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PrivateBlockPopover, {
60753      clientId: clientIdToPositionOver,
60754      bottomClientId: lastClientId,
60755      className: dist_clsx('block-editor-block-list__block-popover', {
60756        'is-insertion-point-visible': isInsertionPointVisible
60757      }),
60758      resize: false,
60759      ...popoverProps,
60760      __unstableContentRef: __unstableContentRef,
60761      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PrivateBlockToolbar
60762      // If the toolbar is being shown because of being forced
60763      // it should focus the toolbar right after the mount.
60764      , {
60765        focusOnMount: isToolbarForcedRef.current,
60766        __experimentalInitialIndex: initialToolbarItemIndexRef.current,
60767        __experimentalOnIndexChange: index => {
60768          initialToolbarItemIndexRef.current = index;
60769        },
60770        variant: "toolbar"
60771      })
60772    });
60773  }
60774  
60775  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-tools/zoom-out-mode-inserter-button.js
60776  /**
60777   * External dependencies
60778   */
60779  
60780  
60781  /**
60782   * WordPress dependencies
60783   */
60784  
60785  
60786  
60787  
60788  function ZoomOutModeInserterButton({
60789    onClick
60790  }) {
60791    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
60792      variant: "primary",
60793      icon: library_plus,
60794      size: "compact",
60795      className: dist_clsx('block-editor-button-pattern-inserter__button', 'block-editor-block-tools__zoom-out-mode-inserter-button'),
60796      onClick: onClick,
60797      label: (0,external_wp_i18n_namespaceObject._x)('Add pattern', 'Generic label for pattern inserter button')
60798    });
60799  }
60800  /* harmony default export */ const zoom_out_mode_inserter_button = (ZoomOutModeInserterButton);
60801  
60802  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-tools/zoom-out-mode-inserters.js
60803  /**
60804   * WordPress dependencies
60805   */
60806  
60807  
60808  
60809  /**
60810   * Internal dependencies
60811   */
60812  
60813  
60814  
60815  
60816  
60817  function ZoomOutModeInserters() {
60818    const [isReady, setIsReady] = (0,external_wp_element_namespaceObject.useState)(false);
60819    const {
60820      hasSelection,
60821      blockOrder,
60822      setInserterIsOpened,
60823      sectionRootClientId,
60824      selectedBlockClientId,
60825      blockInsertionPoint,
60826      insertionPointVisible
60827    } = (0,external_wp_data_namespaceObject.useSelect)(select => {
60828      const {
60829        getSettings,
60830        getBlockOrder,
60831        getSelectionStart,
60832        getSelectedBlockClientId,
60833        getSectionRootClientId,
60834        getBlockInsertionPoint,
60835        isBlockInsertionPointVisible
60836      } = unlock(select(store));
60837      const root = getSectionRootClientId();
60838      return {
60839        hasSelection: !!getSelectionStart().clientId,
60840        blockOrder: getBlockOrder(root),
60841        sectionRootClientId: root,
60842        setInserterIsOpened: getSettings().__experimentalSetIsInserterOpened,
60843        selectedBlockClientId: getSelectedBlockClientId(),
60844        blockInsertionPoint: getBlockInsertionPoint(),
60845        insertionPointVisible: isBlockInsertionPointVisible()
60846      };
60847    }, []);
60848  
60849    // eslint-disable-next-line @wordpress/no-unused-vars-before-return
60850    const {
60851      showInsertionPoint
60852    } = unlock((0,external_wp_data_namespaceObject.useDispatch)(store));
60853  
60854    // Defer the initial rendering to avoid the jumps due to the animation.
60855    (0,external_wp_element_namespaceObject.useEffect)(() => {
60856      const timeout = setTimeout(() => {
60857        setIsReady(true);
60858      }, 500);
60859      return () => {
60860        clearTimeout(timeout);
60861      };
60862    }, []);
60863    if (!isReady || !hasSelection) {
60864      return null;
60865    }
60866    const previousClientId = selectedBlockClientId;
60867    const index = blockOrder.findIndex(clientId => selectedBlockClientId === clientId);
60868    const insertionIndex = index + 1;
60869    const nextClientId = blockOrder[insertionIndex];
60870  
60871    // If the block insertion point is visible, and the insertion
60872    // Indices match then we don't need to render the inserter.
60873    if (insertionPointVisible && blockInsertionPoint?.index === insertionIndex) {
60874      return null;
60875    }
60876    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inbetween, {
60877      previousClientId: previousClientId,
60878      nextClientId: nextClientId,
60879      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(zoom_out_mode_inserter_button, {
60880        onClick: () => {
60881          setInserterIsOpened({
60882            rootClientId: sectionRootClientId,
60883            insertionIndex,
60884            tab: 'patterns',
60885            category: 'all'
60886          });
60887          showInsertionPoint(sectionRootClientId, insertionIndex, {
60888            operation: 'insert'
60889          });
60890        }
60891      })
60892    });
60893  }
60894  /* harmony default export */ const zoom_out_mode_inserters = (ZoomOutModeInserters);
60895  
60896  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-tools/use-show-block-tools.js
60897  /**
60898   * WordPress dependencies
60899   */
60900  
60901  
60902  
60903  /**
60904   * Internal dependencies
60905   */
60906  
60907  
60908  
60909  /**
60910   * Source of truth for which block tools are showing in the block editor.
60911   *
60912   * @return {Object} Object of which block tools will be shown.
60913   */
60914  function useShowBlockTools() {
60915    return (0,external_wp_data_namespaceObject.useSelect)(select => {
60916      const {
60917        getSelectedBlockClientId,
60918        getFirstMultiSelectedBlockClientId,
60919        getBlock,
60920        getBlockMode,
60921        getSettings,
60922        __unstableGetEditorMode,
60923        isTyping
60924      } = unlock(select(store));
60925      const clientId = getSelectedBlockClientId() || getFirstMultiSelectedBlockClientId();
60926      const block = getBlock(clientId);
60927      const editorMode = __unstableGetEditorMode();
60928      const hasSelectedBlock = !!clientId && !!block;
60929      const isEmptyDefaultBlock = hasSelectedBlock && (0,external_wp_blocks_namespaceObject.isUnmodifiedDefaultBlock)(block) && getBlockMode(clientId) !== 'html';
60930      const _showEmptyBlockSideInserter = clientId && !isTyping() &&
60931      // Hide the block inserter on the navigation mode.
60932      // See https://github.com/WordPress/gutenberg/pull/66636#discussion_r1824728483.
60933      editorMode !== 'navigation' && isEmptyDefaultBlock;
60934      const _showBlockToolbarPopover = !getSettings().hasFixedToolbar && !_showEmptyBlockSideInserter && hasSelectedBlock && !isEmptyDefaultBlock;
60935      return {
60936        showEmptyBlockSideInserter: _showEmptyBlockSideInserter,
60937        showBlockToolbarPopover: _showBlockToolbarPopover
60938      };
60939    }, []);
60940  }
60941  
60942  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-tools/index.js
60943  /**
60944   * WordPress dependencies
60945   */
60946  
60947  
60948  
60949  
60950  
60951  
60952  
60953  
60954  
60955  /**
60956   * Internal dependencies
60957   */
60958  
60959  
60960  
60961  
60962  
60963  
60964  
60965  
60966  
60967  function block_tools_selector(select) {
60968    const {
60969      getSelectedBlockClientId,
60970      getFirstMultiSelectedBlockClientId,
60971      getSettings,
60972      isTyping,
60973      isDragging,
60974      isZoomOut
60975    } = unlock(select(store));
60976    const clientId = getSelectedBlockClientId() || getFirstMultiSelectedBlockClientId();
60977    return {
60978      clientId,
60979      hasFixedToolbar: getSettings().hasFixedToolbar,
60980      isTyping: isTyping(),
60981      isZoomOutMode: isZoomOut(),
60982      isDragging: isDragging()
60983    };
60984  }
60985  
60986  /**
60987   * Renders block tools (the block toolbar, select/navigation mode toolbar, the
60988   * insertion point and a slot for the inline rich text toolbar). Must be wrapped
60989   * around the block content and editor styles wrapper or iframe.
60990   *
60991   * @param {Object} $0                      Props.
60992   * @param {Object} $0.children             The block content and style container.
60993   * @param {Object} $0.__unstableContentRef Ref holding the content scroll container.
60994   */
60995  function BlockTools({
60996    children,
60997    __unstableContentRef,
60998    ...props
60999  }) {
61000    const {
61001      clientId,
61002      hasFixedToolbar,
61003      isTyping,
61004      isZoomOutMode,
61005      isDragging
61006    } = (0,external_wp_data_namespaceObject.useSelect)(block_tools_selector, []);
61007    const isMatch = (0,external_wp_keyboardShortcuts_namespaceObject.__unstableUseShortcutEventMatch)();
61008    const {
61009      getBlocksByClientId,
61010      getSelectedBlockClientIds,
61011      getBlockRootClientId,
61012      isGroupable
61013    } = (0,external_wp_data_namespaceObject.useSelect)(store);
61014    const {
61015      getGroupingBlockName
61016    } = (0,external_wp_data_namespaceObject.useSelect)(external_wp_blocks_namespaceObject.store);
61017    const {
61018      showEmptyBlockSideInserter,
61019      showBlockToolbarPopover
61020    } = useShowBlockTools();
61021    const {
61022      duplicateBlocks,
61023      removeBlocks,
61024      replaceBlocks,
61025      insertAfterBlock,
61026      insertBeforeBlock,
61027      selectBlock,
61028      moveBlocksUp,
61029      moveBlocksDown,
61030      expandBlock
61031    } = unlock((0,external_wp_data_namespaceObject.useDispatch)(store));
61032    function onKeyDown(event) {
61033      if (event.defaultPrevented) {
61034        return;
61035      }
61036      if (isMatch('core/block-editor/move-up', event) || isMatch('core/block-editor/move-down', event)) {
61037        const clientIds = getSelectedBlockClientIds();
61038        if (clientIds.length) {
61039          event.preventDefault();
61040          const rootClientId = getBlockRootClientId(clientIds[0]);
61041          const direction = isMatch('core/block-editor/move-up', event) ? 'up' : 'down';
61042          if (direction === 'up') {
61043            moveBlocksUp(clientIds, rootClientId);
61044          } else {
61045            moveBlocksDown(clientIds, rootClientId);
61046          }
61047          const blockLength = Array.isArray(clientIds) ? clientIds.length : 1;
61048          const message = (0,external_wp_i18n_namespaceObject.sprintf)(
61049          // translators: %d: the name of the block that has been moved
61050          (0,external_wp_i18n_namespaceObject._n)('%d block moved.', '%d blocks moved.', clientIds.length), blockLength);
61051          (0,external_wp_a11y_namespaceObject.speak)(message);
61052        }
61053      } else if (isMatch('core/block-editor/duplicate', event)) {
61054        const clientIds = getSelectedBlockClientIds();
61055        if (clientIds.length) {
61056          event.preventDefault();
61057          duplicateBlocks(clientIds);
61058        }
61059      } else if (isMatch('core/block-editor/remove', event)) {
61060        const clientIds = getSelectedBlockClientIds();
61061        if (clientIds.length) {
61062          event.preventDefault();
61063          removeBlocks(clientIds);
61064        }
61065      } else if (isMatch('core/block-editor/insert-after', event)) {
61066        const clientIds = getSelectedBlockClientIds();
61067        if (clientIds.length) {
61068          event.preventDefault();
61069          insertAfterBlock(clientIds[clientIds.length - 1]);
61070        }
61071      } else if (isMatch('core/block-editor/insert-before', event)) {
61072        const clientIds = getSelectedBlockClientIds();
61073        if (clientIds.length) {
61074          event.preventDefault();
61075          insertBeforeBlock(clientIds[0]);
61076        }
61077      } else if (isMatch('core/block-editor/unselect', event)) {
61078        if (event.target.closest('[role=toolbar]')) {
61079          // This shouldn't be necessary, but we have a combination of a few things all combining to create a situation where:
61080          // - Because the block toolbar uses createPortal to populate the block toolbar fills, we can't rely on the React event bubbling to hit the onKeyDown listener for the block toolbar
61081          // - Since we can't use the React tree, we use the DOM tree which _should_ handle the event bubbling correctly from a `createPortal` element.
61082          // - This bubbles via the React tree, which hits this `unselect` escape keypress before the block toolbar DOM event listener has access to it.
61083          // An alternative would be to remove the addEventListener on the navigableToolbar and use this event to handle it directly right here. That feels hacky too though.
61084          return;
61085        }
61086        const clientIds = getSelectedBlockClientIds();
61087        if (clientIds.length > 1) {
61088          event.preventDefault();
61089          // If there is more than one block selected, select the first
61090          // block so that focus is directed back to the beginning of the selection.
61091          // In effect, to the user this feels like deselecting the multi-selection.
61092          selectBlock(clientIds[0]);
61093        }
61094      } else if (isMatch('core/block-editor/collapse-list-view', event)) {
61095        // If focus is currently within a text field, such as a rich text block or other editable field,
61096        // skip collapsing the list view, and allow the keyboard shortcut to be handled by the text field.
61097        // This condition checks for both the active element and the active element within an iframed editor.
61098        if ((0,external_wp_dom_namespaceObject.isTextField)(event.target) || (0,external_wp_dom_namespaceObject.isTextField)(event.target?.contentWindow?.document?.activeElement)) {
61099          return;
61100        }
61101        event.preventDefault();
61102        expandBlock(clientId);
61103      } else if (isMatch('core/block-editor/group', event)) {
61104        const clientIds = getSelectedBlockClientIds();
61105        if (clientIds.length > 1 && isGroupable(clientIds)) {
61106          event.preventDefault();
61107          const blocks = getBlocksByClientId(clientIds);
61108          const groupingBlockName = getGroupingBlockName();
61109          const newBlocks = (0,external_wp_blocks_namespaceObject.switchToBlockType)(blocks, groupingBlockName);
61110          replaceBlocks(clientIds, newBlocks);
61111          (0,external_wp_a11y_namespaceObject.speak)((0,external_wp_i18n_namespaceObject.__)('Selected blocks are grouped.'));
61112        }
61113      }
61114    }
61115    const blockToolbarRef = use_popover_scroll(__unstableContentRef);
61116    const blockToolbarAfterRef = use_popover_scroll(__unstableContentRef);
61117    return (
61118      /*#__PURE__*/
61119      // eslint-disable-next-line jsx-a11y/no-static-element-interactions
61120      (0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
61121        ...props,
61122        onKeyDown: onKeyDown,
61123        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(insertion_point_InsertionPointOpenRef.Provider, {
61124          value: (0,external_wp_element_namespaceObject.useRef)(false),
61125          children: [!isTyping && !isZoomOutMode && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(InsertionPoint, {
61126            __unstableContentRef: __unstableContentRef
61127          }), showEmptyBlockSideInserter && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(EmptyBlockInserter, {
61128            __unstableContentRef: __unstableContentRef,
61129            clientId: clientId
61130          }), showBlockToolbarPopover && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockToolbarPopover, {
61131            __unstableContentRef: __unstableContentRef,
61132            clientId: clientId,
61133            isTyping: isTyping
61134          }), !isZoomOutMode && !hasFixedToolbar && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Popover.Slot, {
61135            name: "block-toolbar",
61136            ref: blockToolbarRef
61137          }), children, /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Popover.Slot, {
61138            name: "__unstable-block-tools-after",
61139            ref: blockToolbarAfterRef
61140          }), isZoomOutMode && !isDragging && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(zoom_out_mode_inserters, {
61141            __unstableContentRef: __unstableContentRef
61142          })]
61143        })
61144      })
61145    );
61146  }
61147  
61148  ;// external ["wp","commands"]
61149  const external_wp_commands_namespaceObject = window["wp"]["commands"];
61150  ;// ./node_modules/@wordpress/icons/build-module/library/ungroup.js
61151  /**
61152   * WordPress dependencies
61153   */
61154  
61155  
61156  const ungroup = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
61157    xmlns: "http://www.w3.org/2000/svg",
61158    viewBox: "0 0 24 24",
61159    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
61160      d: "M18 4h-7c-1.1 0-2 .9-2 2v7c0 1.1.9 2 2 2h7c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2zm.5 9c0 .3-.2.5-.5.5h-7c-.3 0-.5-.2-.5-.5V6c0-.3.2-.5.5-.5h7c.3 0 .5.2.5.5v7zm-5 5c0 .3-.2.5-.5.5H6c-.3 0-.5-.2-.5-.5v-7c0-.3.2-.5.5-.5h1V9H6c-1.1 0-2 .9-2 2v7c0 1.1.9 2 2 2h7c1.1 0 2-.9 2-2v-1h-1.5v1z"
61161    })
61162  });
61163  /* harmony default export */ const library_ungroup = (ungroup);
61164  
61165  ;// ./node_modules/@wordpress/icons/build-module/library/trash.js
61166  /**
61167   * WordPress dependencies
61168   */
61169  
61170  
61171  const trash = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
61172    xmlns: "http://www.w3.org/2000/svg",
61173    viewBox: "0 0 24 24",
61174    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
61175      fillRule: "evenodd",
61176      clipRule: "evenodd",
61177      d: "M12 5.5A2.25 2.25 0 0 0 9.878 7h4.244A2.251 2.251 0 0 0 12 5.5ZM12 4a3.751 3.751 0 0 0-3.675 3H5v1.5h1.27l.818 8.997a2.75 2.75 0 0 0 2.739 2.501h4.347a2.75 2.75 0 0 0 2.738-2.5L17.73 8.5H19V7h-3.325A3.751 3.751 0 0 0 12 4Zm4.224 4.5H7.776l.806 8.861a1.25 1.25 0 0 0 1.245 1.137h4.347a1.25 1.25 0 0 0 1.245-1.137l.805-8.861Z"
61178    })
61179  });
61180  /* harmony default export */ const library_trash = (trash);
61181  
61182  ;// ./node_modules/@wordpress/block-editor/build-module/components/use-block-commands/index.js
61183  /**
61184   * WordPress dependencies
61185   */
61186  
61187  
61188  
61189  
61190  
61191  
61192  /**
61193   * Internal dependencies
61194   */
61195  
61196  
61197  
61198  const getTransformCommands = () => function useTransformCommands() {
61199    const {
61200      replaceBlocks,
61201      multiSelect
61202    } = (0,external_wp_data_namespaceObject.useDispatch)(store);
61203    const {
61204      blocks,
61205      clientIds,
61206      canRemove,
61207      possibleBlockTransformations,
61208      invalidSelection
61209    } = (0,external_wp_data_namespaceObject.useSelect)(select => {
61210      const {
61211        getBlockRootClientId,
61212        getBlockTransformItems,
61213        getSelectedBlockClientIds,
61214        getBlocksByClientId,
61215        canRemoveBlocks
61216      } = select(store);
61217      const selectedBlockClientIds = getSelectedBlockClientIds();
61218      const selectedBlocks = getBlocksByClientId(selectedBlockClientIds);
61219  
61220      // selectedBlocks can have `null`s when something tries to call `selectBlock` with an inexistent clientId.
61221      // These nulls will cause fatal errors down the line.
61222      // In order to prevent discrepancies between selectedBlockClientIds and selectedBlocks, we effectively treat the entire selection as invalid.
61223      // @see https://github.com/WordPress/gutenberg/pull/59410#issuecomment-2006304536
61224      if (selectedBlocks.filter(block => !block).length > 0) {
61225        return {
61226          invalidSelection: true
61227        };
61228      }
61229      const rootClientId = getBlockRootClientId(selectedBlockClientIds[0]);
61230      return {
61231        blocks: selectedBlocks,
61232        clientIds: selectedBlockClientIds,
61233        possibleBlockTransformations: getBlockTransformItems(selectedBlocks, rootClientId),
61234        canRemove: canRemoveBlocks(selectedBlockClientIds),
61235        invalidSelection: false
61236      };
61237    }, []);
61238    if (invalidSelection) {
61239      return {
61240        isLoading: false,
61241        commands: []
61242      };
61243    }
61244    const isTemplate = blocks.length === 1 && (0,external_wp_blocks_namespaceObject.isTemplatePart)(blocks[0]);
61245    function selectForMultipleBlocks(insertedBlocks) {
61246      if (insertedBlocks.length > 1) {
61247        multiSelect(insertedBlocks[0].clientId, insertedBlocks[insertedBlocks.length - 1].clientId);
61248      }
61249    }
61250  
61251    // Simple block transformation based on the `Block Transforms` API.
61252    function onBlockTransform(name) {
61253      const newBlocks = (0,external_wp_blocks_namespaceObject.switchToBlockType)(blocks, name);
61254      replaceBlocks(clientIds, newBlocks);
61255      selectForMultipleBlocks(newBlocks);
61256    }
61257  
61258    /**
61259     * The `isTemplate` check is a stopgap solution here.
61260     * Ideally, the Transforms API should handle this
61261     * by allowing to exclude blocks from wildcard transformations.
61262     */
61263    const hasPossibleBlockTransformations = !!possibleBlockTransformations.length && canRemove && !isTemplate;
61264    if (!clientIds || clientIds.length < 1 || !hasPossibleBlockTransformations) {
61265      return {
61266        isLoading: false,
61267        commands: []
61268      };
61269    }
61270    const commands = possibleBlockTransformations.map(transformation => {
61271      const {
61272        name,
61273        title,
61274        icon
61275      } = transformation;
61276      return {
61277        name: 'core/block-editor/transform-to-' + name.replace('/', '-'),
61278        /* translators: %s: Block or block variation name. */
61279        label: (0,external_wp_i18n_namespaceObject.sprintf)((0,external_wp_i18n_namespaceObject.__)('Transform to %s'), title),
61280        icon: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_icon, {
61281          icon: icon
61282        }),
61283        callback: ({
61284          close
61285        }) => {
61286          onBlockTransform(name);
61287          close();
61288        }
61289      };
61290    });
61291    return {
61292      isLoading: false,
61293      commands
61294    };
61295  };
61296  const getQuickActionsCommands = () => function useQuickActionsCommands() {
61297    const {
61298      clientIds,
61299      isUngroupable,
61300      isGroupable
61301    } = (0,external_wp_data_namespaceObject.useSelect)(select => {
61302      const {
61303        getSelectedBlockClientIds,
61304        isUngroupable: _isUngroupable,
61305        isGroupable: _isGroupable
61306      } = select(store);
61307      const selectedBlockClientIds = getSelectedBlockClientIds();
61308      return {
61309        clientIds: selectedBlockClientIds,
61310        isUngroupable: _isUngroupable(),
61311        isGroupable: _isGroupable()
61312      };
61313    }, []);
61314    const {
61315      canInsertBlockType,
61316      getBlockRootClientId,
61317      getBlocksByClientId,
61318      canRemoveBlocks
61319    } = (0,external_wp_data_namespaceObject.useSelect)(store);
61320    const {
61321      getDefaultBlockName,
61322      getGroupingBlockName
61323    } = (0,external_wp_data_namespaceObject.useSelect)(external_wp_blocks_namespaceObject.store);
61324    const blocks = getBlocksByClientId(clientIds);
61325    const {
61326      removeBlocks,
61327      replaceBlocks,
61328      duplicateBlocks,
61329      insertAfterBlock,
61330      insertBeforeBlock
61331    } = (0,external_wp_data_namespaceObject.useDispatch)(store);
61332    const onGroup = () => {
61333      if (!blocks.length) {
61334        return;
61335      }
61336      const groupingBlockName = getGroupingBlockName();
61337  
61338      // Activate the `transform` on `core/group` which does the conversion.
61339      const newBlocks = (0,external_wp_blocks_namespaceObject.switchToBlockType)(blocks, groupingBlockName);
61340      if (!newBlocks) {
61341        return;
61342      }
61343      replaceBlocks(clientIds, newBlocks);
61344    };
61345    const onUngroup = () => {
61346      if (!blocks.length) {
61347        return;
61348      }
61349      const innerBlocks = blocks[0].innerBlocks;
61350      if (!innerBlocks.length) {
61351        return;
61352      }
61353      replaceBlocks(clientIds, innerBlocks);
61354    };
61355    if (!clientIds || clientIds.length < 1) {
61356      return {
61357        isLoading: false,
61358        commands: []
61359      };
61360    }
61361    const rootClientId = getBlockRootClientId(clientIds[0]);
61362    const canInsertDefaultBlock = canInsertBlockType(getDefaultBlockName(), rootClientId);
61363    const canDuplicate = blocks.every(block => {
61364      return !!block && (0,external_wp_blocks_namespaceObject.hasBlockSupport)(block.name, 'multiple', true) && canInsertBlockType(block.name, rootClientId);
61365    });
61366    const canRemove = canRemoveBlocks(clientIds);
61367    const commands = [];
61368    if (canDuplicate) {
61369      commands.push({
61370        name: 'duplicate',
61371        label: (0,external_wp_i18n_namespaceObject.__)('Duplicate'),
61372        callback: () => duplicateBlocks(clientIds, true),
61373        icon: library_copy
61374      });
61375    }
61376    if (canInsertDefaultBlock) {
61377      commands.push({
61378        name: 'add-before',
61379        label: (0,external_wp_i18n_namespaceObject.__)('Add before'),
61380        callback: () => {
61381          const clientId = Array.isArray(clientIds) ? clientIds[0] : clientId;
61382          insertBeforeBlock(clientId);
61383        },
61384        icon: library_plus
61385      }, {
61386        name: 'add-after',
61387        label: (0,external_wp_i18n_namespaceObject.__)('Add after'),
61388        callback: () => {
61389          const clientId = Array.isArray(clientIds) ? clientIds[clientIds.length - 1] : clientId;
61390          insertAfterBlock(clientId);
61391        },
61392        icon: library_plus
61393      });
61394    }
61395    if (isGroupable) {
61396      commands.push({
61397        name: 'Group',
61398        label: (0,external_wp_i18n_namespaceObject.__)('Group'),
61399        callback: onGroup,
61400        icon: library_group
61401      });
61402    }
61403    if (isUngroupable) {
61404      commands.push({
61405        name: 'ungroup',
61406        label: (0,external_wp_i18n_namespaceObject.__)('Ungroup'),
61407        callback: onUngroup,
61408        icon: library_ungroup
61409      });
61410    }
61411    if (canRemove) {
61412      commands.push({
61413        name: 'remove',
61414        label: (0,external_wp_i18n_namespaceObject.__)('Delete'),
61415        callback: () => removeBlocks(clientIds, true),
61416        icon: library_trash
61417      });
61418    }
61419    return {
61420      isLoading: false,
61421      commands: commands.map(command => ({
61422        ...command,
61423        name: 'core/block-editor/action-' + command.name,
61424        callback: ({
61425          close
61426        }) => {
61427          command.callback();
61428          close();
61429        }
61430      }))
61431    };
61432  };
61433  const useBlockCommands = () => {
61434    (0,external_wp_commands_namespaceObject.useCommandLoader)({
61435      name: 'core/block-editor/blockTransforms',
61436      hook: getTransformCommands()
61437    });
61438    (0,external_wp_commands_namespaceObject.useCommandLoader)({
61439      name: 'core/block-editor/blockQuickActions',
61440      hook: getQuickActionsCommands(),
61441      context: 'block-selection-edit'
61442    });
61443  };
61444  
61445  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-canvas/index.js
61446  /**
61447   * WordPress dependencies
61448   */
61449  
61450  
61451  
61452  
61453  /**
61454   * Internal dependencies
61455   */
61456  
61457  
61458  
61459  
61460  
61461  
61462  
61463  
61464  
61465  
61466  
61467  // EditorStyles is a memoized component, so avoid passing a new
61468  // object reference on each render.
61469  
61470  const EDITOR_STYLE_TRANSFORM_OPTIONS = {
61471    // Don't transform selectors that already specify `.editor-styles-wrapper`.
61472    ignoredSelectors: [/\.editor-styles-wrapper/gi]
61473  };
61474  function ExperimentalBlockCanvas({
61475    shouldIframe = true,
61476    height = '300px',
61477    children = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockList, {}),
61478    styles,
61479    contentRef: contentRefProp,
61480    iframeProps
61481  }) {
61482    useBlockCommands();
61483    const isTabletViewport = (0,external_wp_compose_namespaceObject.useViewportMatch)('medium', '<');
61484    const resetTypingRef = useMouseMoveTypingReset();
61485    const clearerRef = useBlockSelectionClearer();
61486    const localRef = (0,external_wp_element_namespaceObject.useRef)();
61487    const contentRef = (0,external_wp_compose_namespaceObject.useMergeRefs)([contentRefProp, clearerRef, localRef]);
61488    const zoomLevel = (0,external_wp_data_namespaceObject.useSelect)(select => unlock(select(store)).getZoomLevel(), []);
61489    const zoomOutIframeProps = zoomLevel !== 100 && !isTabletViewport ? {
61490      scale: zoomLevel,
61491      frameSize: '40px'
61492    } : {};
61493    if (!shouldIframe) {
61494      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(BlockTools, {
61495        __unstableContentRef: localRef,
61496        className: "block-editor-block-canvas",
61497        style: {
61498          height
61499        },
61500        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(editor_styles, {
61501          styles: styles,
61502          scope: ":where(.editor-styles-wrapper)",
61503          transformOptions: EDITOR_STYLE_TRANSFORM_OPTIONS
61504        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(writing_flow, {
61505          ref: contentRef,
61506          className: "editor-styles-wrapper",
61507          tabIndex: -1,
61508          children: children
61509        })]
61510      });
61511    }
61512    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockTools, {
61513      __unstableContentRef: localRef,
61514      className: "block-editor-block-canvas",
61515      style: {
61516        height,
61517        display: 'flex'
61518      },
61519      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(iframe, {
61520        ...iframeProps,
61521        ...zoomOutIframeProps,
61522        ref: resetTypingRef,
61523        contentRef: contentRef,
61524        style: {
61525          ...iframeProps?.style
61526        },
61527        name: "editor-canvas",
61528        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(editor_styles, {
61529          styles: styles
61530        }), children]
61531      })
61532    });
61533  }
61534  
61535  /**
61536   * BlockCanvas component is a component used to display the canvas of the block editor.
61537   * What we call the canvas is an iframe containing the block list that you can manipulate.
61538   * The component is also responsible of wiring up all the necessary hooks to enable
61539   * the keyboard navigation across blocks in the editor and inject content styles into the iframe.
61540   *
61541   * @example
61542   *
61543   * ```jsx
61544   * function MyBlockEditor() {
61545   *   const [ blocks, updateBlocks ] = useState([]);
61546   *   return (
61547   *     <BlockEditorProvider
61548   *       value={ blocks }
61549   *       onInput={ updateBlocks }
61550   *       onChange={ persistBlocks }
61551   *      >
61552   *        <BlockCanvas height="400px" />
61553   *      </BlockEditorProvider>
61554   *    );
61555   * }
61556   * ```
61557   *
61558   * @param {Object}  props          Component props.
61559   * @param {string}  props.height   Canvas height, defaults to 300px.
61560   * @param {Array}   props.styles   Content styles to inject into the iframe.
61561   * @param {Element} props.children Content of the canvas, defaults to the BlockList component.
61562   * @return {Element}               Block Breadcrumb.
61563   */
61564  function BlockCanvas({
61565    children,
61566    height,
61567    styles
61568  }) {
61569    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ExperimentalBlockCanvas, {
61570      height: height,
61571      styles: styles,
61572      children: children
61573    });
61574  }
61575  /* harmony default export */ const block_canvas = (BlockCanvas);
61576  
61577  ;// ./node_modules/@wordpress/block-editor/build-module/components/color-style-selector/index.js
61578  /**
61579   * WordPress dependencies
61580   */
61581  
61582  
61583  
61584  
61585  
61586  const ColorSelectorSVGIcon = () => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.SVG, {
61587    xmlns: "http://www.w3.org/2000/svg",
61588    viewBox: "0 0 20 20",
61589    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Path, {
61590      d: "M7.434 5l3.18 9.16H8.538l-.692-2.184H4.628l-.705 2.184H2L5.18 5h2.254zm-1.13 1.904h-.115l-1.148 3.593H7.44L6.304 6.904zM14.348 7.006c1.853 0 2.9.876 2.9 2.374v4.78h-1.79v-.914h-.114c-.362.64-1.123 1.022-2.031 1.022-1.346 0-2.292-.826-2.292-2.108 0-1.27.972-2.006 2.71-2.107l1.696-.102V9.38c0-.584-.42-.914-1.18-.914-.667 0-1.112.228-1.264.647h-1.701c.12-1.295 1.307-2.107 3.066-2.107zm1.079 4.1l-1.416.09c-.793.056-1.18.342-1.18.844 0 .52.45.837 1.091.837.857 0 1.505-.545 1.505-1.256v-.515z"
61591    })
61592  });
61593  
61594  /**
61595   * Color Selector Icon component.
61596   *
61597   * @param {Object} props           Component properties.
61598   * @param {Object} props.style     Style object.
61599   * @param {string} props.className Class name for component.
61600   *
61601   * @return {*} React Icon component.
61602   */
61603  const ColorSelectorIcon = ({
61604    style,
61605    className
61606  }) => {
61607    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
61608      className: "block-library-colors-selector__icon-container",
61609      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
61610        className: `$className} block-library-colors-selector__state-selection`,
61611        style: style,
61612        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ColorSelectorSVGIcon, {})
61613      })
61614    });
61615  };
61616  
61617  /**
61618   * Renders the Colors Selector Toolbar with the icon button.
61619   *
61620   * @param {Object} props                 Component properties.
61621   * @param {Object} props.TextColor       Text color component that wraps icon.
61622   * @param {Object} props.BackgroundColor Background color component that wraps icon.
61623   *
61624   * @return {*} React toggle button component.
61625   */
61626  const renderToggleComponent = ({
61627    TextColor,
61628    BackgroundColor
61629  }) => ({
61630    onToggle,
61631    isOpen
61632  }) => {
61633    const openOnArrowDown = event => {
61634      if (!isOpen && event.keyCode === external_wp_keycodes_namespaceObject.DOWN) {
61635        event.preventDefault();
61636        onToggle();
61637      }
61638    };
61639    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarGroup, {
61640      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarButton, {
61641        className: "components-toolbar__control block-library-colors-selector__toggle",
61642        label: (0,external_wp_i18n_namespaceObject.__)('Open Colors Selector'),
61643        onClick: onToggle,
61644        onKeyDown: openOnArrowDown,
61645        icon: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BackgroundColor, {
61646          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(TextColor, {
61647            children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ColorSelectorIcon, {})
61648          })
61649        })
61650      })
61651    });
61652  };
61653  const BlockColorsStyleSelector = ({
61654    children,
61655    ...other
61656  }) => {
61657    external_wp_deprecated_default()(`wp.blockEditor.BlockColorsStyleSelector`, {
61658      alternative: 'block supports API',
61659      since: '6.1',
61660      version: '6.3'
61661    });
61662    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Dropdown, {
61663      popoverProps: {
61664        placement: 'bottom-start'
61665      },
61666      className: "block-library-colors-selector",
61667      contentClassName: "block-library-colors-selector__popover",
61668      renderToggle: renderToggleComponent(other),
61669      renderContent: () => children
61670    });
61671  };
61672  /* harmony default export */ const color_style_selector = (BlockColorsStyleSelector);
61673  
61674  ;// ./node_modules/@wordpress/icons/build-module/library/list-view.js
61675  /**
61676   * WordPress dependencies
61677   */
61678  
61679  
61680  const listView = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
61681    viewBox: "0 0 24 24",
61682    xmlns: "http://www.w3.org/2000/svg",
61683    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
61684      d: "M3 6h11v1.5H3V6Zm3.5 5.5h11V13h-11v-1.5ZM21 17H10v1.5h11V17Z"
61685    })
61686  });
61687  /* harmony default export */ const list_view = (listView);
61688  
61689  ;// ./node_modules/@wordpress/block-editor/build-module/components/list-view/context.js
61690  /**
61691   * WordPress dependencies
61692   */
61693  
61694  const ListViewContext = (0,external_wp_element_namespaceObject.createContext)({});
61695  const useListViewContext = () => (0,external_wp_element_namespaceObject.useContext)(ListViewContext);
61696  
61697  ;// ./node_modules/@wordpress/block-editor/build-module/components/list-view/aria-referenced-text.js
61698  /**
61699   * WordPress dependencies
61700   */
61701  
61702  
61703  /**
61704   * A component specifically designed to be used as an element referenced
61705   * by ARIA attributes such as `aria-labelledby` or `aria-describedby`.
61706   *
61707   * @param {Object}                    props          Props.
61708   * @param {import('react').ReactNode} props.children
61709   */
61710  
61711  function AriaReferencedText({
61712    children,
61713    ...props
61714  }) {
61715    const ref = (0,external_wp_element_namespaceObject.useRef)();
61716    (0,external_wp_element_namespaceObject.useEffect)(() => {
61717      if (ref.current) {
61718        // This seems like a no-op, but it fixes a bug in Firefox where
61719        // it fails to recompute the text when only the text node changes.
61720        // @see https://github.com/WordPress/gutenberg/pull/51035
61721        ref.current.textContent = ref.current.textContent;
61722      }
61723    }, [children]);
61724    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
61725      hidden: true,
61726      ...props,
61727      ref: ref,
61728      children: children
61729    });
61730  }
61731  
61732  ;// ./node_modules/@wordpress/block-editor/build-module/components/list-view/appender.js
61733  /**
61734   * WordPress dependencies
61735   */
61736  
61737  
61738  
61739  
61740  
61741  
61742  /**
61743   * Internal dependencies
61744   */
61745  
61746  
61747  
61748  
61749  
61750  
61751  
61752  const Appender = (0,external_wp_element_namespaceObject.forwardRef)(({
61753    nestingLevel,
61754    blockCount,
61755    clientId,
61756    ...props
61757  }, ref) => {
61758    const {
61759      insertedBlock,
61760      setInsertedBlock
61761    } = useListViewContext();
61762    const instanceId = (0,external_wp_compose_namespaceObject.useInstanceId)(Appender);
61763    const hideInserter = (0,external_wp_data_namespaceObject.useSelect)(select => {
61764      const {
61765        getTemplateLock,
61766        isZoomOut
61767      } = unlock(select(store));
61768      return !!getTemplateLock(clientId) || isZoomOut();
61769    }, [clientId]);
61770    const blockTitle = useBlockDisplayTitle({
61771      clientId,
61772      context: 'list-view'
61773    });
61774    const insertedBlockTitle = useBlockDisplayTitle({
61775      clientId: insertedBlock?.clientId,
61776      context: 'list-view'
61777    });
61778    (0,external_wp_element_namespaceObject.useEffect)(() => {
61779      if (!insertedBlockTitle?.length) {
61780        return;
61781      }
61782      (0,external_wp_a11y_namespaceObject.speak)((0,external_wp_i18n_namespaceObject.sprintf)(
61783      // translators: %s: name of block being inserted (i.e. Paragraph, Image, Group etc)
61784      (0,external_wp_i18n_namespaceObject.__)('%s block inserted'), insertedBlockTitle), 'assertive');
61785    }, [insertedBlockTitle]);
61786    if (hideInserter) {
61787      return null;
61788    }
61789    const descriptionId = `list-view-appender__$instanceId}`;
61790    const description = (0,external_wp_i18n_namespaceObject.sprintf)(/* translators: 1: The name of the block. 2: The numerical position of the block. 3: The level of nesting for the block. */
61791    (0,external_wp_i18n_namespaceObject.__)('Append to %1$s block at position %2$d, Level %3$d'), blockTitle, blockCount + 1, nestingLevel);
61792    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
61793      className: "list-view-appender",
61794      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inserter, {
61795        ref: ref,
61796        rootClientId: clientId,
61797        position: "bottom right",
61798        isAppender: true,
61799        selectBlockOnInsert: false,
61800        shouldDirectInsert: false,
61801        __experimentalIsQuick: true,
61802        ...props,
61803        toggleProps: {
61804          'aria-describedby': descriptionId
61805        },
61806        onSelectOrClose: maybeInsertedBlock => {
61807          if (maybeInsertedBlock?.clientId) {
61808            setInsertedBlock(maybeInsertedBlock);
61809          }
61810        }
61811      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(AriaReferencedText, {
61812        id: descriptionId,
61813        children: description
61814      })]
61815    });
61816  });
61817  
61818  ;// ./node_modules/@wordpress/block-editor/build-module/components/list-view/leaf.js
61819  /**
61820   * External dependencies
61821   */
61822  
61823  
61824  
61825  /**
61826   * WordPress dependencies
61827   */
61828  
61829  
61830  
61831  
61832  /**
61833   * Internal dependencies
61834   */
61835  
61836  
61837  const AnimatedTreeGridRow = dist_esm_it(external_wp_components_namespaceObject.__experimentalTreeGridRow);
61838  const ListViewLeaf = (0,external_wp_element_namespaceObject.forwardRef)(({
61839    isDragged,
61840    isSelected,
61841    position,
61842    level,
61843    rowCount,
61844    children,
61845    className,
61846    path,
61847    ...props
61848  }, ref) => {
61849    const animationRef = use_moving_animation({
61850      clientId: props['data-block'],
61851      enableAnimation: true,
61852      triggerAnimationOnChange: path
61853    });
61854    const mergedRef = (0,external_wp_compose_namespaceObject.useMergeRefs)([ref, animationRef]);
61855    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(AnimatedTreeGridRow, {
61856      ref: mergedRef,
61857      className: dist_clsx('block-editor-list-view-leaf', className),
61858      level: level,
61859      positionInSet: position,
61860      setSize: rowCount,
61861      isExpanded: undefined,
61862      ...props,
61863      children: children
61864    });
61865  });
61866  /* harmony default export */ const leaf = (ListViewLeaf);
61867  
61868  ;// ./node_modules/@wordpress/block-editor/build-module/components/list-view/use-list-view-scroll-into-view.js
61869  /**
61870   * WordPress dependencies
61871   */
61872  
61873  
61874  function useListViewScrollIntoView({
61875    isSelected,
61876    selectedClientIds,
61877    rowItemRef
61878  }) {
61879    const isSingleSelection = selectedClientIds.length === 1;
61880    (0,external_wp_element_namespaceObject.useLayoutEffect)(() => {
61881      // Skip scrolling into view if this particular block isn't selected,
61882      // or if more than one block is selected overall. This is to avoid
61883      // scrolling the view in a multi selection where the user has intentionally
61884      // selected multiple blocks within the list view, but the initially
61885      // selected block may be out of view.
61886      if (!isSelected || !isSingleSelection || !rowItemRef.current) {
61887        return;
61888      }
61889      const scrollContainer = (0,external_wp_dom_namespaceObject.getScrollContainer)(rowItemRef.current);
61890      const {
61891        ownerDocument
61892      } = rowItemRef.current;
61893      const windowScroll = scrollContainer === ownerDocument.body || scrollContainer === ownerDocument.documentElement;
61894  
61895      // If the there is no scroll container, of if the scroll container is the window,
61896      // do not scroll into view, as the block is already in view.
61897      if (windowScroll || !scrollContainer) {
61898        return;
61899      }
61900      const rowRect = rowItemRef.current.getBoundingClientRect();
61901      const scrollContainerRect = scrollContainer.getBoundingClientRect();
61902  
61903      // If the selected block is not currently visible, scroll to it.
61904      if (rowRect.top < scrollContainerRect.top || rowRect.bottom > scrollContainerRect.bottom) {
61905        rowItemRef.current.scrollIntoView();
61906      }
61907    }, [isSelected, isSingleSelection, rowItemRef]);
61908  }
61909  
61910  ;// ./node_modules/@wordpress/icons/build-module/library/pin-small.js
61911  /**
61912   * WordPress dependencies
61913   */
61914  
61915  
61916  const pinSmall = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
61917    width: "24",
61918    height: "24",
61919    viewBox: "0 0 24 24",
61920    xmlns: "http://www.w3.org/2000/svg",
61921    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
61922      d: "M10.97 10.159a3.382 3.382 0 0 0-2.857.955l1.724 1.723-2.836 2.913L7 17h1.25l2.913-2.837 1.723 1.723a3.38 3.38 0 0 0 .606-.825c.33-.63.446-1.343.35-2.032L17 10.695 13.305 7l-2.334 3.159Z"
61923    })
61924  });
61925  /* harmony default export */ const pin_small = (pinSmall);
61926  
61927  ;// ./node_modules/@wordpress/icons/build-module/library/lock-small.js
61928  /**
61929   * WordPress dependencies
61930   */
61931  
61932  
61933  const lockSmall = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
61934    viewBox: "0 0 24 24",
61935    xmlns: "http://www.w3.org/2000/svg",
61936    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
61937      fillRule: "evenodd",
61938      clipRule: "evenodd",
61939      d: "M15 11h-.2V9c0-1.5-1.2-2.8-2.8-2.8S9.2 7.5 9.2 9v2H9c-.6 0-1 .4-1 1v4c0 .6.4 1 1 1h6c.6 0 1-.4 1-1v-4c0-.6-.4-1-1-1zm-1.8 0h-2.5V9c0-.7.6-1.2 1.2-1.2s1.2.6 1.2 1.2v2z"
61940    })
61941  });
61942  /* harmony default export */ const lock_small = (lockSmall);
61943  
61944  ;// ./node_modules/@wordpress/block-editor/build-module/components/list-view/expander.js
61945  /**
61946   * WordPress dependencies
61947   */
61948  
61949  
61950  
61951  function ListViewExpander({
61952    onClick
61953  }) {
61954    return (
61955      /*#__PURE__*/
61956      // Keyboard events are handled by TreeGrid see: components/src/tree-grid/index.js
61957      //
61958      // The expander component is implemented as a pseudo element in the w3 example
61959      // https://www.w3.org/TR/wai-aria-practices/examples/treegrid/treegrid-1.html
61960      //
61961      // We've mimicked this by adding an icon with aria-hidden set to true to hide this from the accessibility tree.
61962      // For the current tree grid implementation, please do not try to make this a button.
61963      //
61964      // eslint-disable-next-line jsx-a11y/click-events-have-key-events,jsx-a11y/no-static-element-interactions
61965      (0,external_ReactJSXRuntime_namespaceObject.jsx)("span", {
61966        className: "block-editor-list-view__expander",
61967        onClick: event => onClick(event, {
61968          forceToggle: true
61969        }),
61970        "aria-hidden": "true",
61971        "data-testid": "list-view-expander",
61972        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(build_module_icon, {
61973          icon: (0,external_wp_i18n_namespaceObject.isRTL)() ? chevron_left_small : chevron_right_small
61974        })
61975      })
61976    );
61977  }
61978  
61979  ;// ./node_modules/@wordpress/block-editor/build-module/components/list-view/use-list-view-images.js
61980  /**
61981   * WordPress dependencies
61982   */
61983  
61984  
61985  
61986  /**
61987   * Internal dependencies
61988   */
61989  
61990  
61991  // Maximum number of images to display in a list view row.
61992  const MAX_IMAGES = 3;
61993  function getImage(block) {
61994    if (block.name !== 'core/image') {
61995      return;
61996    }
61997    if (block.attributes?.url) {
61998      return {
61999        url: block.attributes.url,
62000        alt: block.attributes.alt,
62001        clientId: block.clientId
62002      };
62003    }
62004  }
62005  function getImagesFromGallery(block) {
62006    if (block.name !== 'core/gallery' || !block.innerBlocks) {
62007      return [];
62008    }
62009    const images = [];
62010    for (const innerBlock of block.innerBlocks) {
62011      const img = getImage(innerBlock);
62012      if (img) {
62013        images.push(img);
62014      }
62015      if (images.length >= MAX_IMAGES) {
62016        return images;
62017      }
62018    }
62019    return images;
62020  }
62021  function getImagesFromBlock(block, isExpanded) {
62022    const img = getImage(block);
62023    if (img) {
62024      return [img];
62025    }
62026    return isExpanded ? [] : getImagesFromGallery(block);
62027  }
62028  
62029  /**
62030   * Get a block's preview images for display within a list view row.
62031   *
62032   * TODO: Currently only supports images from the core/image and core/gallery
62033   * blocks. This should be expanded to support other blocks that have images,
62034   * potentially via an API that blocks can opt into / provide their own logic.
62035   *
62036   * @param {Object}  props            Hook properties.
62037   * @param {string}  props.clientId   The block's clientId.
62038   * @param {boolean} props.isExpanded Whether or not the block is expanded in the list view.
62039   * @return {Array} Images.
62040   */
62041  function useListViewImages({
62042    clientId,
62043    isExpanded
62044  }) {
62045    const {
62046      block
62047    } = (0,external_wp_data_namespaceObject.useSelect)(select => {
62048      const _block = select(store).getBlock(clientId);
62049      return {
62050        block: _block
62051      };
62052    }, [clientId]);
62053    const images = (0,external_wp_element_namespaceObject.useMemo)(() => {
62054      return getImagesFromBlock(block, isExpanded);
62055    }, [block, isExpanded]);
62056    return images;
62057  }
62058  
62059  ;// ./node_modules/@wordpress/block-editor/build-module/components/list-view/block-select-button.js
62060  /**
62061   * External dependencies
62062   */
62063  
62064  
62065  /**
62066   * WordPress dependencies
62067   */
62068  
62069  
62070  
62071  
62072  
62073  
62074  /**
62075   * Internal dependencies
62076   */
62077  
62078  
62079  
62080  
62081  
62082  
62083  
62084  
62085  
62086  const {
62087    Badge: block_select_button_Badge
62088  } = unlock(external_wp_components_namespaceObject.privateApis);
62089  function ListViewBlockSelectButton({
62090    className,
62091    block: {
62092      clientId
62093    },
62094    onClick,
62095    onContextMenu,
62096    onMouseDown,
62097    onToggleExpanded,
62098    tabIndex,
62099    onFocus,
62100    onDragStart,
62101    onDragEnd,
62102    draggable,
62103    isExpanded,
62104    ariaDescribedBy
62105  }, ref) {
62106    const blockInformation = useBlockDisplayInformation(clientId);
62107    const blockTitle = useBlockDisplayTitle({
62108      clientId,
62109      context: 'list-view'
62110    });
62111    const {
62112      isLocked
62113    } = useBlockLock(clientId);
62114    const {
62115      isContentOnly
62116    } = (0,external_wp_data_namespaceObject.useSelect)(select => ({
62117      isContentOnly: select(store).getBlockEditingMode(clientId) === 'contentOnly'
62118    }), [clientId]);
62119    const shouldShowLockIcon = isLocked && !isContentOnly;
62120    const isSticky = blockInformation?.positionType === 'sticky';
62121    const images = useListViewImages({
62122      clientId,
62123      isExpanded
62124    });
62125  
62126    // The `href` attribute triggers the browser's native HTML drag operations.
62127    // When the link is dragged, the element's outerHTML is set in DataTransfer object as text/html.
62128    // We need to clear any HTML drag data to prevent `pasteHandler` from firing
62129    // inside the `useOnBlockDrop` hook.
62130    const onDragStartHandler = event => {
62131      event.dataTransfer.clearData();
62132      onDragStart?.(event);
62133    };
62134  
62135    /**
62136     * @param {KeyboardEvent} event
62137     */
62138    function onKeyDown(event) {
62139      if (event.keyCode === external_wp_keycodes_namespaceObject.ENTER || event.keyCode === external_wp_keycodes_namespaceObject.SPACE) {
62140        onClick(event);
62141      }
62142    }
62143    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("a", {
62144      className: dist_clsx('block-editor-list-view-block-select-button', className),
62145      onClick: onClick,
62146      onContextMenu: onContextMenu,
62147      onKeyDown: onKeyDown,
62148      onMouseDown: onMouseDown,
62149      ref: ref,
62150      tabIndex: tabIndex,
62151      onFocus: onFocus,
62152      onDragStart: onDragStartHandler,
62153      onDragEnd: onDragEnd,
62154      draggable: draggable,
62155      href: `#block-$clientId}`,
62156      "aria-describedby": ariaDescribedBy,
62157      "aria-expanded": isExpanded,
62158      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ListViewExpander, {
62159        onClick: onToggleExpanded
62160      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_icon, {
62161        icon: blockInformation?.icon,
62162        showColors: true,
62163        context: "list-view"
62164      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalHStack, {
62165        alignment: "center",
62166        className: "block-editor-list-view-block-select-button__label-wrapper",
62167        justify: "flex-start",
62168        spacing: 1,
62169        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("span", {
62170          className: "block-editor-list-view-block-select-button__title",
62171          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalTruncate, {
62172            ellipsizeMode: "auto",
62173            children: blockTitle
62174          })
62175        }), blockInformation?.anchor && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("span", {
62176          className: "block-editor-list-view-block-select-button__anchor-wrapper",
62177          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_select_button_Badge, {
62178            className: "block-editor-list-view-block-select-button__anchor",
62179            children: blockInformation.anchor
62180          })
62181        }), isSticky && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("span", {
62182          className: "block-editor-list-view-block-select-button__sticky",
62183          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(build_module_icon, {
62184            icon: pin_small
62185          })
62186        }), images.length ? /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("span", {
62187          className: "block-editor-list-view-block-select-button__images",
62188          "aria-hidden": true,
62189          children: images.map((image, index) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("span", {
62190            className: "block-editor-list-view-block-select-button__image",
62191            style: {
62192              backgroundImage: `url($image.url})`,
62193              zIndex: images.length - index // Ensure the first image is on top, and subsequent images are behind.
62194            }
62195          }, image.clientId))
62196        }) : null, shouldShowLockIcon && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("span", {
62197          className: "block-editor-list-view-block-select-button__lock",
62198          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(build_module_icon, {
62199            icon: lock_small
62200          })
62201        })]
62202      })]
62203    });
62204  }
62205  /* harmony default export */ const block_select_button = ((0,external_wp_element_namespaceObject.forwardRef)(ListViewBlockSelectButton));
62206  
62207  ;// ./node_modules/@wordpress/block-editor/build-module/components/list-view/block-contents.js
62208  /**
62209   * WordPress dependencies
62210   */
62211  
62212  
62213  /**
62214   * Internal dependencies
62215   */
62216  
62217  
62218  
62219  
62220  const ListViewBlockContents = (0,external_wp_element_namespaceObject.forwardRef)(({
62221    onClick,
62222    onToggleExpanded,
62223    block,
62224    isSelected,
62225    position,
62226    siblingBlockCount,
62227    level,
62228    isExpanded,
62229    selectedClientIds,
62230    ...props
62231  }, ref) => {
62232    const {
62233      clientId
62234    } = block;
62235    const {
62236      AdditionalBlockContent,
62237      insertedBlock,
62238      setInsertedBlock
62239    } = useListViewContext();
62240  
62241    // Only include all selected blocks if the currently clicked on block
62242    // is one of the selected blocks. This ensures that if a user attempts
62243    // to drag a block that isn't part of the selection, they're still able
62244    // to drag it and rearrange its position.
62245    const draggableClientIds = selectedClientIds.includes(clientId) ? selectedClientIds : [clientId];
62246    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
62247      children: [AdditionalBlockContent && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(AdditionalBlockContent, {
62248        block: block,
62249        insertedBlock: insertedBlock,
62250        setInsertedBlock: setInsertedBlock
62251      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_draggable, {
62252        appendToOwnerDocument: true,
62253        clientIds: draggableClientIds,
62254        cloneClassname: "block-editor-list-view-draggable-chip",
62255        children: ({
62256          draggable,
62257          onDragStart,
62258          onDragEnd
62259        }) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_select_button, {
62260          ref: ref,
62261          className: "block-editor-list-view-block-contents",
62262          block: block,
62263          onClick: onClick,
62264          onToggleExpanded: onToggleExpanded,
62265          isSelected: isSelected,
62266          position: position,
62267          siblingBlockCount: siblingBlockCount,
62268          level: level,
62269          draggable: draggable,
62270          onDragStart: onDragStart,
62271          onDragEnd: onDragEnd,
62272          isExpanded: isExpanded,
62273          ...props
62274        })
62275      })]
62276    });
62277  });
62278  /* harmony default export */ const block_contents = (ListViewBlockContents);
62279  
62280  ;// ./node_modules/@wordpress/block-editor/build-module/components/list-view/utils.js
62281  /**
62282   * WordPress dependencies
62283   */
62284  
62285  
62286  const getBlockPositionDescription = (position, siblingCount, level) => (0,external_wp_i18n_namespaceObject.sprintf)(/* translators: 1: The numerical position of the block. 2: The total number of blocks. 3. The level of nesting for the block. */
62287  (0,external_wp_i18n_namespaceObject.__)('Block %1$d of %2$d, Level %3$d.'), position, siblingCount, level);
62288  const getBlockPropertiesDescription = (blockInformation, isLocked) => [blockInformation?.positionLabel ? `${(0,external_wp_i18n_namespaceObject.sprintf)(
62289  // translators: %s: Position of selected block, e.g. "Sticky" or "Fixed".
62290  (0,external_wp_i18n_namespaceObject.__)('Position: %s'), blockInformation.positionLabel)}.` : undefined, isLocked ? (0,external_wp_i18n_namespaceObject.__)('This block is locked.') : undefined].filter(Boolean).join(' ');
62291  
62292  /**
62293   * Returns true if the client ID occurs within the block selection or multi-selection,
62294   * or false otherwise.
62295   *
62296   * @param {string}          clientId               Block client ID.
62297   * @param {string|string[]} selectedBlockClientIds Selected block client ID, or an array of multi-selected blocks client IDs.
62298   *
62299   * @return {boolean} Whether the block is in multi-selection set.
62300   */
62301  const isClientIdSelected = (clientId, selectedBlockClientIds) => Array.isArray(selectedBlockClientIds) && selectedBlockClientIds.length ? selectedBlockClientIds.indexOf(clientId) !== -1 : selectedBlockClientIds === clientId;
62302  
62303  /**
62304   * From a start and end clientId of potentially different nesting levels,
62305   * return the nearest-depth ids that have a common level of depth in the
62306   * nesting hierarchy. For multiple block selection, this ensure that the
62307   * selection is always at the same nesting level, and not split across
62308   * separate levels.
62309   *
62310   * @param {string}   startId      The first id of a selection.
62311   * @param {string}   endId        The end id of a selection, usually one that has been clicked on.
62312   * @param {string[]} startParents An array of ancestor ids for the start id, in descending order.
62313   * @param {string[]} endParents   An array of ancestor ids for the end id, in descending order.
62314   * @return {Object} An object containing the start and end ids.
62315   */
62316  function getCommonDepthClientIds(startId, endId, startParents, endParents) {
62317    const startPath = [...startParents, startId];
62318    const endPath = [...endParents, endId];
62319    const depth = Math.min(startPath.length, endPath.length) - 1;
62320    const start = startPath[depth];
62321    const end = endPath[depth];
62322    return {
62323      start,
62324      end
62325    };
62326  }
62327  
62328  /**
62329   * Shift focus to the list view item associated with a particular clientId.
62330   *
62331   * @typedef {import('@wordpress/element').RefObject} RefObject
62332   *
62333   * @param {string}       focusClientId   The client ID of the block to focus.
62334   * @param {?HTMLElement} treeGridElement The container element to search within.
62335   */
62336  function focusListItem(focusClientId, treeGridElement) {
62337    const getFocusElement = () => {
62338      const row = treeGridElement?.querySelector(`[role=row][data-block="$focusClientId}"]`);
62339      if (!row) {
62340        return null;
62341      }
62342      // Focus the first focusable in the row, which is the ListViewBlockSelectButton.
62343      return external_wp_dom_namespaceObject.focus.focusable.find(row)[0];
62344    };
62345    let focusElement = getFocusElement();
62346    if (focusElement) {
62347      focusElement.focus();
62348    } else {
62349      // The element hasn't been painted yet. Defer focusing on the next frame.
62350      // This could happen when all blocks have been deleted and the default block
62351      // hasn't been added to the editor yet.
62352      window.requestAnimationFrame(() => {
62353        focusElement = getFocusElement();
62354  
62355        // Ignore if the element still doesn't exist.
62356        if (focusElement) {
62357          focusElement.focus();
62358        }
62359      });
62360    }
62361  }
62362  
62363  /**
62364   * Get values for the block that flag whether the block should be displaced up or down,
62365   * whether the block is being nested, and whether the block appears after the dragged
62366   * blocks. These values are used to determine the class names to apply to the block.
62367   * The list view rows are displaced visually via CSS rules. Displacement rules:
62368   * - `normal`: no displacement — used to apply a translateY of `0` so that the block
62369   *  appears in its original position, and moves to that position smoothly when dragging
62370   *  outside of the list view area.
62371   * - `up`: the block should be displaced up, creating room beneath the block for the drop indicator.
62372   * - `down`: the block should be displaced down, creating room above the block for the drop indicator.
62373   *
62374   * @param {Object}                props
62375   * @param {Object}                props.blockIndexes           The indexes of all the blocks in the list view, keyed by clientId.
62376   * @param {number|null|undefined} props.blockDropTargetIndex   The index of the block that the user is dropping to.
62377   * @param {?string}               props.blockDropPosition      The position relative to the block that the user is dropping to.
62378   * @param {string}                props.clientId               The client id for the current block.
62379   * @param {?number}               props.firstDraggedBlockIndex The index of the first dragged block.
62380   * @param {?boolean}              props.isDragged              Whether the current block is being dragged. Dragged blocks skip displacement.
62381   * @return {Object} An object containing the `displacement`, `isAfterDraggedBlocks` and `isNesting` values.
62382   */
62383  function getDragDisplacementValues({
62384    blockIndexes,
62385    blockDropTargetIndex,
62386    blockDropPosition,
62387    clientId,
62388    firstDraggedBlockIndex,
62389    isDragged
62390  }) {
62391    let displacement;
62392    let isNesting;
62393    let isAfterDraggedBlocks;
62394    if (!isDragged) {
62395      isNesting = false;
62396      const thisBlockIndex = blockIndexes[clientId];
62397      isAfterDraggedBlocks = thisBlockIndex > firstDraggedBlockIndex;
62398  
62399      // Determine where to displace the position of the current block, relative
62400      // to the blocks being dragged (in their original position) and the drop target
62401      // (the position where a user is currently dragging the blocks to).
62402      if (blockDropTargetIndex !== undefined && blockDropTargetIndex !== null && firstDraggedBlockIndex !== undefined) {
62403        // If the block is being dragged and there is a valid drop target,
62404        // determine if the block being rendered should be displaced up or down.
62405  
62406        if (thisBlockIndex !== undefined) {
62407          if (thisBlockIndex >= firstDraggedBlockIndex && thisBlockIndex < blockDropTargetIndex) {
62408            // If the current block appears after the set of dragged blocks
62409            // (in their original position), but is before the drop target,
62410            // then the current block should be displaced up.
62411            displacement = 'up';
62412          } else if (thisBlockIndex < firstDraggedBlockIndex && thisBlockIndex >= blockDropTargetIndex) {
62413            // If the current block appears before the set of dragged blocks
62414            // (in their original position), but is after the drop target,
62415            // then the current block should be displaced down.
62416            displacement = 'down';
62417          } else {
62418            displacement = 'normal';
62419          }
62420          isNesting = typeof blockDropTargetIndex === 'number' && blockDropTargetIndex - 1 === thisBlockIndex && blockDropPosition === 'inside';
62421        }
62422      } else if (blockDropTargetIndex === null && firstDraggedBlockIndex !== undefined) {
62423        // A `null` value for `blockDropTargetIndex` indicates that the
62424        // drop target is outside of the valid areas within the list view.
62425        // In this case, the drag is still active, but as there is no
62426        // valid drop target, we should remove the gap indicating where
62427        // the block would be inserted.
62428        if (thisBlockIndex !== undefined && thisBlockIndex >= firstDraggedBlockIndex) {
62429          displacement = 'up';
62430        } else {
62431          displacement = 'normal';
62432        }
62433      } else if (blockDropTargetIndex !== undefined && blockDropTargetIndex !== null && firstDraggedBlockIndex === undefined) {
62434        // If the blockdrop target is defined, but there are no dragged blocks,
62435        // then the block should be displaced relative to the drop target.
62436        if (thisBlockIndex !== undefined) {
62437          if (thisBlockIndex < blockDropTargetIndex) {
62438            displacement = 'normal';
62439          } else {
62440            displacement = 'down';
62441          }
62442        }
62443      } else if (blockDropTargetIndex === null) {
62444        displacement = 'normal';
62445      }
62446    }
62447    return {
62448      displacement,
62449      isNesting,
62450      isAfterDraggedBlocks
62451    };
62452  }
62453  
62454  ;// ./node_modules/@wordpress/block-editor/build-module/components/list-view/block.js
62455  /**
62456   * External dependencies
62457   */
62458  
62459  
62460  /**
62461   * WordPress dependencies
62462   */
62463  
62464  
62465  
62466  
62467  
62468  
62469  
62470  
62471  
62472  
62473  
62474  
62475  /**
62476   * Internal dependencies
62477   */
62478  
62479  
62480  
62481  
62482  
62483  
62484  
62485  
62486  
62487  
62488  
62489  
62490  function ListViewBlock({
62491    block: {
62492      clientId
62493    },
62494    displacement,
62495    isAfterDraggedBlocks,
62496    isDragged,
62497    isNesting,
62498    isSelected,
62499    isBranchSelected,
62500    selectBlock,
62501    position,
62502    level,
62503    rowCount,
62504    siblingBlockCount,
62505    showBlockMovers,
62506    path,
62507    isExpanded,
62508    selectedClientIds,
62509    isSyncedBranch
62510  }) {
62511    const cellRef = (0,external_wp_element_namespaceObject.useRef)(null);
62512    const rowRef = (0,external_wp_element_namespaceObject.useRef)(null);
62513    const settingsRef = (0,external_wp_element_namespaceObject.useRef)(null);
62514    const [isHovered, setIsHovered] = (0,external_wp_element_namespaceObject.useState)(false);
62515    const [settingsAnchorRect, setSettingsAnchorRect] = (0,external_wp_element_namespaceObject.useState)();
62516    const {
62517      isLocked,
62518      canEdit,
62519      canMove
62520    } = useBlockLock(clientId);
62521    const isFirstSelectedBlock = isSelected && selectedClientIds[0] === clientId;
62522    const isLastSelectedBlock = isSelected && selectedClientIds[selectedClientIds.length - 1] === clientId;
62523    const {
62524      toggleBlockHighlight,
62525      duplicateBlocks,
62526      multiSelect,
62527      replaceBlocks,
62528      removeBlocks,
62529      insertAfterBlock,
62530      insertBeforeBlock,
62531      setOpenedBlockSettingsMenu
62532    } = unlock((0,external_wp_data_namespaceObject.useDispatch)(store));
62533    const {
62534      canInsertBlockType,
62535      getSelectedBlockClientIds,
62536      getPreviousBlockClientId,
62537      getBlockRootClientId,
62538      getBlockOrder,
62539      getBlockParents,
62540      getBlocksByClientId,
62541      canRemoveBlocks,
62542      isGroupable
62543    } = (0,external_wp_data_namespaceObject.useSelect)(store);
62544    const {
62545      getGroupingBlockName
62546    } = (0,external_wp_data_namespaceObject.useSelect)(external_wp_blocks_namespaceObject.store);
62547    const blockInformation = useBlockDisplayInformation(clientId);
62548    const {
62549      block,
62550      blockName,
62551      allowRightClickOverrides
62552    } = (0,external_wp_data_namespaceObject.useSelect)(select => {
62553      const {
62554        getBlock,
62555        getBlockName,
62556        getSettings
62557      } = select(store);
62558      return {
62559        block: getBlock(clientId),
62560        blockName: getBlockName(clientId),
62561        allowRightClickOverrides: getSettings().allowRightClickOverrides
62562      };
62563    }, [clientId]);
62564    const showBlockActions =
62565    // When a block hides its toolbar it also hides the block settings menu,
62566    // since that menu is part of the toolbar in the editor canvas.
62567    // List View respects this by also hiding the block settings menu.
62568    (0,external_wp_blocks_namespaceObject.hasBlockSupport)(blockName, '__experimentalToolbar', true);
62569    const instanceId = (0,external_wp_compose_namespaceObject.useInstanceId)(ListViewBlock);
62570    const descriptionId = `list-view-block-select-button__description-$instanceId}`;
62571    const {
62572      expand,
62573      collapse,
62574      collapseAll,
62575      BlockSettingsMenu,
62576      listViewInstanceId,
62577      expandedState,
62578      setInsertedBlock,
62579      treeGridElementRef,
62580      rootClientId
62581    } = useListViewContext();
62582    const isMatch = (0,external_wp_keyboardShortcuts_namespaceObject.__unstableUseShortcutEventMatch)();
62583  
62584    // Determine which blocks to update:
62585    // If the current (focused) block is part of the block selection, use the whole selection.
62586    // If the focused block is not part of the block selection, only update the focused block.
62587    function getBlocksToUpdate() {
62588      const selectedBlockClientIds = getSelectedBlockClientIds();
62589      const isUpdatingSelectedBlocks = selectedBlockClientIds.includes(clientId);
62590      const firstBlockClientId = isUpdatingSelectedBlocks ? selectedBlockClientIds[0] : clientId;
62591      const firstBlockRootClientId = getBlockRootClientId(firstBlockClientId);
62592      const blocksToUpdate = isUpdatingSelectedBlocks ? selectedBlockClientIds : [clientId];
62593      return {
62594        blocksToUpdate,
62595        firstBlockClientId,
62596        firstBlockRootClientId,
62597        selectedBlockClientIds
62598      };
62599    }
62600  
62601    /**
62602     * @param {KeyboardEvent} event
62603     */
62604    async function onKeyDown(event) {
62605      if (event.defaultPrevented) {
62606        return;
62607      }
62608  
62609      // Do not handle events if it comes from modals;
62610      // retain the default behavior for these keys.
62611      if (event.target.closest('[role=dialog]')) {
62612        return;
62613      }
62614      const isDeleteKey = [external_wp_keycodes_namespaceObject.BACKSPACE, external_wp_keycodes_namespaceObject.DELETE].includes(event.keyCode);
62615  
62616      // If multiple blocks are selected, deselect all blocks when the user
62617      // presses the escape key.
62618      if (isMatch('core/block-editor/unselect', event) && selectedClientIds.length > 0) {
62619        event.stopPropagation();
62620        event.preventDefault();
62621        selectBlock(event, undefined);
62622      } else if (isDeleteKey || isMatch('core/block-editor/remove', event)) {
62623        var _getPreviousBlockClie;
62624        const {
62625          blocksToUpdate: blocksToDelete,
62626          firstBlockClientId,
62627          firstBlockRootClientId,
62628          selectedBlockClientIds
62629        } = getBlocksToUpdate();
62630  
62631        // Don't update the selection if the blocks cannot be deleted.
62632        if (!canRemoveBlocks(blocksToDelete)) {
62633          return;
62634        }
62635        let blockToFocus = (_getPreviousBlockClie = getPreviousBlockClientId(firstBlockClientId)) !== null && _getPreviousBlockClie !== void 0 ? _getPreviousBlockClie :
62636        // If the previous block is not found (when the first block is deleted),
62637        // fallback to focus the parent block.
62638        firstBlockRootClientId;
62639        removeBlocks(blocksToDelete, false);
62640  
62641        // Update the selection if the original selection has been removed.
62642        const shouldUpdateSelection = selectedBlockClientIds.length > 0 && getSelectedBlockClientIds().length === 0;
62643  
62644        // If there's no previous block nor parent block, focus the first block.
62645        if (!blockToFocus) {
62646          blockToFocus = getBlockOrder()[0];
62647        }
62648        updateFocusAndSelection(blockToFocus, shouldUpdateSelection);
62649      } else if (isMatch('core/block-editor/duplicate', event)) {
62650        event.preventDefault();
62651        const {
62652          blocksToUpdate,
62653          firstBlockRootClientId
62654        } = getBlocksToUpdate();
62655        const canDuplicate = getBlocksByClientId(blocksToUpdate).every(blockToUpdate => {
62656          return !!blockToUpdate && (0,external_wp_blocks_namespaceObject.hasBlockSupport)(blockToUpdate.name, 'multiple', true) && canInsertBlockType(blockToUpdate.name, firstBlockRootClientId);
62657        });
62658        if (canDuplicate) {
62659          const updatedBlocks = await duplicateBlocks(blocksToUpdate, false);
62660          if (updatedBlocks?.length) {
62661            // If blocks have been duplicated, focus the first duplicated block.
62662            updateFocusAndSelection(updatedBlocks[0], false);
62663          }
62664        }
62665      } else if (isMatch('core/block-editor/insert-before', event)) {
62666        event.preventDefault();
62667        const {
62668          blocksToUpdate
62669        } = getBlocksToUpdate();
62670        await insertBeforeBlock(blocksToUpdate[0]);
62671        const newlySelectedBlocks = getSelectedBlockClientIds();
62672  
62673        // Focus the first block of the newly inserted blocks, to keep focus within the list view.
62674        setOpenedBlockSettingsMenu(undefined);
62675        updateFocusAndSelection(newlySelectedBlocks[0], false);
62676      } else if (isMatch('core/block-editor/insert-after', event)) {
62677        event.preventDefault();
62678        const {
62679          blocksToUpdate
62680        } = getBlocksToUpdate();
62681        await insertAfterBlock(blocksToUpdate.at(-1));
62682        const newlySelectedBlocks = getSelectedBlockClientIds();
62683  
62684        // Focus the first block of the newly inserted blocks, to keep focus within the list view.
62685        setOpenedBlockSettingsMenu(undefined);
62686        updateFocusAndSelection(newlySelectedBlocks[0], false);
62687      } else if (isMatch('core/block-editor/select-all', event)) {
62688        event.preventDefault();
62689        const {
62690          firstBlockRootClientId,
62691          selectedBlockClientIds
62692        } = getBlocksToUpdate();
62693        const blockClientIds = getBlockOrder(firstBlockRootClientId);
62694        if (!blockClientIds.length) {
62695          return;
62696        }
62697  
62698        // If we have selected all sibling nested blocks, try selecting up a level.
62699        // This is a similar implementation to that used by `useSelectAll`.
62700        // `isShallowEqual` is used for the list view instead of a length check,
62701        // as the array of siblings of the currently focused block may be a different
62702        // set of blocks from the current block selection if the user is focused
62703        // on a different part of the list view from the block selection.
62704        if (external_wp_isShallowEqual_default()(selectedBlockClientIds, blockClientIds)) {
62705          // Only select up a level if the first block is not the root block.
62706          // This ensures that the block selection can't break out of the root block
62707          // used by the list view, if the list view is only showing a partial hierarchy.
62708          if (firstBlockRootClientId && firstBlockRootClientId !== rootClientId) {
62709            updateFocusAndSelection(firstBlockRootClientId, true);
62710            return;
62711          }
62712        }
62713  
62714        // Select all while passing `null` to skip focusing to the editor canvas,
62715        // and retain focus within the list view.
62716        multiSelect(blockClientIds[0], blockClientIds[blockClientIds.length - 1], null);
62717      } else if (isMatch('core/block-editor/collapse-list-view', event)) {
62718        event.preventDefault();
62719        const {
62720          firstBlockClientId
62721        } = getBlocksToUpdate();
62722        const blockParents = getBlockParents(firstBlockClientId, false);
62723        // Collapse all blocks.
62724        collapseAll();
62725        // Expand all parents of the current block.
62726        expand(blockParents);
62727      } else if (isMatch('core/block-editor/group', event)) {
62728        const {
62729          blocksToUpdate
62730        } = getBlocksToUpdate();
62731        if (blocksToUpdate.length > 1 && isGroupable(blocksToUpdate)) {
62732          event.preventDefault();
62733          const blocks = getBlocksByClientId(blocksToUpdate);
62734          const groupingBlockName = getGroupingBlockName();
62735          const newBlocks = (0,external_wp_blocks_namespaceObject.switchToBlockType)(blocks, groupingBlockName);
62736          replaceBlocks(blocksToUpdate, newBlocks);
62737          (0,external_wp_a11y_namespaceObject.speak)((0,external_wp_i18n_namespaceObject.__)('Selected blocks are grouped.'));
62738          const newlySelectedBlocks = getSelectedBlockClientIds();
62739          // Focus the first block of the newly inserted blocks, to keep focus within the list view.
62740          setOpenedBlockSettingsMenu(undefined);
62741          updateFocusAndSelection(newlySelectedBlocks[0], false);
62742        }
62743      }
62744    }
62745    const onMouseEnter = (0,external_wp_element_namespaceObject.useCallback)(() => {
62746      setIsHovered(true);
62747      toggleBlockHighlight(clientId, true);
62748    }, [clientId, setIsHovered, toggleBlockHighlight]);
62749    const onMouseLeave = (0,external_wp_element_namespaceObject.useCallback)(() => {
62750      setIsHovered(false);
62751      toggleBlockHighlight(clientId, false);
62752    }, [clientId, setIsHovered, toggleBlockHighlight]);
62753    const selectEditorBlock = (0,external_wp_element_namespaceObject.useCallback)(event => {
62754      selectBlock(event, clientId);
62755      event.preventDefault();
62756    }, [clientId, selectBlock]);
62757    const updateFocusAndSelection = (0,external_wp_element_namespaceObject.useCallback)((focusClientId, shouldSelectBlock) => {
62758      if (shouldSelectBlock) {
62759        selectBlock(undefined, focusClientId, null, null);
62760      }
62761      focusListItem(focusClientId, treeGridElementRef?.current);
62762    }, [selectBlock, treeGridElementRef]);
62763    const toggleExpanded = (0,external_wp_element_namespaceObject.useCallback)(event => {
62764      // Prevent shift+click from opening link in a new window when toggling.
62765      event.preventDefault();
62766      event.stopPropagation();
62767      if (isExpanded === true) {
62768        collapse(clientId);
62769      } else if (isExpanded === false) {
62770        expand(clientId);
62771      }
62772    }, [clientId, expand, collapse, isExpanded]);
62773  
62774    // Allow right-clicking an item in the List View to open up the block settings dropdown.
62775    const onContextMenu = (0,external_wp_element_namespaceObject.useCallback)(event => {
62776      if (showBlockActions && allowRightClickOverrides) {
62777        settingsRef.current?.click();
62778        // Ensure the position of the settings dropdown is at the cursor.
62779        setSettingsAnchorRect(new window.DOMRect(event.clientX, event.clientY, 0, 0));
62780        event.preventDefault();
62781      }
62782    }, [allowRightClickOverrides, settingsRef, showBlockActions]);
62783    const onMouseDown = (0,external_wp_element_namespaceObject.useCallback)(event => {
62784      // Prevent right-click from focusing the block,
62785      // because focus will be handled when opening the block settings dropdown.
62786      if (allowRightClickOverrides && event.button === 2) {
62787        event.preventDefault();
62788      }
62789    }, [allowRightClickOverrides]);
62790    const settingsPopoverAnchor = (0,external_wp_element_namespaceObject.useMemo)(() => {
62791      const {
62792        ownerDocument
62793      } = rowRef?.current || {};
62794  
62795      // If no custom position is set, the settings dropdown will be anchored to the
62796      // DropdownMenu toggle button.
62797      if (!settingsAnchorRect || !ownerDocument) {
62798        return undefined;
62799      }
62800  
62801      // Position the settings dropdown at the cursor when right-clicking a block.
62802      return {
62803        ownerDocument,
62804        getBoundingClientRect() {
62805          return settingsAnchorRect;
62806        }
62807      };
62808    }, [settingsAnchorRect]);
62809    const clearSettingsAnchorRect = (0,external_wp_element_namespaceObject.useCallback)(() => {
62810      // Clear the custom position for the settings dropdown so that it is restored back
62811      // to being anchored to the DropdownMenu toggle button.
62812      setSettingsAnchorRect(undefined);
62813    }, [setSettingsAnchorRect]);
62814  
62815    // Pass in a ref to the row, so that it can be scrolled
62816    // into view when selected. For long lists, the placeholder for the
62817    // selected block is also observed, within ListViewLeafPlaceholder.
62818    useListViewScrollIntoView({
62819      isSelected,
62820      rowItemRef: rowRef,
62821      selectedClientIds
62822    });
62823  
62824    // When switching between rendering modes (such as template preview and content only),
62825    // it is possible for a block to temporarily be unavailable. In this case, we should not
62826    // render the leaf, to avoid errors further down the tree.
62827    if (!block) {
62828      return null;
62829    }
62830    const blockPositionDescription = getBlockPositionDescription(position, siblingBlockCount, level);
62831    const blockPropertiesDescription = getBlockPropertiesDescription(blockInformation, isLocked);
62832    const hasSiblings = siblingBlockCount > 0;
62833    const hasRenderedMovers = showBlockMovers && hasSiblings;
62834    const moverCellClassName = dist_clsx('block-editor-list-view-block__mover-cell', {
62835      'is-visible': isHovered || isSelected
62836    });
62837    const listViewBlockSettingsClassName = dist_clsx('block-editor-list-view-block__menu-cell', {
62838      'is-visible': isHovered || isFirstSelectedBlock
62839    });
62840    let colSpan;
62841    if (hasRenderedMovers) {
62842      colSpan = 2;
62843    } else if (!showBlockActions) {
62844      colSpan = 3;
62845    }
62846    const classes = dist_clsx({
62847      'is-selected': isSelected,
62848      'is-first-selected': isFirstSelectedBlock,
62849      'is-last-selected': isLastSelectedBlock,
62850      'is-branch-selected': isBranchSelected,
62851      'is-synced-branch': isSyncedBranch,
62852      'is-dragging': isDragged,
62853      'has-single-cell': !showBlockActions,
62854      'is-synced': blockInformation?.isSynced,
62855      'is-draggable': canMove,
62856      'is-displacement-normal': displacement === 'normal',
62857      'is-displacement-up': displacement === 'up',
62858      'is-displacement-down': displacement === 'down',
62859      'is-after-dragged-blocks': isAfterDraggedBlocks,
62860      'is-nesting': isNesting
62861    });
62862  
62863    // Only include all selected blocks if the currently clicked on block
62864    // is one of the selected blocks. This ensures that if a user attempts
62865    // to alter a block that isn't part of the selection, they're still able
62866    // to do so.
62867    const dropdownClientIds = selectedClientIds.includes(clientId) ? selectedClientIds : [clientId];
62868  
62869    // Detect if there is a block in the canvas currently being edited and multi-selection is not happening.
62870    const currentlyEditingBlockInCanvas = isSelected && selectedClientIds.length === 1;
62871    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(leaf, {
62872      className: classes,
62873      isDragged: isDragged,
62874      onKeyDown: onKeyDown,
62875      onMouseEnter: onMouseEnter,
62876      onMouseLeave: onMouseLeave,
62877      onFocus: onMouseEnter,
62878      onBlur: onMouseLeave,
62879      level: level,
62880      position: position,
62881      rowCount: rowCount,
62882      path: path,
62883      id: `list-view-$listViewInstanceId}-block-$clientId}`,
62884      "data-block": clientId,
62885      "data-expanded": canEdit ? isExpanded : undefined,
62886      ref: rowRef,
62887      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalTreeGridCell, {
62888        className: "block-editor-list-view-block__contents-cell",
62889        colSpan: colSpan,
62890        ref: cellRef,
62891        "aria-selected": !!isSelected,
62892        children: ({
62893          ref,
62894          tabIndex,
62895          onFocus
62896        }) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
62897          className: "block-editor-list-view-block__contents-container",
62898          children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_contents, {
62899            block: block,
62900            onClick: selectEditorBlock,
62901            onContextMenu: onContextMenu,
62902            onMouseDown: onMouseDown,
62903            onToggleExpanded: toggleExpanded,
62904            isSelected: isSelected,
62905            position: position,
62906            siblingBlockCount: siblingBlockCount,
62907            level: level,
62908            ref: ref,
62909            tabIndex: currentlyEditingBlockInCanvas ? 0 : tabIndex,
62910            onFocus: onFocus,
62911            isExpanded: canEdit ? isExpanded : undefined,
62912            selectedClientIds: selectedClientIds,
62913            ariaDescribedBy: descriptionId
62914          }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(AriaReferencedText, {
62915            id: descriptionId,
62916            children: [blockPositionDescription, blockPropertiesDescription].filter(Boolean).join(' ')
62917          })]
62918        })
62919      }), hasRenderedMovers && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_ReactJSXRuntime_namespaceObject.Fragment, {
62920        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalTreeGridCell, {
62921          className: moverCellClassName,
62922          withoutGridItem: true,
62923          children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalTreeGridItem, {
62924            children: ({
62925              ref,
62926              tabIndex,
62927              onFocus
62928            }) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockMoverUpButton, {
62929              orientation: "vertical",
62930              clientIds: [clientId],
62931              ref: ref,
62932              tabIndex: tabIndex,
62933              onFocus: onFocus
62934            })
62935          }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalTreeGridItem, {
62936            children: ({
62937              ref,
62938              tabIndex,
62939              onFocus
62940            }) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockMoverDownButton, {
62941              orientation: "vertical",
62942              clientIds: [clientId],
62943              ref: ref,
62944              tabIndex: tabIndex,
62945              onFocus: onFocus
62946            })
62947          })]
62948        })
62949      }), showBlockActions && BlockSettingsMenu && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalTreeGridCell, {
62950        className: listViewBlockSettingsClassName,
62951        "aria-selected": !!isSelected,
62952        ref: settingsRef,
62953        children: ({
62954          ref,
62955          tabIndex,
62956          onFocus
62957        }) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockSettingsMenu, {
62958          clientIds: dropdownClientIds,
62959          block: block,
62960          icon: more_vertical,
62961          label: (0,external_wp_i18n_namespaceObject.__)('Options'),
62962          popoverProps: {
62963            anchor: settingsPopoverAnchor // Used to position the settings at the cursor on right-click.
62964          },
62965          toggleProps: {
62966            ref,
62967            className: 'block-editor-list-view-block__menu',
62968            tabIndex,
62969            onClick: clearSettingsAnchorRect,
62970            onFocus
62971          },
62972          disableOpenOnArrowDown: true,
62973          expand: expand,
62974          expandedState: expandedState,
62975          setInsertedBlock: setInsertedBlock,
62976          __experimentalSelectBlock: updateFocusAndSelection
62977        })
62978      })]
62979    });
62980  }
62981  /* harmony default export */ const list_view_block = ((0,external_wp_element_namespaceObject.memo)(ListViewBlock));
62982  
62983  ;// ./node_modules/@wordpress/block-editor/build-module/components/list-view/branch.js
62984  /**
62985   * WordPress dependencies
62986   */
62987  
62988  
62989  
62990  
62991  /**
62992   * Internal dependencies
62993   */
62994  
62995  
62996  
62997  
62998  
62999  
63000  
63001  /**
63002   * Given a block, returns the total number of blocks in that subtree. This is used to help determine
63003   * the list position of a block.
63004   *
63005   * When a block is collapsed, we do not count their children as part of that total. In the current drag
63006   * implementation dragged blocks and their children are not counted.
63007   *
63008   * @param {Object}  block               block tree
63009   * @param {Object}  expandedState       state that notes which branches are collapsed
63010   * @param {Array}   draggedClientIds    a list of dragged client ids
63011   * @param {boolean} isExpandedByDefault flag to determine the default fallback expanded state.
63012   * @return {number} block count
63013   */
63014  
63015  function countBlocks(block, expandedState, draggedClientIds, isExpandedByDefault) {
63016    var _expandedState$block$;
63017    const isDragged = draggedClientIds?.includes(block.clientId);
63018    if (isDragged) {
63019      return 0;
63020    }
63021    const isExpanded = (_expandedState$block$ = expandedState[block.clientId]) !== null && _expandedState$block$ !== void 0 ? _expandedState$block$ : isExpandedByDefault;
63022    if (isExpanded) {
63023      return 1 + block.innerBlocks.reduce(countReducer(expandedState, draggedClientIds, isExpandedByDefault), 0);
63024    }
63025    return 1;
63026  }
63027  const countReducer = (expandedState, draggedClientIds, isExpandedByDefault) => (count, block) => {
63028    var _expandedState$block$2;
63029    const isDragged = draggedClientIds?.includes(block.clientId);
63030    if (isDragged) {
63031      return count;
63032    }
63033    const isExpanded = (_expandedState$block$2 = expandedState[block.clientId]) !== null && _expandedState$block$2 !== void 0 ? _expandedState$block$2 : isExpandedByDefault;
63034    if (isExpanded && block.innerBlocks.length > 0) {
63035      return count + countBlocks(block, expandedState, draggedClientIds, isExpandedByDefault);
63036    }
63037    return count + 1;
63038  };
63039  const branch_noop = () => {};
63040  function ListViewBranch(props) {
63041    const {
63042      blocks,
63043      selectBlock = branch_noop,
63044      showBlockMovers,
63045      selectedClientIds,
63046      level = 1,
63047      path = '',
63048      isBranchSelected = false,
63049      listPosition = 0,
63050      fixedListWindow,
63051      isExpanded,
63052      parentId,
63053      shouldShowInnerBlocks = true,
63054      isSyncedBranch = false,
63055      showAppender: showAppenderProp = true
63056    } = props;
63057    const parentBlockInformation = useBlockDisplayInformation(parentId);
63058    const syncedBranch = isSyncedBranch || !!parentBlockInformation?.isSynced;
63059    const canParentExpand = (0,external_wp_data_namespaceObject.useSelect)(select => {
63060      if (!parentId) {
63061        return true;
63062      }
63063      return select(store).canEditBlock(parentId);
63064    }, [parentId]);
63065    const {
63066      blockDropPosition,
63067      blockDropTargetIndex,
63068      firstDraggedBlockIndex,
63069      blockIndexes,
63070      expandedState,
63071      draggedClientIds
63072    } = useListViewContext();
63073    const nextPositionRef = (0,external_wp_element_namespaceObject.useRef)();
63074    if (!canParentExpand) {
63075      return null;
63076    }
63077  
63078    // Only show the appender at the first level.
63079    const showAppender = showAppenderProp && level === 1;
63080    const filteredBlocks = blocks.filter(Boolean);
63081    const blockCount = filteredBlocks.length;
63082    // The appender means an extra row in List View, so add 1 to the row count.
63083    const rowCount = showAppender ? blockCount + 1 : blockCount;
63084    nextPositionRef.current = listPosition;
63085    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
63086      children: [filteredBlocks.map((block, index) => {
63087        var _expandedState$client;
63088        const {
63089          clientId,
63090          innerBlocks
63091        } = block;
63092        if (index > 0) {
63093          nextPositionRef.current += countBlocks(filteredBlocks[index - 1], expandedState, draggedClientIds, isExpanded);
63094        }
63095        const isDragged = !!draggedClientIds?.includes(clientId);
63096  
63097        // Determine the displacement of the block while dragging. This
63098        // works out whether the current block should be displaced up or
63099        // down, relative to the dragged blocks and the drop target.
63100        const {
63101          displacement,
63102          isAfterDraggedBlocks,
63103          isNesting
63104        } = getDragDisplacementValues({
63105          blockIndexes,
63106          blockDropTargetIndex,
63107          blockDropPosition,
63108          clientId,
63109          firstDraggedBlockIndex,
63110          isDragged
63111        });
63112        const {
63113          itemInView
63114        } = fixedListWindow;
63115        const blockInView = itemInView(nextPositionRef.current);
63116        const position = index + 1;
63117        const updatedPath = path.length > 0 ? `$path}_$position}` : `$position}`;
63118        const hasNestedBlocks = !!innerBlocks?.length;
63119        const shouldExpand = hasNestedBlocks && shouldShowInnerBlocks ? (_expandedState$client = expandedState[clientId]) !== null && _expandedState$client !== void 0 ? _expandedState$client : isExpanded : undefined;
63120  
63121        // Make updates to the selected or dragged blocks synchronous,
63122        // but asynchronous for any other block.
63123        const isSelected = isClientIdSelected(clientId, selectedClientIds);
63124        const isSelectedBranch = isBranchSelected || isSelected && hasNestedBlocks;
63125  
63126        // To avoid performance issues, we only render blocks that are in view,
63127        // or blocks that are selected or dragged. If a block is selected,
63128        // it is only counted if it is the first of the block selection.
63129        // This prevents the entire tree from being rendered when a branch is
63130        // selected, or a user selects all blocks, while still enabling scroll
63131        // into view behavior when selecting a block or opening the list view.
63132        // The first and last blocks of the list are always rendered, to ensure
63133        // that Home and End keys work as expected.
63134        const showBlock = isDragged || blockInView || isSelected && clientId === selectedClientIds[0] || index === 0 || index === blockCount - 1;
63135        return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_data_namespaceObject.AsyncModeProvider, {
63136          value: !isSelected,
63137          children: [showBlock && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(list_view_block, {
63138            block: block,
63139            selectBlock: selectBlock,
63140            isSelected: isSelected,
63141            isBranchSelected: isSelectedBranch,
63142            isDragged: isDragged,
63143            level: level,
63144            position: position,
63145            rowCount: rowCount,
63146            siblingBlockCount: blockCount,
63147            showBlockMovers: showBlockMovers,
63148            path: updatedPath,
63149            isExpanded: isDragged ? false : shouldExpand,
63150            listPosition: nextPositionRef.current,
63151            selectedClientIds: selectedClientIds,
63152            isSyncedBranch: syncedBranch,
63153            displacement: displacement,
63154            isAfterDraggedBlocks: isAfterDraggedBlocks,
63155            isNesting: isNesting
63156          }), !showBlock && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("tr", {
63157            children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("td", {
63158              className: "block-editor-list-view-placeholder"
63159            })
63160          }), hasNestedBlocks && shouldExpand && !isDragged && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ListViewBranch, {
63161            parentId: clientId,
63162            blocks: innerBlocks,
63163            selectBlock: selectBlock,
63164            showBlockMovers: showBlockMovers,
63165            level: level + 1,
63166            path: updatedPath,
63167            listPosition: nextPositionRef.current + 1,
63168            fixedListWindow: fixedListWindow,
63169            isBranchSelected: isSelectedBranch,
63170            selectedClientIds: selectedClientIds,
63171            isExpanded: isExpanded,
63172            isSyncedBranch: syncedBranch
63173          })]
63174        }, clientId);
63175      }), showAppender && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalTreeGridRow, {
63176        level: level,
63177        setSize: rowCount,
63178        positionInSet: rowCount,
63179        isExpanded: true,
63180        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalTreeGridCell, {
63181          children: treeGridCellProps => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Appender, {
63182            clientId: parentId,
63183            nestingLevel: level,
63184            blockCount: blockCount,
63185            ...treeGridCellProps
63186          })
63187        })
63188      })]
63189    });
63190  }
63191  /* harmony default export */ const branch = ((0,external_wp_element_namespaceObject.memo)(ListViewBranch));
63192  
63193  ;// ./node_modules/@wordpress/block-editor/build-module/components/list-view/drop-indicator.js
63194  /**
63195   * External dependencies
63196   */
63197  
63198  
63199  /**
63200   * WordPress dependencies
63201   */
63202  
63203  
63204  
63205  
63206  
63207  /**
63208   * Internal dependencies
63209   */
63210  
63211  
63212  
63213  
63214  
63215  function ListViewDropIndicatorPreview({
63216    draggedBlockClientId,
63217    listViewRef,
63218    blockDropTarget
63219  }) {
63220    const blockInformation = useBlockDisplayInformation(draggedBlockClientId);
63221    const blockTitle = useBlockDisplayTitle({
63222      clientId: draggedBlockClientId,
63223      context: 'list-view'
63224    });
63225    const {
63226      rootClientId,
63227      clientId,
63228      dropPosition
63229    } = blockDropTarget || {};
63230    const [rootBlockElement, blockElement] = (0,external_wp_element_namespaceObject.useMemo)(() => {
63231      if (!listViewRef.current) {
63232        return [];
63233      }
63234  
63235      // The rootClientId will be defined whenever dropping into inner
63236      // block lists, but is undefined when dropping at the root level.
63237      const _rootBlockElement = rootClientId ? listViewRef.current.querySelector(`[data-block="$rootClientId}"]`) : undefined;
63238  
63239      // The clientId represents the sibling block, the dragged block will
63240      // usually be inserted adjacent to it. It will be undefined when
63241      // dropping a block into an empty block list.
63242      const _blockElement = clientId ? listViewRef.current.querySelector(`[data-block="$clientId}"]`) : undefined;
63243      return [_rootBlockElement, _blockElement];
63244    }, [listViewRef, rootClientId, clientId]);
63245  
63246    // The targetElement is the element that the drop indicator will appear
63247    // before or after. When dropping into an empty block list, blockElement
63248    // is undefined, so the indicator will appear after the rootBlockElement.
63249    const targetElement = blockElement || rootBlockElement;
63250    const rtl = (0,external_wp_i18n_namespaceObject.isRTL)();
63251    const getDropIndicatorWidth = (0,external_wp_element_namespaceObject.useCallback)((targetElementRect, indent) => {
63252      if (!targetElement) {
63253        return 0;
63254      }
63255  
63256      // Default to assuming that the width of the drop indicator
63257      // should be the same as the target element.
63258      let width = targetElement.offsetWidth;
63259  
63260      // In deeply nested lists, where a scrollbar is present,
63261      // the width of the drop indicator should be the width of
63262      // the scroll container, minus the distance from the left
63263      // edge of the scroll container to the left edge of the
63264      // target element.
63265      const scrollContainer = (0,external_wp_dom_namespaceObject.getScrollContainer)(targetElement, 'horizontal');
63266      const ownerDocument = targetElement.ownerDocument;
63267      const windowScroll = scrollContainer === ownerDocument.body || scrollContainer === ownerDocument.documentElement;
63268      if (scrollContainer && !windowScroll) {
63269        const scrollContainerRect = scrollContainer.getBoundingClientRect();
63270        const distanceBetweenContainerAndTarget = (0,external_wp_i18n_namespaceObject.isRTL)() ? scrollContainerRect.right - targetElementRect.right : targetElementRect.left - scrollContainerRect.left;
63271        const scrollContainerWidth = scrollContainer.clientWidth;
63272        if (scrollContainerWidth < width + distanceBetweenContainerAndTarget) {
63273          width = scrollContainerWidth - distanceBetweenContainerAndTarget;
63274        }
63275  
63276        // LTR logic for ensuring the drop indicator does not extend
63277        // beyond the right edge of the scroll container.
63278        if (!rtl && targetElementRect.left + indent < scrollContainerRect.left) {
63279          width -= scrollContainerRect.left - targetElementRect.left;
63280          return width;
63281        }
63282  
63283        // RTL logic for ensuring the drop indicator does not extend
63284        // beyond the right edge of the scroll container.
63285        if (rtl && targetElementRect.right - indent > scrollContainerRect.right) {
63286          width -= targetElementRect.right - scrollContainerRect.right;
63287          return width;
63288        }
63289      }
63290  
63291      // Subtract the indent from the final width of the indicator.
63292      return width - indent;
63293    }, [rtl, targetElement]);
63294    const style = (0,external_wp_element_namespaceObject.useMemo)(() => {
63295      if (!targetElement) {
63296        return {};
63297      }
63298      const targetElementRect = targetElement.getBoundingClientRect();
63299      return {
63300        width: getDropIndicatorWidth(targetElementRect, 0)
63301      };
63302    }, [getDropIndicatorWidth, targetElement]);
63303    const horizontalScrollOffsetStyle = (0,external_wp_element_namespaceObject.useMemo)(() => {
63304      if (!targetElement) {
63305        return {};
63306      }
63307      const scrollContainer = (0,external_wp_dom_namespaceObject.getScrollContainer)(targetElement);
63308      const ownerDocument = targetElement.ownerDocument;
63309      const windowScroll = scrollContainer === ownerDocument.body || scrollContainer === ownerDocument.documentElement;
63310      if (scrollContainer && !windowScroll) {
63311        const scrollContainerRect = scrollContainer.getBoundingClientRect();
63312        const targetElementRect = targetElement.getBoundingClientRect();
63313        const distanceBetweenContainerAndTarget = rtl ? scrollContainerRect.right - targetElementRect.right : targetElementRect.left - scrollContainerRect.left;
63314        if (!rtl && scrollContainerRect.left > targetElementRect.left) {
63315          return {
63316            transform: `translateX( $distanceBetweenContainerAndTarget}px )`
63317          };
63318        }
63319        if (rtl && scrollContainerRect.right < targetElementRect.right) {
63320          return {
63321            transform: `translateX( $distanceBetweenContainerAndTarget * -1}px )`
63322          };
63323        }
63324      }
63325      return {};
63326    }, [rtl, targetElement]);
63327    const ariaLevel = (0,external_wp_element_namespaceObject.useMemo)(() => {
63328      if (!rootBlockElement) {
63329        return 1;
63330      }
63331      const _ariaLevel = parseInt(rootBlockElement.getAttribute('aria-level'), 10);
63332      return _ariaLevel ? _ariaLevel + 1 : 1;
63333    }, [rootBlockElement]);
63334    const hasAdjacentSelectedBranch = (0,external_wp_element_namespaceObject.useMemo)(() => {
63335      if (!targetElement) {
63336        return false;
63337      }
63338      return targetElement.classList.contains('is-branch-selected');
63339    }, [targetElement]);
63340    const popoverAnchor = (0,external_wp_element_namespaceObject.useMemo)(() => {
63341      const isValidDropPosition = dropPosition === 'top' || dropPosition === 'bottom' || dropPosition === 'inside';
63342      if (!targetElement || !isValidDropPosition) {
63343        return undefined;
63344      }
63345      return {
63346        contextElement: targetElement,
63347        getBoundingClientRect() {
63348          const rect = targetElement.getBoundingClientRect();
63349          // In RTL languages, the drop indicator should be positioned
63350          // to the left of the target element, with the width of the
63351          // indicator determining the indent at the right edge of the
63352          // target element. In LTR languages, the drop indicator should
63353          // end at the right edge of the target element, with the indent
63354          // added to the position of the left edge of the target element.
63355          // let left = rtl ? rect.left : rect.left + indent;
63356          let left = rect.left;
63357          let top = 0;
63358  
63359          // In deeply nested lists, where a scrollbar is present,
63360          // the width of the drop indicator should be the width of
63361          // the visible area of the scroll container. Additionally,
63362          // the left edge of the drop indicator line needs to be
63363          // offset by the distance the left edge of the target element
63364          // and the left edge of the scroll container. The ensures
63365          // that the drop indicator position never breaks out of the
63366          // visible area of the scroll container.
63367          const scrollContainer = (0,external_wp_dom_namespaceObject.getScrollContainer)(targetElement, 'horizontal');
63368          const doc = targetElement.ownerDocument;
63369          const windowScroll = scrollContainer === doc.body || scrollContainer === doc.documentElement;
63370  
63371          // If the scroll container is not the window, offset the left position, if need be.
63372          if (scrollContainer && !windowScroll) {
63373            const scrollContainerRect = scrollContainer.getBoundingClientRect();
63374  
63375            // In RTL languages, a vertical scrollbar is present on the
63376            // left edge of the scroll container. The width of the
63377            // scrollbar needs to be accounted for when positioning the
63378            // drop indicator.
63379            const scrollbarWidth = rtl ? scrollContainer.offsetWidth - scrollContainer.clientWidth : 0;
63380            if (left < scrollContainerRect.left + scrollbarWidth) {
63381              left = scrollContainerRect.left + scrollbarWidth;
63382            }
63383          }
63384          if (dropPosition === 'top') {
63385            top = rect.top - rect.height * 2;
63386          } else {
63387            // `dropPosition` is either `bottom` or `inside`
63388            top = rect.top;
63389          }
63390          const width = getDropIndicatorWidth(rect, 0);
63391          const height = rect.height;
63392          return new window.DOMRect(left, top, width, height);
63393        }
63394      };
63395    }, [targetElement, dropPosition, getDropIndicatorWidth, rtl]);
63396    if (!targetElement) {
63397      return null;
63398    }
63399    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Popover, {
63400      animate: false,
63401      anchor: popoverAnchor,
63402      focusOnMount: false,
63403      className: "block-editor-list-view-drop-indicator--preview",
63404      variant: "unstyled",
63405      flip: false,
63406      resize: true,
63407      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
63408        style: style,
63409        className: dist_clsx('block-editor-list-view-drop-indicator__line', {
63410          'block-editor-list-view-drop-indicator__line--darker': hasAdjacentSelectedBranch
63411        }),
63412        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
63413          className: "block-editor-list-view-leaf",
63414          "aria-level": ariaLevel,
63415          children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
63416            className: dist_clsx('block-editor-list-view-block-select-button', 'block-editor-list-view-block-contents'),
63417            style: horizontalScrollOffsetStyle,
63418            children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ListViewExpander, {
63419              onClick: () => {}
63420            }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_icon, {
63421              icon: blockInformation?.icon,
63422              showColors: true,
63423              context: "list-view"
63424            }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalHStack, {
63425              alignment: "center",
63426              className: "block-editor-list-view-block-select-button__label-wrapper",
63427              justify: "flex-start",
63428              spacing: 1,
63429              children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("span", {
63430                className: "block-editor-list-view-block-select-button__title",
63431                children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalTruncate, {
63432                  ellipsizeMode: "auto",
63433                  children: blockTitle
63434                })
63435              })
63436            })]
63437          }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
63438            className: "block-editor-list-view-block__menu-cell"
63439          })]
63440        })
63441      })
63442    });
63443  }
63444  
63445  ;// ./node_modules/@wordpress/block-editor/build-module/components/list-view/use-block-selection.js
63446  /**
63447   * WordPress dependencies
63448   */
63449  
63450  
63451  
63452  
63453  
63454  
63455  
63456  /**
63457   * Internal dependencies
63458   */
63459  
63460  
63461  function useBlockSelection() {
63462    const {
63463      clearSelectedBlock,
63464      multiSelect,
63465      selectBlock
63466    } = (0,external_wp_data_namespaceObject.useDispatch)(store);
63467    const {
63468      getBlockName,
63469      getBlockParents,
63470      getBlockSelectionStart,
63471      getSelectedBlockClientIds,
63472      hasMultiSelection,
63473      hasSelectedBlock
63474    } = (0,external_wp_data_namespaceObject.useSelect)(store);
63475    const {
63476      getBlockType
63477    } = (0,external_wp_data_namespaceObject.useSelect)(external_wp_blocks_namespaceObject.store);
63478    const updateBlockSelection = (0,external_wp_element_namespaceObject.useCallback)(async (event, clientId, destinationClientId, focusPosition) => {
63479      if (!event?.shiftKey && event?.keyCode !== external_wp_keycodes_namespaceObject.ESCAPE) {
63480        selectBlock(clientId, focusPosition);
63481        return;
63482      }
63483  
63484      // To handle multiple block selection via the `SHIFT` key, prevent
63485      // the browser default behavior of opening the link in a new window.
63486      event.preventDefault();
63487      const isOnlyDeselection = event.type === 'keydown' && event.keyCode === external_wp_keycodes_namespaceObject.ESCAPE;
63488      const isKeyPress = event.type === 'keydown' && (event.keyCode === external_wp_keycodes_namespaceObject.UP || event.keyCode === external_wp_keycodes_namespaceObject.DOWN || event.keyCode === external_wp_keycodes_namespaceObject.HOME || event.keyCode === external_wp_keycodes_namespaceObject.END);
63489  
63490      // Handle clicking on a block when no blocks are selected, and return early.
63491      if (!isKeyPress && !hasSelectedBlock() && !hasMultiSelection()) {
63492        selectBlock(clientId, null);
63493        return;
63494      }
63495      const selectedBlocks = getSelectedBlockClientIds();
63496      const clientIdWithParents = [...getBlockParents(clientId), clientId];
63497      if (isOnlyDeselection || isKeyPress && !selectedBlocks.some(blockId => clientIdWithParents.includes(blockId))) {
63498        // Ensure that shift-selecting blocks via the keyboard only
63499        // expands the current selection if focusing over already
63500        // selected blocks. Otherwise, clear the selection so that
63501        // a user can create a new selection entirely by keyboard.
63502        await clearSelectedBlock();
63503      }
63504  
63505      // Update selection, if not only clearing the selection.
63506      if (!isOnlyDeselection) {
63507        let startTarget = getBlockSelectionStart();
63508        let endTarget = clientId;
63509  
63510        // Handle keyboard behavior for selecting multiple blocks.
63511        if (isKeyPress) {
63512          if (!hasSelectedBlock() && !hasMultiSelection()) {
63513            // Set the starting point of the selection to the currently
63514            // focused block, if there are no blocks currently selected.
63515            // This ensures that as the selection is expanded or contracted,
63516            // the starting point of the selection is anchored to that block.
63517            startTarget = clientId;
63518          }
63519          if (destinationClientId) {
63520            // If the user presses UP or DOWN, we want to ensure that the block they're
63521            // moving to is the target for selection, and not the currently focused one.
63522            endTarget = destinationClientId;
63523          }
63524        }
63525        const startParents = getBlockParents(startTarget);
63526        const endParents = getBlockParents(endTarget);
63527        const {
63528          start,
63529          end
63530        } = getCommonDepthClientIds(startTarget, endTarget, startParents, endParents);
63531        await multiSelect(start, end, null);
63532      }
63533  
63534      // Announce deselected block, or number of deselected blocks if
63535      // the total number of blocks deselected is greater than one.
63536      const updatedSelectedBlocks = getSelectedBlockClientIds();
63537  
63538      // If the selection is greater than 1 and the Home or End keys
63539      // were used to generate the selection, then skip announcing the
63540      // deselected blocks.
63541      if ((event.keyCode === external_wp_keycodes_namespaceObject.HOME || event.keyCode === external_wp_keycodes_namespaceObject.END) && updatedSelectedBlocks.length > 1) {
63542        return;
63543      }
63544      const selectionDiff = selectedBlocks.filter(blockId => !updatedSelectedBlocks.includes(blockId));
63545      let label;
63546      if (selectionDiff.length === 1) {
63547        const title = getBlockType(getBlockName(selectionDiff[0]))?.title;
63548        if (title) {
63549          label = (0,external_wp_i18n_namespaceObject.sprintf)(/* translators: %s: block name */
63550          (0,external_wp_i18n_namespaceObject.__)('%s deselected.'), title);
63551        }
63552      } else if (selectionDiff.length > 1) {
63553        label = (0,external_wp_i18n_namespaceObject.sprintf)(/* translators: %s: number of deselected blocks */
63554        (0,external_wp_i18n_namespaceObject.__)('%s blocks deselected.'), selectionDiff.length);
63555      }
63556      if (label) {
63557        (0,external_wp_a11y_namespaceObject.speak)(label, 'assertive');
63558      }
63559    }, [clearSelectedBlock, getBlockName, getBlockType, getBlockParents, getBlockSelectionStart, getSelectedBlockClientIds, hasMultiSelection, hasSelectedBlock, multiSelect, selectBlock]);
63560    return {
63561      updateBlockSelection
63562    };
63563  }
63564  
63565  ;// ./node_modules/@wordpress/block-editor/build-module/components/list-view/use-list-view-block-indexes.js
63566  /**
63567   * WordPress dependencies
63568   */
63569  
63570  function useListViewBlockIndexes(blocks) {
63571    const blockIndexes = (0,external_wp_element_namespaceObject.useMemo)(() => {
63572      const indexes = {};
63573      let currentGlobalIndex = 0;
63574      const traverseBlocks = blockList => {
63575        blockList.forEach(block => {
63576          indexes[block.clientId] = currentGlobalIndex;
63577          currentGlobalIndex++;
63578          if (block.innerBlocks.length > 0) {
63579            traverseBlocks(block.innerBlocks);
63580          }
63581        });
63582      };
63583      traverseBlocks(blocks);
63584      return indexes;
63585    }, [blocks]);
63586    return blockIndexes;
63587  }
63588  
63589  ;// ./node_modules/@wordpress/block-editor/build-module/components/list-view/use-list-view-client-ids.js
63590  /**
63591   * WordPress dependencies
63592   */
63593  
63594  
63595  
63596  /**
63597   * Internal dependencies
63598   */
63599  
63600  
63601  function useListViewClientIds({
63602    blocks,
63603    rootClientId
63604  }) {
63605    return (0,external_wp_data_namespaceObject.useSelect)(select => {
63606      const {
63607        getDraggedBlockClientIds,
63608        getSelectedBlockClientIds,
63609        getEnabledClientIdsTree
63610      } = unlock(select(store));
63611      return {
63612        selectedClientIds: getSelectedBlockClientIds(),
63613        draggedClientIds: getDraggedBlockClientIds(),
63614        clientIdsTree: blocks !== null && blocks !== void 0 ? blocks : getEnabledClientIdsTree(rootClientId)
63615      };
63616    }, [blocks, rootClientId]);
63617  }
63618  
63619  ;// ./node_modules/@wordpress/block-editor/build-module/components/list-view/use-list-view-collapse-items.js
63620  /**
63621   * WordPress dependencies
63622   */
63623  
63624  
63625  
63626  /**
63627   * Internal dependencies
63628   */
63629  
63630  
63631  function useListViewCollapseItems({
63632    collapseAll,
63633    expand
63634  }) {
63635    const {
63636      expandedBlock,
63637      getBlockParents
63638    } = (0,external_wp_data_namespaceObject.useSelect)(select => {
63639      const {
63640        getBlockParents: _getBlockParents,
63641        getExpandedBlock
63642      } = unlock(select(store));
63643      return {
63644        expandedBlock: getExpandedBlock(),
63645        getBlockParents: _getBlockParents
63646      };
63647    }, []);
63648  
63649    // Collapse all but the specified block when the expanded block client Id changes.
63650    (0,external_wp_element_namespaceObject.useEffect)(() => {
63651      if (expandedBlock) {
63652        const blockParents = getBlockParents(expandedBlock, false);
63653        // Collapse all blocks and expand the block's parents.
63654        collapseAll();
63655        expand(blockParents);
63656      }
63657    }, [collapseAll, expand, expandedBlock, getBlockParents]);
63658  }
63659  
63660  ;// ./node_modules/@wordpress/block-editor/build-module/components/list-view/use-list-view-drop-zone.js
63661  /**
63662   * WordPress dependencies
63663   */
63664  
63665  
63666  
63667  
63668  
63669  /**
63670   * Internal dependencies
63671   */
63672  
63673  
63674  
63675  
63676  /** @typedef {import('../../utils/math').WPPoint} WPPoint */
63677  
63678  /**
63679   * The type of a drag event.
63680   *
63681   * @typedef {'default'|'file'|'html'} WPDragEventType
63682   */
63683  
63684  /**
63685   * An object representing data for blocks in the DOM used by drag and drop.
63686   *
63687   * @typedef {Object} WPListViewDropZoneBlock
63688   * @property {string}  clientId                        The client id for the block.
63689   * @property {string}  rootClientId                    The root client id for the block.
63690   * @property {number}  blockIndex                      The block's index.
63691   * @property {Element} element                         The DOM element representing the block.
63692   * @property {number}  innerBlockCount                 The number of inner blocks the block has.
63693   * @property {boolean} isDraggedBlock                  Whether the block is currently being dragged.
63694   * @property {boolean} isExpanded                      Whether the block is expanded in the UI.
63695   * @property {boolean} canInsertDraggedBlocksAsSibling Whether the dragged block can be a sibling of this block.
63696   * @property {boolean} canInsertDraggedBlocksAsChild   Whether the dragged block can be a child of this block.
63697   */
63698  
63699  /**
63700   * An array representing data for blocks in the DOM used by drag and drop.
63701   *
63702   * @typedef {WPListViewDropZoneBlock[]} WPListViewDropZoneBlocks
63703   */
63704  
63705  /**
63706   * An object containing details of a drop target.
63707   *
63708   * @typedef {Object} WPListViewDropZoneTarget
63709   * @property {string}                  blockIndex   The insertion index.
63710   * @property {string}                  rootClientId The root client id for the block.
63711   * @property {string|undefined}        clientId     The client id for the block.
63712   * @property {'top'|'bottom'|'inside'} dropPosition The position relative to the block that the user is dropping to.
63713   *                                                  'inside' refers to nesting as an inner block.
63714   */
63715  
63716  // When the indentation level, the corresponding left margin in `style.scss`
63717  // must be updated as well to ensure the drop zone is aligned with the indentation.
63718  const NESTING_LEVEL_INDENTATION = 24;
63719  
63720  /**
63721   * Determines whether the user is positioning the dragged block to be
63722   * moved up to a parent level.
63723   *
63724   * Determined based on nesting level indentation of the current block.
63725   *
63726   * @param {WPPoint} point        The point representing the cursor position when dragging.
63727   * @param {DOMRect} rect         The rectangle.
63728   * @param {number}  nestingLevel The nesting level of the block.
63729   * @param {boolean} rtl          Whether the editor is in RTL mode.
63730   * @return {boolean} Whether the gesture is an upward gesture.
63731   */
63732  function isUpGesture(point, rect, nestingLevel = 1, rtl = false) {
63733    // If the block is nested, and the user is dragging to the bottom
63734    // left of the block (or bottom right in RTL languages), then it is an upward gesture.
63735    const blockIndentPosition = rtl ? rect.right - nestingLevel * NESTING_LEVEL_INDENTATION : rect.left + nestingLevel * NESTING_LEVEL_INDENTATION;
63736    return rtl ? point.x > blockIndentPosition : point.x < blockIndentPosition;
63737  }
63738  
63739  /**
63740   * Returns how many nesting levels up the user is attempting to drag to.
63741   *
63742   * The relative parent level is calculated based on how far
63743   * the cursor is from the provided nesting level (e.g. of a candidate block
63744   * that the user is hovering over). The nesting level is considered "desired"
63745   * because it is not guaranteed that the user will be able to drag to the desired level.
63746   *
63747   * The returned integer can be used to access an ascending array
63748   * of parent blocks, where the first item is the block the user
63749   * is hovering over, and the last item is the root block.
63750   *
63751   * @param {WPPoint} point        The point representing the cursor position when dragging.
63752   * @param {DOMRect} rect         The rectangle.
63753   * @param {number}  nestingLevel The nesting level of the block.
63754   * @param {boolean} rtl          Whether the editor is in RTL mode.
63755   * @return {number} The desired relative parent level.
63756   */
63757  function getDesiredRelativeParentLevel(point, rect, nestingLevel = 1, rtl = false) {
63758    // In RTL languages, the block indent position is from the right edge of the block.
63759    // In LTR languages, the block indent position is from the left edge of the block.
63760    const blockIndentPosition = rtl ? rect.right - nestingLevel * NESTING_LEVEL_INDENTATION : rect.left + nestingLevel * NESTING_LEVEL_INDENTATION;
63761    const distanceBetweenPointAndBlockIndentPosition = rtl ? blockIndentPosition - point.x : point.x - blockIndentPosition;
63762    const desiredParentLevel = Math.round(distanceBetweenPointAndBlockIndentPosition / NESTING_LEVEL_INDENTATION);
63763    return Math.abs(desiredParentLevel);
63764  }
63765  
63766  /**
63767   * Returns an array of the parent blocks of the block the user is dropping to.
63768   *
63769   * @param {WPListViewDropZoneBlock}  candidateBlockData The block the user is dropping to.
63770   * @param {WPListViewDropZoneBlocks} blocksData         Data about the blocks in list view.
63771   * @return {WPListViewDropZoneBlocks} An array of block parents, including the block the user is dropping to.
63772   */
63773  function getCandidateBlockParents(candidateBlockData, blocksData) {
63774    const candidateBlockParents = [];
63775    let currentBlockData = candidateBlockData;
63776    while (currentBlockData) {
63777      candidateBlockParents.push({
63778        ...currentBlockData
63779      });
63780      currentBlockData = blocksData.find(blockData => blockData.clientId === currentBlockData.rootClientId);
63781    }
63782    return candidateBlockParents;
63783  }
63784  
63785  /**
63786   * Given a list of blocks data and a block index, return the next non-dragged
63787   * block. This is used to determine the block that the user is dropping to,
63788   * while ignoring the dragged block.
63789   *
63790   * @param {WPListViewDropZoneBlocks} blocksData Data about the blocks in list view.
63791   * @param {number}                   index      The index to begin searching from.
63792   * @return {WPListViewDropZoneBlock | undefined} The next non-dragged block.
63793   */
63794  function getNextNonDraggedBlock(blocksData, index) {
63795    const nextBlockData = blocksData[index + 1];
63796    if (nextBlockData && nextBlockData.isDraggedBlock) {
63797      return getNextNonDraggedBlock(blocksData, index + 1);
63798    }
63799    return nextBlockData;
63800  }
63801  
63802  /**
63803   * Determines whether the user positioning the dragged block to nest as an
63804   * inner block.
63805   *
63806   * Determined based on nesting level indentation of the current block, plus
63807   * the indentation of the next level of nesting. The vertical position of the
63808   * cursor must also be within the block.
63809   *
63810   * @param {WPPoint} point        The point representing the cursor position when dragging.
63811   * @param {DOMRect} rect         The rectangle.
63812   * @param {number}  nestingLevel The nesting level of the block.
63813   * @param {boolean} rtl          Whether the editor is in RTL mode.
63814   */
63815  function isNestingGesture(point, rect, nestingLevel = 1, rtl = false) {
63816    const blockIndentPosition = rtl ? rect.right - nestingLevel * NESTING_LEVEL_INDENTATION : rect.left + nestingLevel * NESTING_LEVEL_INDENTATION;
63817    const isNestingHorizontalGesture = rtl ? point.x < blockIndentPosition - NESTING_LEVEL_INDENTATION : point.x > blockIndentPosition + NESTING_LEVEL_INDENTATION;
63818    return isNestingHorizontalGesture && point.y < rect.bottom;
63819  }
63820  
63821  // Block navigation is always a vertical list, so only allow dropping
63822  // to the above or below a block.
63823  const ALLOWED_DROP_EDGES = ['top', 'bottom'];
63824  
63825  /**
63826   * Given blocks data and the cursor position, compute the drop target.
63827   *
63828   * @param {WPListViewDropZoneBlocks} blocksData Data about the blocks in list view.
63829   * @param {WPPoint}                  position   The point representing the cursor position when dragging.
63830   * @param {boolean}                  rtl        Whether the editor is in RTL mode.
63831   *
63832   * @return {WPListViewDropZoneTarget | undefined} An object containing data about the drop target.
63833   */
63834  function getListViewDropTarget(blocksData, position, rtl = false) {
63835    let candidateEdge;
63836    let candidateBlockData;
63837    let candidateDistance;
63838    let candidateRect;
63839    let candidateBlockIndex;
63840    for (let i = 0; i < blocksData.length; i++) {
63841      const blockData = blocksData[i];
63842      if (blockData.isDraggedBlock) {
63843        continue;
63844      }
63845      const rect = blockData.element.getBoundingClientRect();
63846      const [distance, edge] = getDistanceToNearestEdge(position, rect, ALLOWED_DROP_EDGES);
63847      const isCursorWithinBlock = isPointContainedByRect(position, rect);
63848      if (candidateDistance === undefined || distance < candidateDistance || isCursorWithinBlock) {
63849        candidateDistance = distance;
63850        const index = blocksData.indexOf(blockData);
63851        const previousBlockData = blocksData[index - 1];
63852  
63853        // If dragging near the top of a block and the preceding block
63854        // is at the same level, use the preceding block as the candidate
63855        // instead, as later it makes determining a nesting drop easier.
63856        if (edge === 'top' && previousBlockData && previousBlockData.rootClientId === blockData.rootClientId && !previousBlockData.isDraggedBlock) {
63857          candidateBlockData = previousBlockData;
63858          candidateEdge = 'bottom';
63859          candidateRect = previousBlockData.element.getBoundingClientRect();
63860          candidateBlockIndex = index - 1;
63861        } else {
63862          candidateBlockData = blockData;
63863          candidateEdge = edge;
63864          candidateRect = rect;
63865          candidateBlockIndex = index;
63866        }
63867  
63868        // If the mouse position is within the block, break early
63869        // as the user would intend to drop either before or after
63870        // this block.
63871        //
63872        // This solves an issue where some rows in the list view
63873        // tree overlap slightly due to sub-pixel rendering.
63874        if (isCursorWithinBlock) {
63875          break;
63876        }
63877      }
63878    }
63879    if (!candidateBlockData) {
63880      return;
63881    }
63882    const candidateBlockParents = getCandidateBlockParents(candidateBlockData, blocksData);
63883    const isDraggingBelow = candidateEdge === 'bottom';
63884  
63885    // If the user is dragging towards the bottom of the block check whether
63886    // they might be trying to nest the block as a child.
63887    // If the block already has inner blocks, and is expanded, this should be treated
63888    // as nesting since the next block in the tree will be the first child.
63889    // However, if the block is collapsed, dragging beneath the block should
63890    // still be allowed, as the next visible block in the tree will be a sibling.
63891    if (isDraggingBelow && candidateBlockData.canInsertDraggedBlocksAsChild && (candidateBlockData.innerBlockCount > 0 && candidateBlockData.isExpanded || isNestingGesture(position, candidateRect, candidateBlockParents.length, rtl))) {
63892      // If the block is expanded, insert the block as the first child.
63893      // Otherwise, for collapsed blocks, insert the block as the last child.
63894      const newBlockIndex = candidateBlockData.isExpanded ? 0 : candidateBlockData.innerBlockCount || 0;
63895      return {
63896        rootClientId: candidateBlockData.clientId,
63897        clientId: candidateBlockData.clientId,
63898        blockIndex: newBlockIndex,
63899        dropPosition: 'inside'
63900      };
63901    }
63902  
63903    // If the user is dragging towards the bottom of the block check whether
63904    // they might be trying to move the block to be at a parent level.
63905    if (isDraggingBelow && candidateBlockData.rootClientId && isUpGesture(position, candidateRect, candidateBlockParents.length, rtl)) {
63906      const nextBlock = getNextNonDraggedBlock(blocksData, candidateBlockIndex);
63907      const currentLevel = candidateBlockData.nestingLevel;
63908      const nextLevel = nextBlock ? nextBlock.nestingLevel : 1;
63909      if (currentLevel && nextLevel) {
63910        // Determine the desired relative level of the block to be dropped.
63911        const desiredRelativeLevel = getDesiredRelativeParentLevel(position, candidateRect, candidateBlockParents.length, rtl);
63912        const targetParentIndex = Math.max(Math.min(desiredRelativeLevel, currentLevel - nextLevel), 0);
63913        if (candidateBlockParents[targetParentIndex]) {
63914          // Default to the block index of the candidate block.
63915          let newBlockIndex = candidateBlockData.blockIndex;
63916  
63917          // If the next block is at the same level, use that as the default
63918          // block index. This ensures that the block is dropped in the correct
63919          // position when dragging to the bottom of a block.
63920          if (candidateBlockParents[targetParentIndex].nestingLevel === nextBlock?.nestingLevel) {
63921            newBlockIndex = nextBlock?.blockIndex;
63922          } else {
63923            // Otherwise, search from the current block index back
63924            // to find the last block index within the same target parent.
63925            for (let i = candidateBlockIndex; i >= 0; i--) {
63926              const blockData = blocksData[i];
63927              if (blockData.rootClientId === candidateBlockParents[targetParentIndex].rootClientId) {
63928                newBlockIndex = blockData.blockIndex + 1;
63929                break;
63930              }
63931            }
63932          }
63933          return {
63934            rootClientId: candidateBlockParents[targetParentIndex].rootClientId,
63935            clientId: candidateBlockData.clientId,
63936            blockIndex: newBlockIndex,
63937            dropPosition: candidateEdge
63938          };
63939        }
63940      }
63941    }
63942  
63943    // If dropping as a sibling, but block cannot be inserted in
63944    // this context, return early.
63945    if (!candidateBlockData.canInsertDraggedBlocksAsSibling) {
63946      return;
63947    }
63948    const offset = isDraggingBelow ? 1 : 0;
63949    return {
63950      rootClientId: candidateBlockData.rootClientId,
63951      clientId: candidateBlockData.clientId,
63952      blockIndex: candidateBlockData.blockIndex + offset,
63953      dropPosition: candidateEdge
63954    };
63955  }
63956  
63957  // Throttle options need to be defined outside of the hook to avoid
63958  // re-creating the object on every render. This is due to a limitation
63959  // of the `useThrottle` hook, where the options object is included
63960  // in the dependency array for memoization.
63961  const EXPAND_THROTTLE_OPTIONS = {
63962    leading: false,
63963    // Don't call the function immediately on the first call.
63964    trailing: true // Do call the function on the last call.
63965  };
63966  
63967  /**
63968   * A react hook for implementing a drop zone in list view.
63969   *
63970   * @param {Object}       props                    Named parameters.
63971   * @param {?HTMLElement} [props.dropZoneElement]  Optional element to be used as the drop zone.
63972   * @param {Object}       [props.expandedState]    The expanded state of the blocks in the list view.
63973   * @param {Function}     [props.setExpandedState] Function to set the expanded state of a list of block clientIds.
63974   *
63975   * @return {WPListViewDropZoneTarget} The drop target.
63976   */
63977  function useListViewDropZone({
63978    dropZoneElement,
63979    expandedState,
63980    setExpandedState
63981  }) {
63982    const {
63983      getBlockRootClientId,
63984      getBlockIndex,
63985      getBlockCount,
63986      getDraggedBlockClientIds,
63987      canInsertBlocks
63988    } = (0,external_wp_data_namespaceObject.useSelect)(store);
63989    const [target, setTarget] = (0,external_wp_element_namespaceObject.useState)();
63990    const {
63991      rootClientId: targetRootClientId,
63992      blockIndex: targetBlockIndex
63993    } = target || {};
63994    const onBlockDrop = useOnBlockDrop(targetRootClientId, targetBlockIndex);
63995    const rtl = (0,external_wp_i18n_namespaceObject.isRTL)();
63996    const previousRootClientId = (0,external_wp_compose_namespaceObject.usePrevious)(targetRootClientId);
63997    const maybeExpandBlock = (0,external_wp_element_namespaceObject.useCallback)((_expandedState, _target) => {
63998      // If the user is attempting to drop a block inside a collapsed block,
63999      // that is, using a nesting gesture flagged by 'inside' dropPosition,
64000      // expand the block within the list view, if it isn't already.
64001      const {
64002        rootClientId
64003      } = _target || {};
64004      if (!rootClientId) {
64005        return;
64006      }
64007      if (_target?.dropPosition === 'inside' && !_expandedState[rootClientId]) {
64008        setExpandedState({
64009          type: 'expand',
64010          clientIds: [rootClientId]
64011        });
64012      }
64013    }, [setExpandedState]);
64014  
64015    // Throttle the maybeExpandBlock function to avoid expanding the block
64016    // too quickly when the user is dragging over the block. This is to
64017    // avoid expanding the block when the user is just passing over it.
64018    const throttledMaybeExpandBlock = (0,external_wp_compose_namespaceObject.useThrottle)(maybeExpandBlock, 500, EXPAND_THROTTLE_OPTIONS);
64019    (0,external_wp_element_namespaceObject.useEffect)(() => {
64020      if (target?.dropPosition !== 'inside' || previousRootClientId !== target?.rootClientId) {
64021        throttledMaybeExpandBlock.cancel();
64022        return;
64023      }
64024      throttledMaybeExpandBlock(expandedState, target);
64025    }, [expandedState, previousRootClientId, target, throttledMaybeExpandBlock]);
64026    const draggedBlockClientIds = getDraggedBlockClientIds();
64027    const throttled = (0,external_wp_compose_namespaceObject.useThrottle)((0,external_wp_element_namespaceObject.useCallback)((event, currentTarget) => {
64028      const position = {
64029        x: event.clientX,
64030        y: event.clientY
64031      };
64032      const isBlockDrag = !!draggedBlockClientIds?.length;
64033      const blockElements = Array.from(currentTarget.querySelectorAll('[data-block]'));
64034      const blocksData = blockElements.map(blockElement => {
64035        const clientId = blockElement.dataset.block;
64036        const isExpanded = blockElement.dataset.expanded === 'true';
64037        const isDraggedBlock = blockElement.classList.contains('is-dragging');
64038  
64039        // Get nesting level from `aria-level` attribute because Firefox does not support `element.ariaLevel`.
64040        const nestingLevel = parseInt(blockElement.getAttribute('aria-level'), 10);
64041        const rootClientId = getBlockRootClientId(clientId);
64042        return {
64043          clientId,
64044          isExpanded,
64045          rootClientId,
64046          blockIndex: getBlockIndex(clientId),
64047          element: blockElement,
64048          nestingLevel: nestingLevel || undefined,
64049          isDraggedBlock: isBlockDrag ? isDraggedBlock : false,
64050          innerBlockCount: getBlockCount(clientId),
64051          canInsertDraggedBlocksAsSibling: isBlockDrag ? canInsertBlocks(draggedBlockClientIds, rootClientId) : true,
64052          canInsertDraggedBlocksAsChild: isBlockDrag ? canInsertBlocks(draggedBlockClientIds, clientId) : true
64053        };
64054      });
64055      const newTarget = getListViewDropTarget(blocksData, position, rtl);
64056      if (newTarget) {
64057        setTarget(newTarget);
64058      }
64059    }, [canInsertBlocks, draggedBlockClientIds, getBlockCount, getBlockIndex, getBlockRootClientId, rtl]), 50);
64060    const ref = (0,external_wp_compose_namespaceObject.__experimentalUseDropZone)({
64061      dropZoneElement,
64062      onDrop(event) {
64063        throttled.cancel();
64064        if (target) {
64065          onBlockDrop(event);
64066        }
64067        // Use `undefined` value to indicate that the drag has concluded.
64068        // This allows styling rules that are active only when a user is
64069        // dragging to be removed.
64070        setTarget(undefined);
64071      },
64072      onDragLeave() {
64073        throttled.cancel();
64074        // Use `null` value to indicate that the drop target is not valid,
64075        // but that the drag is still active. This allows for styling rules
64076        // that are active only when a user drags outside of the list view.
64077        setTarget(null);
64078      },
64079      onDragOver(event) {
64080        // `currentTarget` is only available while the event is being
64081        // handled, so get it now and pass it to the thottled function.
64082        // https://developer.mozilla.org/en-US/docs/Web/API/Event/currentTarget
64083        throttled(event, event.currentTarget);
64084      },
64085      onDragEnd() {
64086        throttled.cancel();
64087        // Use `undefined` value to indicate that the drag has concluded.
64088        // This allows styling rules that are active only when a user is
64089        // dragging to be removed.
64090        setTarget(undefined);
64091      }
64092    });
64093    return {
64094      ref,
64095      target
64096    };
64097  }
64098  
64099  ;// ./node_modules/@wordpress/block-editor/build-module/components/list-view/use-list-view-expand-selected-item.js
64100  /**
64101   * WordPress dependencies
64102   */
64103  
64104  
64105  
64106  /**
64107   * Internal dependencies
64108   */
64109  
64110  function useListViewExpandSelectedItem({
64111    firstSelectedBlockClientId,
64112    setExpandedState
64113  }) {
64114    const [selectedTreeId, setSelectedTreeId] = (0,external_wp_element_namespaceObject.useState)(null);
64115    const {
64116      selectedBlockParentClientIds
64117    } = (0,external_wp_data_namespaceObject.useSelect)(select => {
64118      const {
64119        getBlockParents
64120      } = select(store);
64121      return {
64122        selectedBlockParentClientIds: getBlockParents(firstSelectedBlockClientId, false)
64123      };
64124    }, [firstSelectedBlockClientId]);
64125  
64126    // Expand tree when a block is selected.
64127    (0,external_wp_element_namespaceObject.useEffect)(() => {
64128      // If the selectedTreeId is the same as the selected block,
64129      // it means that the block was selected using the block list tree.
64130      if (selectedTreeId === firstSelectedBlockClientId) {
64131        return;
64132      }
64133  
64134      // If the selected block has parents, get the top-level parent.
64135      if (selectedBlockParentClientIds?.length) {
64136        // If the selected block has parents,
64137        // expand the tree branch.
64138        setExpandedState({
64139          type: 'expand',
64140          clientIds: selectedBlockParentClientIds
64141        });
64142      }
64143    }, [firstSelectedBlockClientId, selectedBlockParentClientIds, selectedTreeId, setExpandedState]);
64144    return {
64145      setSelectedTreeId
64146    };
64147  }
64148  
64149  ;// ./node_modules/@wordpress/block-editor/build-module/components/list-view/use-clipboard-handler.js
64150  /**
64151   * WordPress dependencies
64152   */
64153  
64154  
64155  
64156  /**
64157   * Internal dependencies
64158   */
64159  
64160  
64161  
64162  
64163  
64164  // This hook borrows from useClipboardHandler in ../writing-flow/use-clipboard-handler.js
64165  // and adds behaviour for the list view, while skipping partial selection.
64166  function use_clipboard_handler_useClipboardHandler({
64167    selectBlock
64168  }) {
64169    const registry = (0,external_wp_data_namespaceObject.useRegistry)();
64170    const {
64171      getBlockOrder,
64172      getBlockRootClientId,
64173      getBlocksByClientId,
64174      getPreviousBlockClientId,
64175      getSelectedBlockClientIds,
64176      getSettings,
64177      canInsertBlockType,
64178      canRemoveBlocks
64179    } = (0,external_wp_data_namespaceObject.useSelect)(store);
64180    const {
64181      flashBlock,
64182      removeBlocks,
64183      replaceBlocks,
64184      insertBlocks
64185    } = (0,external_wp_data_namespaceObject.useDispatch)(store);
64186    const notifyCopy = useNotifyCopy();
64187    return (0,external_wp_compose_namespaceObject.useRefEffect)(node => {
64188      function updateFocusAndSelection(focusClientId, shouldSelectBlock) {
64189        if (shouldSelectBlock) {
64190          selectBlock(undefined, focusClientId, null, null);
64191        }
64192        focusListItem(focusClientId, node);
64193      }
64194  
64195      // Determine which blocks to update:
64196      // If the current (focused) block is part of the block selection, use the whole selection.
64197      // If the focused block is not part of the block selection, only update the focused block.
64198      function getBlocksToUpdate(clientId) {
64199        const selectedBlockClientIds = getSelectedBlockClientIds();
64200        const isUpdatingSelectedBlocks = selectedBlockClientIds.includes(clientId);
64201        const firstBlockClientId = isUpdatingSelectedBlocks ? selectedBlockClientIds[0] : clientId;
64202        const firstBlockRootClientId = getBlockRootClientId(firstBlockClientId);
64203        const blocksToUpdate = isUpdatingSelectedBlocks ? selectedBlockClientIds : [clientId];
64204        return {
64205          blocksToUpdate,
64206          firstBlockClientId,
64207          firstBlockRootClientId,
64208          originallySelectedBlockClientIds: selectedBlockClientIds
64209        };
64210      }
64211      function handler(event) {
64212        if (event.defaultPrevented) {
64213          // This was possibly already handled in rich-text/use-paste-handler.js.
64214          return;
64215        }
64216  
64217        // Only handle events that occur within the list view.
64218        if (!node.contains(event.target.ownerDocument.activeElement)) {
64219          return;
64220        }
64221  
64222        // Retrieve the block clientId associated with the focused list view row.
64223        // This enables applying copy / cut / paste behavior to the focused block,
64224        // rather than just the blocks that are currently selected.
64225        const listViewRow = event.target.ownerDocument.activeElement?.closest('[role=row]');
64226        const clientId = listViewRow?.dataset?.block;
64227        if (!clientId) {
64228          return;
64229        }
64230        const {
64231          blocksToUpdate: selectedBlockClientIds,
64232          firstBlockClientId,
64233          firstBlockRootClientId,
64234          originallySelectedBlockClientIds
64235        } = getBlocksToUpdate(clientId);
64236        if (selectedBlockClientIds.length === 0) {
64237          return;
64238        }
64239        event.preventDefault();
64240        if (event.type === 'copy' || event.type === 'cut') {
64241          if (selectedBlockClientIds.length === 1) {
64242            flashBlock(selectedBlockClientIds[0]);
64243          }
64244          notifyCopy(event.type, selectedBlockClientIds);
64245          const blocks = getBlocksByClientId(selectedBlockClientIds);
64246          setClipboardBlocks(event, blocks, registry);
64247        }
64248        if (event.type === 'cut') {
64249          var _getPreviousBlockClie;
64250          // Don't update the selection if the blocks cannot be deleted.
64251          if (!canRemoveBlocks(selectedBlockClientIds)) {
64252            return;
64253          }
64254          let blockToFocus = (_getPreviousBlockClie = getPreviousBlockClientId(firstBlockClientId)) !== null && _getPreviousBlockClie !== void 0 ? _getPreviousBlockClie :
64255          // If the previous block is not found (when the first block is deleted),
64256          // fallback to focus the parent block.
64257          firstBlockRootClientId;
64258  
64259          // Remove blocks, but don't update selection, and it will be handled below.
64260          removeBlocks(selectedBlockClientIds, false);
64261  
64262          // Update the selection if the original selection has been removed.
64263          const shouldUpdateSelection = originallySelectedBlockClientIds.length > 0 && getSelectedBlockClientIds().length === 0;
64264  
64265          // If there's no previous block nor parent block, focus the first block.
64266          if (!blockToFocus) {
64267            blockToFocus = getBlockOrder()[0];
64268          }
64269          updateFocusAndSelection(blockToFocus, shouldUpdateSelection);
64270        } else if (event.type === 'paste') {
64271          const {
64272            __experimentalCanUserUseUnfilteredHTML: canUserUseUnfilteredHTML
64273          } = getSettings();
64274          const blocks = getPasteBlocks(event, canUserUseUnfilteredHTML);
64275          if (selectedBlockClientIds.length === 1) {
64276            const [selectedBlockClientId] = selectedBlockClientIds;
64277  
64278            // If a single block is focused, and the blocks to be posted can
64279            // be inserted within the block, then append the pasted blocks
64280            // within the focused block. For example, if you have copied a paragraph
64281            // block and paste it within a single Group block, this will append
64282            // the paragraph block within the Group block.
64283            if (blocks.every(block => canInsertBlockType(block.name, selectedBlockClientId))) {
64284              insertBlocks(blocks, undefined, selectedBlockClientId);
64285              updateFocusAndSelection(blocks[0]?.clientId, false);
64286              return;
64287            }
64288          }
64289          replaceBlocks(selectedBlockClientIds, blocks, blocks.length - 1, -1);
64290          updateFocusAndSelection(blocks[0]?.clientId, false);
64291        }
64292      }
64293      node.ownerDocument.addEventListener('copy', handler);
64294      node.ownerDocument.addEventListener('cut', handler);
64295      node.ownerDocument.addEventListener('paste', handler);
64296      return () => {
64297        node.ownerDocument.removeEventListener('copy', handler);
64298        node.ownerDocument.removeEventListener('cut', handler);
64299        node.ownerDocument.removeEventListener('paste', handler);
64300      };
64301    }, []);
64302  }
64303  
64304  ;// ./node_modules/@wordpress/block-editor/build-module/components/list-view/index.js
64305  /**
64306   * External dependencies
64307   */
64308  
64309  
64310  /**
64311   * WordPress dependencies
64312   */
64313  
64314  
64315  
64316  
64317  
64318  
64319  
64320  /**
64321   * Internal dependencies
64322   */
64323  
64324  
64325  
64326  
64327  
64328  
64329  
64330  
64331  
64332  
64333  
64334  
64335  
64336  
64337  const expanded = (state, action) => {
64338    if (action.type === 'clear') {
64339      return {};
64340    }
64341    if (Array.isArray(action.clientIds)) {
64342      return {
64343        ...state,
64344        ...action.clientIds.reduce((newState, id) => ({
64345          ...newState,
64346          [id]: action.type === 'expand'
64347        }), {})
64348      };
64349    }
64350    return state;
64351  };
64352  const BLOCK_LIST_ITEM_HEIGHT = 32;
64353  
64354  /** @typedef {import('react').ComponentType} ComponentType */
64355  /** @typedef {import('react').Ref<HTMLElement>} Ref */
64356  
64357  /**
64358   * Show a hierarchical list of blocks.
64359   *
64360   * @param {Object}         props                        Components props.
64361   * @param {string}         props.id                     An HTML element id for the root element of ListView.
64362   * @param {Array}          props.blocks                 _deprecated_ Custom subset of block client IDs to be used instead of the default hierarchy.
64363   * @param {?HTMLElement}   props.dropZoneElement        Optional element to be used as the drop zone.
64364   * @param {?boolean}       props.showBlockMovers        Flag to enable block movers. Defaults to `false`.
64365   * @param {?boolean}       props.isExpanded             Flag to determine whether nested levels are expanded by default. Defaults to `false`.
64366   * @param {?boolean}       props.showAppender           Flag to show or hide the block appender. Defaults to `false`.
64367   * @param {?ComponentType} props.blockSettingsMenu      Optional more menu substitution. Defaults to the standard `BlockSettingsDropdown` component.
64368   * @param {string}         props.rootClientId           The client id of the root block from which we determine the blocks to show in the list.
64369   * @param {string}         props.description            Optional accessible description for the tree grid component.
64370   * @param {?Function}      props.onSelect               Optional callback to be invoked when a block is selected. Receives the block object that was selected.
64371   * @param {?ComponentType} props.additionalBlockContent Component that renders additional block content UI.
64372   * @param {Ref}            ref                          Forwarded ref
64373   */
64374  function ListViewComponent({
64375    id,
64376    blocks,
64377    dropZoneElement,
64378    showBlockMovers = false,
64379    isExpanded = false,
64380    showAppender = false,
64381    blockSettingsMenu: BlockSettingsMenu = BlockSettingsDropdown,
64382    rootClientId,
64383    description,
64384    onSelect,
64385    additionalBlockContent: AdditionalBlockContent
64386  }, ref) {
64387    // This can be removed once we no longer need to support the blocks prop.
64388    if (blocks) {
64389      external_wp_deprecated_default()('`blocks` property in `wp.blockEditor.__experimentalListView`', {
64390        since: '6.3',
64391        alternative: '`rootClientId` property'
64392      });
64393    }
64394    const instanceId = (0,external_wp_compose_namespaceObject.useInstanceId)(ListViewComponent);
64395    const {
64396      clientIdsTree,
64397      draggedClientIds,
64398      selectedClientIds
64399    } = useListViewClientIds({
64400      blocks,
64401      rootClientId
64402    });
64403    const blockIndexes = useListViewBlockIndexes(clientIdsTree);
64404    const {
64405      getBlock
64406    } = (0,external_wp_data_namespaceObject.useSelect)(store);
64407    const {
64408      visibleBlockCount
64409    } = (0,external_wp_data_namespaceObject.useSelect)(select => {
64410      const {
64411        getGlobalBlockCount,
64412        getClientIdsOfDescendants
64413      } = select(store);
64414      const draggedBlockCount = draggedClientIds?.length > 0 ? getClientIdsOfDescendants(draggedClientIds).length + 1 : 0;
64415      return {
64416        visibleBlockCount: getGlobalBlockCount() - draggedBlockCount
64417      };
64418    }, [draggedClientIds]);
64419    const {
64420      updateBlockSelection
64421    } = useBlockSelection();
64422    const [expandedState, setExpandedState] = (0,external_wp_element_namespaceObject.useReducer)(expanded, {});
64423    const [insertedBlock, setInsertedBlock] = (0,external_wp_element_namespaceObject.useState)(null);
64424    const {
64425      setSelectedTreeId
64426    } = useListViewExpandSelectedItem({
64427      firstSelectedBlockClientId: selectedClientIds[0],
64428      setExpandedState
64429    });
64430    const selectEditorBlock = (0,external_wp_element_namespaceObject.useCallback)(
64431    /**
64432     * @param {MouseEvent | KeyboardEvent | undefined} event
64433     * @param {string}                                 blockClientId
64434     * @param {null | undefined | -1 | 1}              focusPosition
64435     */
64436    (event, blockClientId, focusPosition) => {
64437      updateBlockSelection(event, blockClientId, null, focusPosition);
64438      setSelectedTreeId(blockClientId);
64439      if (onSelect) {
64440        onSelect(getBlock(blockClientId));
64441      }
64442    }, [setSelectedTreeId, updateBlockSelection, onSelect, getBlock]);
64443    const {
64444      ref: dropZoneRef,
64445      target: blockDropTarget
64446    } = useListViewDropZone({
64447      dropZoneElement,
64448      expandedState,
64449      setExpandedState
64450    });
64451    const elementRef = (0,external_wp_element_namespaceObject.useRef)();
64452  
64453    // Allow handling of copy, cut, and paste events.
64454    const clipBoardRef = use_clipboard_handler_useClipboardHandler({
64455      selectBlock: selectEditorBlock
64456    });
64457    const treeGridRef = (0,external_wp_compose_namespaceObject.useMergeRefs)([clipBoardRef, elementRef, dropZoneRef, ref]);
64458    (0,external_wp_element_namespaceObject.useEffect)(() => {
64459      // If a blocks are already selected when the list view is initially
64460      // mounted, shift focus to the first selected block.
64461      if (selectedClientIds?.length) {
64462        focusListItem(selectedClientIds[0], elementRef?.current);
64463      }
64464      // Only focus on the selected item when the list view is mounted.
64465    }, []);
64466    const expand = (0,external_wp_element_namespaceObject.useCallback)(clientId => {
64467      if (!clientId) {
64468        return;
64469      }
64470      const clientIds = Array.isArray(clientId) ? clientId : [clientId];
64471      setExpandedState({
64472        type: 'expand',
64473        clientIds
64474      });
64475    }, [setExpandedState]);
64476    const collapse = (0,external_wp_element_namespaceObject.useCallback)(clientId => {
64477      if (!clientId) {
64478        return;
64479      }
64480      setExpandedState({
64481        type: 'collapse',
64482        clientIds: [clientId]
64483      });
64484    }, [setExpandedState]);
64485    const collapseAll = (0,external_wp_element_namespaceObject.useCallback)(() => {
64486      setExpandedState({
64487        type: 'clear'
64488      });
64489    }, [setExpandedState]);
64490    const expandRow = (0,external_wp_element_namespaceObject.useCallback)(row => {
64491      expand(row?.dataset?.block);
64492    }, [expand]);
64493    const collapseRow = (0,external_wp_element_namespaceObject.useCallback)(row => {
64494      collapse(row?.dataset?.block);
64495    }, [collapse]);
64496    const focusRow = (0,external_wp_element_namespaceObject.useCallback)((event, startRow, endRow) => {
64497      if (event.shiftKey) {
64498        updateBlockSelection(event, startRow?.dataset?.block, endRow?.dataset?.block);
64499      }
64500    }, [updateBlockSelection]);
64501    useListViewCollapseItems({
64502      collapseAll,
64503      expand
64504    });
64505    const firstDraggedBlockClientId = draggedClientIds?.[0];
64506  
64507    // Convert a blockDropTarget into indexes relative to the blocks in the list view.
64508    // These values are used to determine which blocks should be displaced to make room
64509    // for the drop indicator. See `ListViewBranch` and `getDragDisplacementValues`.
64510    const {
64511      blockDropTargetIndex,
64512      blockDropPosition,
64513      firstDraggedBlockIndex
64514    } = (0,external_wp_element_namespaceObject.useMemo)(() => {
64515      let _blockDropTargetIndex, _firstDraggedBlockIndex;
64516      if (blockDropTarget?.clientId) {
64517        const foundBlockIndex = blockIndexes[blockDropTarget.clientId];
64518        // If dragging below or inside the block, treat the drop target as the next block.
64519        _blockDropTargetIndex = foundBlockIndex === undefined || blockDropTarget?.dropPosition === 'top' ? foundBlockIndex : foundBlockIndex + 1;
64520      } else if (blockDropTarget === null) {
64521        // A `null` value is used to indicate that the user is dragging outside of the list view.
64522        _blockDropTargetIndex = null;
64523      }
64524      if (firstDraggedBlockClientId) {
64525        const foundBlockIndex = blockIndexes[firstDraggedBlockClientId];
64526        _firstDraggedBlockIndex = foundBlockIndex === undefined || blockDropTarget?.dropPosition === 'top' ? foundBlockIndex : foundBlockIndex + 1;
64527      }
64528      return {
64529        blockDropTargetIndex: _blockDropTargetIndex,
64530        blockDropPosition: blockDropTarget?.dropPosition,
64531        firstDraggedBlockIndex: _firstDraggedBlockIndex
64532      };
64533    }, [blockDropTarget, blockIndexes, firstDraggedBlockClientId]);
64534    const contextValue = (0,external_wp_element_namespaceObject.useMemo)(() => ({
64535      blockDropPosition,
64536      blockDropTargetIndex,
64537      blockIndexes,
64538      draggedClientIds,
64539      expandedState,
64540      expand,
64541      firstDraggedBlockIndex,
64542      collapse,
64543      collapseAll,
64544      BlockSettingsMenu,
64545      listViewInstanceId: instanceId,
64546      AdditionalBlockContent,
64547      insertedBlock,
64548      setInsertedBlock,
64549      treeGridElementRef: elementRef,
64550      rootClientId
64551    }), [blockDropPosition, blockDropTargetIndex, blockIndexes, draggedClientIds, expandedState, expand, firstDraggedBlockIndex, collapse, collapseAll, BlockSettingsMenu, instanceId, AdditionalBlockContent, insertedBlock, setInsertedBlock, rootClientId]);
64552  
64553    // List View renders a fixed number of items and relies on each having a fixed item height of 36px.
64554    // If this value changes, we should also change the itemHeight value set in useFixedWindowList.
64555    // See: https://github.com/WordPress/gutenberg/pull/35230 for additional context.
64556    const [fixedListWindow] = (0,external_wp_compose_namespaceObject.__experimentalUseFixedWindowList)(elementRef, BLOCK_LIST_ITEM_HEIGHT, visibleBlockCount, {
64557      // Ensure that the windowing logic is recalculated when the expanded state changes.
64558      // This is necessary because expanding a collapsed block in a short list view can
64559      // switch the list view to a tall list view with a scrollbar, and vice versa.
64560      // When this happens, the windowing logic needs to be recalculated to ensure that
64561      // the correct number of blocks are rendered, by rechecking for a scroll container.
64562      expandedState,
64563      useWindowing: true,
64564      windowOverscan: 40
64565    });
64566  
64567    // If there are no blocks to show and we're not showing the appender, do not render the list view.
64568    if (!clientIdsTree.length && !showAppender) {
64569      return null;
64570    }
64571    const describedById = description && `block-editor-list-view-description-$instanceId}`;
64572    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_data_namespaceObject.AsyncModeProvider, {
64573      value: true,
64574      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ListViewDropIndicatorPreview, {
64575        draggedBlockClientId: firstDraggedBlockClientId,
64576        listViewRef: elementRef,
64577        blockDropTarget: blockDropTarget
64578      }), description && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.VisuallyHidden, {
64579        id: describedById,
64580        children: description
64581      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalTreeGrid, {
64582        id: id,
64583        className: dist_clsx('block-editor-list-view-tree', {
64584          'is-dragging': draggedClientIds?.length > 0 && blockDropTargetIndex !== undefined
64585        }),
64586        "aria-label": (0,external_wp_i18n_namespaceObject.__)('Block navigation structure'),
64587        ref: treeGridRef,
64588        onCollapseRow: collapseRow,
64589        onExpandRow: expandRow,
64590        onFocusRow: focusRow,
64591        applicationAriaLabel: (0,external_wp_i18n_namespaceObject.__)('Block navigation structure'),
64592        "aria-describedby": describedById,
64593        style: {
64594          '--wp-admin--list-view-dragged-items-height': draggedClientIds?.length ? `$BLOCK_LIST_ITEM_HEIGHT * (draggedClientIds.length - 1)}px` : null
64595        },
64596        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ListViewContext.Provider, {
64597          value: contextValue,
64598          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(branch, {
64599            blocks: clientIdsTree,
64600            parentId: rootClientId,
64601            selectBlock: selectEditorBlock,
64602            showBlockMovers: showBlockMovers,
64603            fixedListWindow: fixedListWindow,
64604            selectedClientIds: selectedClientIds,
64605            isExpanded: isExpanded,
64606            showAppender: showAppender
64607          })
64608        })
64609      })]
64610    });
64611  }
64612  
64613  // This is the private API for the ListView component.
64614  // It allows access to all props, not just the public ones.
64615  const PrivateListView = (0,external_wp_element_namespaceObject.forwardRef)(ListViewComponent);
64616  
64617  // This is the public API for the ListView component.
64618  // We wrap the PrivateListView component to hide some props from the public API.
64619  /* harmony default export */ const components_list_view = ((0,external_wp_element_namespaceObject.forwardRef)((props, ref) => {
64620    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PrivateListView, {
64621      ref: ref,
64622      ...props,
64623      showAppender: false,
64624      rootClientId: null,
64625      onSelect: null,
64626      additionalBlockContent: null,
64627      blockSettingsMenu: undefined
64628    });
64629  }));
64630  
64631  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-navigation/dropdown.js
64632  /**
64633   * WordPress dependencies
64634   */
64635  
64636  
64637  /**
64638   * WordPress dependencies
64639   */
64640  
64641  
64642  
64643  
64644  
64645  
64646  /**
64647   * Internal dependencies
64648   */
64649  
64650  
64651  
64652  function BlockNavigationDropdownToggle({
64653    isEnabled,
64654    onToggle,
64655    isOpen,
64656    innerRef,
64657    ...props
64658  }) {
64659    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
64660      __next40pxDefaultSize: true,
64661      ...props,
64662      ref: innerRef,
64663      icon: list_view,
64664      "aria-expanded": isOpen,
64665      "aria-haspopup": "true",
64666      onClick: isEnabled ? onToggle : undefined
64667      /* translators: button label text should, if possible, be under 16 characters. */,
64668      label: (0,external_wp_i18n_namespaceObject.__)('List view'),
64669      className: "block-editor-block-navigation",
64670      "aria-disabled": !isEnabled
64671    });
64672  }
64673  function BlockNavigationDropdown({
64674    isDisabled,
64675    ...props
64676  }, ref) {
64677    external_wp_deprecated_default()('wp.blockEditor.BlockNavigationDropdown', {
64678      since: '6.1',
64679      alternative: 'wp.components.Dropdown and wp.blockEditor.ListView'
64680    });
64681    const hasBlocks = (0,external_wp_data_namespaceObject.useSelect)(select => !!select(store).getBlockCount(), []);
64682    const isEnabled = hasBlocks && !isDisabled;
64683    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Dropdown, {
64684      contentClassName: "block-editor-block-navigation__popover",
64685      popoverProps: {
64686        placement: 'bottom-start'
64687      },
64688      renderToggle: ({
64689        isOpen,
64690        onToggle
64691      }) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockNavigationDropdownToggle, {
64692        ...props,
64693        innerRef: ref,
64694        isOpen: isOpen,
64695        onToggle: onToggle,
64696        isEnabled: isEnabled
64697      }),
64698      renderContent: () => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
64699        className: "block-editor-block-navigation__container",
64700        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("p", {
64701          className: "block-editor-block-navigation__label",
64702          children: (0,external_wp_i18n_namespaceObject.__)('List view')
64703        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(components_list_view, {})]
64704      })
64705    });
64706  }
64707  /* harmony default export */ const dropdown = ((0,external_wp_element_namespaceObject.forwardRef)(BlockNavigationDropdown));
64708  
64709  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-styles/preview-panel.js
64710  /**
64711   * WordPress dependencies
64712   */
64713  
64714  
64715  
64716  /**
64717   * Internal dependencies
64718   */
64719  
64720  
64721  
64722  function BlockStylesPreviewPanel({
64723    genericPreviewBlock,
64724    style,
64725    className,
64726    activeStyle
64727  }) {
64728    const example = (0,external_wp_blocks_namespaceObject.getBlockType)(genericPreviewBlock.name)?.example;
64729    const styleClassName = replaceActiveStyle(className, activeStyle, style);
64730    const previewBlocks = (0,external_wp_element_namespaceObject.useMemo)(() => {
64731      return {
64732        ...genericPreviewBlock,
64733        title: style.label || style.name,
64734        description: style.description,
64735        initialAttributes: {
64736          ...genericPreviewBlock.attributes,
64737          className: styleClassName + ' block-editor-block-styles__block-preview-container'
64738        },
64739        example
64740      };
64741    }, [genericPreviewBlock, styleClassName]);
64742    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(preview_panel, {
64743      item: previewBlocks
64744    });
64745  }
64746  
64747  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-styles/index.js
64748  /**
64749   * External dependencies
64750   */
64751  
64752  
64753  /**
64754   * WordPress dependencies
64755   */
64756  
64757  
64758  
64759  
64760  /**
64761   * Internal dependencies
64762   */
64763  
64764  
64765  
64766  const block_styles_noop = () => {};
64767  
64768  // Block Styles component for the Settings Sidebar.
64769  function BlockStyles({
64770    clientId,
64771    onSwitch = block_styles_noop,
64772    onHoverClassName = block_styles_noop
64773  }) {
64774    const {
64775      onSelect,
64776      stylesToRender,
64777      activeStyle,
64778      genericPreviewBlock,
64779      className: previewClassName
64780    } = useStylesForBlocks({
64781      clientId,
64782      onSwitch
64783    });
64784    const [hoveredStyle, setHoveredStyle] = (0,external_wp_element_namespaceObject.useState)(null);
64785    const isMobileViewport = (0,external_wp_compose_namespaceObject.useViewportMatch)('medium', '<');
64786    if (!stylesToRender || stylesToRender.length === 0) {
64787      return null;
64788    }
64789    const debouncedSetHoveredStyle = (0,external_wp_compose_namespaceObject.debounce)(setHoveredStyle, 250);
64790    const onSelectStylePreview = style => {
64791      onSelect(style);
64792      onHoverClassName(null);
64793      setHoveredStyle(null);
64794      debouncedSetHoveredStyle.cancel();
64795    };
64796    const styleItemHandler = item => {
64797      var _item$name;
64798      if (hoveredStyle === item) {
64799        debouncedSetHoveredStyle.cancel();
64800        return;
64801      }
64802      debouncedSetHoveredStyle(item);
64803      onHoverClassName((_item$name = item?.name) !== null && _item$name !== void 0 ? _item$name : null);
64804    };
64805    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
64806      className: "block-editor-block-styles",
64807      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
64808        className: "block-editor-block-styles__variants",
64809        children: stylesToRender.map(style => {
64810          const buttonText = style.label || style.name;
64811          return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
64812            __next40pxDefaultSize: true,
64813            className: dist_clsx('block-editor-block-styles__item', {
64814              'is-active': activeStyle.name === style.name
64815            }),
64816            variant: "secondary",
64817            label: buttonText,
64818            onMouseEnter: () => styleItemHandler(style),
64819            onFocus: () => styleItemHandler(style),
64820            onMouseLeave: () => styleItemHandler(null),
64821            onBlur: () => styleItemHandler(null),
64822            onClick: () => onSelectStylePreview(style),
64823            "aria-current": activeStyle.name === style.name,
64824            children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalTruncate, {
64825              numberOfLines: 1,
64826              className: "block-editor-block-styles__item-text",
64827              children: buttonText
64828            })
64829          }, style.name);
64830        })
64831      }), hoveredStyle && !isMobileViewport && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Popover, {
64832        placement: "left-start",
64833        offset: 34,
64834        focusOnMount: false,
64835        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
64836          className: "block-editor-block-styles__preview-panel",
64837          onMouseLeave: () => styleItemHandler(null),
64838          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockStylesPreviewPanel, {
64839            activeStyle: activeStyle,
64840            className: previewClassName,
64841            genericPreviewBlock: genericPreviewBlock,
64842            style: hoveredStyle
64843          })
64844        })
64845      })]
64846    });
64847  }
64848  /* harmony default export */ const block_styles = (BlockStyles);
64849  
64850  ;// ./node_modules/@wordpress/icons/build-module/library/paragraph.js
64851  /**
64852   * WordPress dependencies
64853   */
64854  
64855  
64856  const paragraph = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
64857    xmlns: "http://www.w3.org/2000/svg",
64858    viewBox: "0 0 24 24",
64859    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
64860      d: "m9.99609 14v-.2251l.00391.0001v6.225h1.5v-14.5h2.5v14.5h1.5v-14.5h3v-1.5h-8.50391c-2.76142 0-5 2.23858-5 5 0 2.7614 2.23858 5 5 5z"
64861    })
64862  });
64863  /* harmony default export */ const library_paragraph = (paragraph);
64864  
64865  ;// ./node_modules/@wordpress/icons/build-module/library/heading-level-1.js
64866  /**
64867   * WordPress dependencies
64868   */
64869  
64870  
64871  const headingLevel1 = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
64872    xmlns: "http://www.w3.org/2000/svg",
64873    viewBox: "0 0 24 24",
64874    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
64875      d: "M17.6 7c-.6.9-1.5 1.7-2.6 2v1h2v7h2V7h-1.4zM11 11H7V7H5v10h2v-4h4v4h2V7h-2v4z"
64876    })
64877  });
64878  /* harmony default export */ const heading_level_1 = (headingLevel1);
64879  
64880  ;// ./node_modules/@wordpress/icons/build-module/library/heading-level-2.js
64881  /**
64882   * WordPress dependencies
64883   */
64884  
64885  
64886  const headingLevel2 = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
64887    xmlns: "http://www.w3.org/2000/svg",
64888    viewBox: "0 0 24 24",
64889    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
64890      d: "M9 11.1H5v-4H3v10h2v-4h4v4h2v-10H9v4zm8 4c.5-.4.6-.6 1.1-1.1.4-.4.8-.8 1.2-1.3.3-.4.6-.8.9-1.3.2-.4.3-.8.3-1.3 0-.4-.1-.9-.3-1.3-.2-.4-.4-.7-.8-1-.3-.3-.7-.5-1.2-.6-.5-.2-1-.2-1.5-.2-.4 0-.7 0-1.1.1-.3.1-.7.2-1 .3-.3.1-.6.3-.9.5-.3.2-.6.4-.8.7l1.2 1.2c.3-.3.6-.5 1-.7.4-.2.7-.3 1.2-.3s.9.1 1.3.4c.3.3.5.7.5 1.1 0 .4-.1.8-.4 1.1-.3.5-.6.9-1 1.2-.4.4-1 .9-1.6 1.4-.6.5-1.4 1.1-2.2 1.6v1.5h8v-2H17z"
64891    })
64892  });
64893  /* harmony default export */ const heading_level_2 = (headingLevel2);
64894  
64895  ;// ./node_modules/@wordpress/icons/build-module/library/heading-level-3.js
64896  /**
64897   * WordPress dependencies
64898   */
64899  
64900  
64901  const headingLevel3 = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
64902    xmlns: "http://www.w3.org/2000/svg",
64903    viewBox: "0 0 24 24",
64904    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
64905      d: "M9 11H5V7H3v10h2v-4h4v4h2V7H9v4zm11.3 1.7c-.4-.4-1-.7-1.6-.8v-.1c.6-.2 1.1-.5 1.5-.9.3-.4.5-.8.5-1.3 0-.4-.1-.8-.3-1.1-.2-.3-.5-.6-.8-.8-.4-.2-.8-.4-1.2-.5-.6-.1-1.1-.2-1.6-.2-.6 0-1.3.1-1.8.3s-1.1.5-1.6.9l1.2 1.4c.4-.2.7-.4 1.1-.6.3-.2.7-.3 1.1-.3.4 0 .8.1 1.1.3.3.2.4.5.4.8 0 .4-.2.7-.6.9-.7.3-1.5.5-2.2.4v1.6c.5 0 1 0 1.5.1.3.1.7.2 1 .3.2.1.4.2.5.4s.1.4.1.6c0 .3-.2.7-.5.8-.4.2-.9.3-1.4.3s-1-.1-1.4-.3c-.4-.2-.8-.4-1.2-.7L13 15.6c.5.4 1 .8 1.6 1 .7.3 1.5.4 2.3.4.6 0 1.1-.1 1.6-.2.4-.1.9-.2 1.3-.5.4-.2.7-.5.9-.9.2-.4.3-.8.3-1.2 0-.6-.3-1.1-.7-1.5z"
64906    })
64907  });
64908  /* harmony default export */ const heading_level_3 = (headingLevel3);
64909  
64910  ;// ./node_modules/@wordpress/icons/build-module/library/heading-level-4.js
64911  /**
64912   * WordPress dependencies
64913   */
64914  
64915  
64916  const headingLevel4 = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
64917    xmlns: "http://www.w3.org/2000/svg",
64918    viewBox: "0 0 24 24",
64919    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
64920      d: "M20 13V7h-3l-4 6v2h5v2h2v-2h1v-2h-1zm-2 0h-2.8L18 9v4zm-9-2H5V7H3v10h2v-4h4v4h2V7H9v4z"
64921    })
64922  });
64923  /* harmony default export */ const heading_level_4 = (headingLevel4);
64924  
64925  ;// ./node_modules/@wordpress/icons/build-module/library/heading-level-5.js
64926  /**
64927   * WordPress dependencies
64928   */
64929  
64930  
64931  const headingLevel5 = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
64932    xmlns: "http://www.w3.org/2000/svg",
64933    viewBox: "0 0 24 24",
64934    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
64935      d: "M9 11H5V7H3v10h2v-4h4v4h2V7H9v4zm11.7 1.2c-.2-.3-.5-.7-.8-.9-.3-.3-.7-.5-1.1-.6-.5-.1-.9-.2-1.4-.2-.2 0-.5.1-.7.1-.2.1-.5.1-.7.2l.1-1.9h4.3V7H14l-.3 5 1 .6.5-.2.4-.1c.1-.1.3-.1.4-.1h.5c.5 0 1 .1 1.4.4.4.2.6.7.6 1.1 0 .4-.2.8-.6 1.1-.4.3-.9.4-1.4.4-.4 0-.9-.1-1.3-.3-.4-.2-.7-.4-1.1-.7 0 0-1.1 1.4-1 1.5.5.4 1 .8 1.6 1 .7.3 1.5.4 2.3.4.5 0 1-.1 1.5-.3s.9-.4 1.3-.7c.4-.3.7-.7.9-1.1s.3-.9.3-1.4-.1-1-.3-1.4z"
64936    })
64937  });
64938  /* harmony default export */ const heading_level_5 = (headingLevel5);
64939  
64940  ;// ./node_modules/@wordpress/icons/build-module/library/heading-level-6.js
64941  /**
64942   * WordPress dependencies
64943   */
64944  
64945  
64946  const headingLevel6 = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
64947    xmlns: "http://www.w3.org/2000/svg",
64948    viewBox: "0 0 24 24",
64949    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
64950      d: "M20.7 12.4c-.2-.3-.4-.6-.7-.9s-.6-.5-1-.6c-.4-.2-.8-.2-1.2-.2-.5 0-.9.1-1.3.3s-.8.5-1.2.8c0-.5 0-.9.2-1.4l.6-.9c.2-.2.5-.4.8-.5.6-.2 1.3-.2 1.9 0 .3.1.6.3.8.5 0 0 1.3-1.3 1.3-1.4-.4-.3-.9-.6-1.4-.8-.6-.2-1.3-.3-2-.3-.6 0-1.1.1-1.7.4-.5.2-1 .5-1.4.9-.4.4-.8 1-1 1.6-.3.7-.4 1.5-.4 2.3s.1 1.5.3 2.1c.2.6.6 1.1 1 1.5.4.4.9.7 1.4.9 1 .3 2 .3 3 0 .4-.1.8-.3 1.2-.6.3-.3.6-.6.8-1 .2-.5.3-.9.3-1.4s-.1-.9-.3-1.3zm-2 2.1c-.1.2-.3.4-.4.5-.1.1-.3.2-.5.2-.2.1-.4.1-.6.1-.2.1-.5 0-.7-.1-.2 0-.3-.2-.5-.3-.1-.2-.3-.4-.4-.6-.2-.3-.3-.7-.3-1 .3-.3.6-.5 1-.7.3-.1.7-.2 1-.2.4 0 .8.1 1.1.3.3.3.4.7.4 1.1 0 .2 0 .5-.1.7zM9 11H5V7H3v10h2v-4h4v4h2V7H9v4z"
64951    })
64952  });
64953  /* harmony default export */ const heading_level_6 = (headingLevel6);
64954  
64955  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-heading-level-dropdown/heading-level-icon.js
64956  /**
64957   * WordPress dependencies
64958   */
64959  
64960  
64961  
64962  /** @typedef {import('react').ComponentType} ComponentType */
64963  
64964  /**
64965   * HeadingLevelIcon props.
64966   *
64967   * @typedef WPHeadingLevelIconProps
64968   *
64969   * @property {number} level The heading level to show an icon for.
64970   */
64971  
64972  const LEVEL_TO_PATH = {
64973    0: library_paragraph,
64974    1: heading_level_1,
64975    2: heading_level_2,
64976    3: heading_level_3,
64977    4: heading_level_4,
64978    5: heading_level_5,
64979    6: heading_level_6
64980  };
64981  
64982  /**
64983   * Heading level icon.
64984   *
64985   * @param {WPHeadingLevelIconProps} props Component props.
64986   *
64987   * @return {?ComponentType} The icon.
64988   */
64989  function HeadingLevelIcon({
64990    level
64991  }) {
64992    if (LEVEL_TO_PATH[level]) {
64993      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Icon, {
64994        icon: LEVEL_TO_PATH[level]
64995      });
64996    }
64997    return null;
64998  }
64999  
65000  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-heading-level-dropdown/index.js
65001  /**
65002   * WordPress dependencies
65003   */
65004  
65005  
65006  
65007  /**
65008   * Internal dependencies
65009   */
65010  
65011  
65012  const HEADING_LEVELS = [1, 2, 3, 4, 5, 6];
65013  const block_heading_level_dropdown_POPOVER_PROPS = {
65014    className: 'block-library-heading-level-dropdown'
65015  };
65016  
65017  /** @typedef {import('react').ComponentType} ComponentType */
65018  
65019  /**
65020   * HeadingLevelDropdown props.
65021   *
65022   * @typedef WPHeadingLevelDropdownProps
65023   *
65024   * @property {number}     value    The chosen heading level.
65025   * @property {number[]}   options  An array of supported heading levels.
65026   * @property {()=>number} onChange Function called with
65027   *                                 the selected value changes.
65028   */
65029  
65030  /**
65031   * Dropdown for selecting a heading level (1 through 6) or paragraph (0).
65032   *
65033   * @param {WPHeadingLevelDropdownProps} props Component props.
65034   *
65035   * @return {ComponentType} The toolbar.
65036   */
65037  function HeadingLevelDropdown({
65038    options = HEADING_LEVELS,
65039    value,
65040    onChange
65041  }) {
65042    const validOptions = options.filter(option => option === 0 || HEADING_LEVELS.includes(option)).sort((a, b) => a - b); // Sorts numerically in ascending order;
65043  
65044    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarDropdownMenu, {
65045      popoverProps: block_heading_level_dropdown_POPOVER_PROPS,
65046      icon: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(HeadingLevelIcon, {
65047        level: value
65048      }),
65049      label: (0,external_wp_i18n_namespaceObject.__)('Change level'),
65050      controls: validOptions.map(targetLevel => {
65051        const isActive = targetLevel === value;
65052        return {
65053          icon: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(HeadingLevelIcon, {
65054            level: targetLevel
65055          }),
65056          title: targetLevel === 0 ? (0,external_wp_i18n_namespaceObject.__)('Paragraph') : (0,external_wp_i18n_namespaceObject.sprintf)(
65057          // translators: %d: heading level e.g: "1", "2", "3"
65058          (0,external_wp_i18n_namespaceObject.__)('Heading %d'), targetLevel),
65059          isActive,
65060          onClick() {
65061            onChange(targetLevel);
65062          },
65063          role: 'menuitemradio'
65064        };
65065      })
65066    });
65067  }
65068  
65069  ;// ./node_modules/@wordpress/icons/build-module/library/layout.js
65070  /**
65071   * WordPress dependencies
65072   */
65073  
65074  
65075  const layout_layout = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
65076    xmlns: "http://www.w3.org/2000/svg",
65077    viewBox: "0 0 24 24",
65078    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
65079      d: "M18 5.5H6a.5.5 0 00-.5.5v3h13V6a.5.5 0 00-.5-.5zm.5 5H10v8h8a.5.5 0 00.5-.5v-7.5zm-10 0h-3V18a.5.5 0 00.5.5h2.5v-8zM6 4h12a2 2 0 012 2v12a2 2 0 01-2 2H6a2 2 0 01-2-2V6a2 2 0 012-2z"
65080    })
65081  });
65082  /* harmony default export */ const library_layout = (layout_layout);
65083  
65084  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-variation-picker/index.js
65085  /**
65086   * External dependencies
65087   */
65088  
65089  
65090  /**
65091   * WordPress dependencies
65092   */
65093  
65094  
65095  
65096  
65097  function BlockVariationPicker({
65098    icon = library_layout,
65099    label = (0,external_wp_i18n_namespaceObject.__)('Choose variation'),
65100    instructions = (0,external_wp_i18n_namespaceObject.__)('Select a variation to start with:'),
65101    variations,
65102    onSelect,
65103    allowSkip
65104  }) {
65105    const classes = dist_clsx('block-editor-block-variation-picker', {
65106      'has-many-variations': variations.length > 4
65107    });
65108    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.Placeholder, {
65109      icon: icon,
65110      label: label,
65111      instructions: instructions,
65112      className: classes,
65113      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("ul", {
65114        className: "block-editor-block-variation-picker__variations",
65115        role: "list",
65116        "aria-label": (0,external_wp_i18n_namespaceObject.__)('Block variations'),
65117        children: variations.map(variation => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("li", {
65118          children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
65119            __next40pxDefaultSize: true,
65120            variant: "tertiary",
65121            icon: variation.icon && variation.icon.src ? variation.icon.src : variation.icon,
65122            iconSize: 48,
65123            onClick: () => onSelect(variation),
65124            className: "block-editor-block-variation-picker__variation",
65125            label: variation.description || variation.title
65126          }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("span", {
65127            className: "block-editor-block-variation-picker__variation-label",
65128            children: variation.title
65129          })]
65130        }, variation.name))
65131      }), allowSkip && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
65132        className: "block-editor-block-variation-picker__skip",
65133        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
65134          __next40pxDefaultSize: true,
65135          variant: "link",
65136          onClick: () => onSelect(),
65137          children: (0,external_wp_i18n_namespaceObject.__)('Skip')
65138        })
65139      })]
65140    });
65141  }
65142  /* harmony default export */ const block_variation_picker = (BlockVariationPicker);
65143  
65144  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-pattern-setup/constants.js
65145  const VIEWMODES = {
65146    carousel: 'carousel',
65147    grid: 'grid'
65148  };
65149  
65150  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-pattern-setup/setup-toolbar.js
65151  /**
65152   * WordPress dependencies
65153   */
65154  
65155  
65156  
65157  
65158  /**
65159   * Internal dependencies
65160   */
65161  
65162  
65163  const Actions = ({
65164    onBlockPatternSelect
65165  }) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
65166    className: "block-editor-block-pattern-setup__actions",
65167    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
65168      __next40pxDefaultSize: true,
65169      variant: "primary",
65170      onClick: onBlockPatternSelect,
65171      children: (0,external_wp_i18n_namespaceObject.__)('Choose')
65172    })
65173  });
65174  const CarouselNavigation = ({
65175    handlePrevious,
65176    handleNext,
65177    activeSlide,
65178    totalSlides
65179  }) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
65180    className: "block-editor-block-pattern-setup__navigation",
65181    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
65182      size: "compact",
65183      icon: (0,external_wp_i18n_namespaceObject.isRTL)() ? chevron_right : chevron_left,
65184      label: (0,external_wp_i18n_namespaceObject.__)('Previous pattern'),
65185      onClick: handlePrevious,
65186      disabled: activeSlide === 0,
65187      accessibleWhenDisabled: true
65188    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
65189      size: "compact",
65190      icon: (0,external_wp_i18n_namespaceObject.isRTL)() ? chevron_left : chevron_right,
65191      label: (0,external_wp_i18n_namespaceObject.__)('Next pattern'),
65192      onClick: handleNext,
65193      disabled: activeSlide === totalSlides - 1,
65194      accessibleWhenDisabled: true
65195    })]
65196  });
65197  const SetupToolbar = ({
65198    viewMode,
65199    setViewMode,
65200    handlePrevious,
65201    handleNext,
65202    activeSlide,
65203    totalSlides,
65204    onBlockPatternSelect
65205  }) => {
65206    const isCarouselView = viewMode === VIEWMODES.carousel;
65207    const displayControls = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
65208      className: "block-editor-block-pattern-setup__display-controls",
65209      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
65210        size: "compact",
65211        icon: stretch_full_width,
65212        label: (0,external_wp_i18n_namespaceObject.__)('Carousel view'),
65213        onClick: () => setViewMode(VIEWMODES.carousel),
65214        isPressed: isCarouselView
65215      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
65216        size: "compact",
65217        icon: library_grid,
65218        label: (0,external_wp_i18n_namespaceObject.__)('Grid view'),
65219        onClick: () => setViewMode(VIEWMODES.grid),
65220        isPressed: viewMode === VIEWMODES.grid
65221      })]
65222    });
65223    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
65224      className: "block-editor-block-pattern-setup__toolbar",
65225      children: [isCarouselView && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(CarouselNavigation, {
65226        handlePrevious: handlePrevious,
65227        handleNext: handleNext,
65228        activeSlide: activeSlide,
65229        totalSlides: totalSlides
65230      }), displayControls, isCarouselView && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Actions, {
65231        onBlockPatternSelect: onBlockPatternSelect
65232      })]
65233    });
65234  };
65235  /* harmony default export */ const setup_toolbar = (SetupToolbar);
65236  
65237  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-pattern-setup/use-patterns-setup.js
65238  /**
65239   * WordPress dependencies
65240   */
65241  
65242  
65243  /**
65244   * Internal dependencies
65245   */
65246  
65247  function usePatternsSetup(clientId, blockName, filterPatternsFn) {
65248    return (0,external_wp_data_namespaceObject.useSelect)(select => {
65249      const {
65250        getBlockRootClientId,
65251        getPatternsByBlockTypes,
65252        __experimentalGetAllowedPatterns
65253      } = select(store);
65254      const rootClientId = getBlockRootClientId(clientId);
65255      if (filterPatternsFn) {
65256        return __experimentalGetAllowedPatterns(rootClientId).filter(filterPatternsFn);
65257      }
65258      return getPatternsByBlockTypes(blockName, rootClientId);
65259    }, [clientId, blockName, filterPatternsFn]);
65260  }
65261  /* harmony default export */ const use_patterns_setup = (usePatternsSetup);
65262  
65263  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-pattern-setup/index.js
65264  /**
65265   * WordPress dependencies
65266   */
65267  
65268  
65269  
65270  
65271  
65272  
65273  
65274  /**
65275   * Internal dependencies
65276   */
65277  
65278  
65279  
65280  
65281  
65282  
65283  const SetupContent = ({
65284    viewMode,
65285    activeSlide,
65286    patterns,
65287    onBlockPatternSelect,
65288    showTitles
65289  }) => {
65290    const containerClass = 'block-editor-block-pattern-setup__container';
65291    if (viewMode === VIEWMODES.carousel) {
65292      const slideClass = new Map([[activeSlide, 'active-slide'], [activeSlide - 1, 'previous-slide'], [activeSlide + 1, 'next-slide']]);
65293      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
65294        className: "block-editor-block-pattern-setup__carousel",
65295        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
65296          className: containerClass,
65297          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
65298            className: "carousel-container",
65299            children: patterns.map((pattern, index) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockPatternSlide, {
65300              active: index === activeSlide,
65301              className: slideClass.get(index) || '',
65302              pattern: pattern
65303            }, pattern.name))
65304          })
65305        })
65306      });
65307    }
65308    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
65309      className: "block-editor-block-pattern-setup__grid",
65310      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Composite, {
65311        role: "listbox",
65312        className: containerClass,
65313        "aria-label": (0,external_wp_i18n_namespaceObject.__)('Patterns list'),
65314        children: patterns.map(pattern => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_pattern_setup_BlockPattern, {
65315          pattern: pattern,
65316          onSelect: onBlockPatternSelect,
65317          showTitles: showTitles
65318        }, pattern.name))
65319      })
65320    });
65321  };
65322  function block_pattern_setup_BlockPattern({
65323    pattern,
65324    onSelect,
65325    showTitles
65326  }) {
65327    const baseClassName = 'block-editor-block-pattern-setup-list';
65328    const {
65329      blocks,
65330      description,
65331      viewportWidth = 700
65332    } = pattern;
65333    const descriptionId = (0,external_wp_compose_namespaceObject.useInstanceId)(block_pattern_setup_BlockPattern, `$baseClassName}__item-description`);
65334    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
65335      className: `$baseClassName}__list-item`,
65336      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.Composite.Item, {
65337        render: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
65338          "aria-describedby": description ? descriptionId : undefined,
65339          "aria-label": pattern.title,
65340          className: `$baseClassName}__item`
65341        }),
65342        id: `$baseClassName}__pattern__$pattern.name}`,
65343        role: "option",
65344        onClick: () => onSelect(blocks),
65345        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_preview, {
65346          blocks: blocks,
65347          viewportWidth: viewportWidth
65348        }), showTitles && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
65349          className: `$baseClassName}__item-title`,
65350          children: pattern.title
65351        }), !!description && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.VisuallyHidden, {
65352          id: descriptionId,
65353          children: description
65354        })]
65355      })
65356    });
65357  }
65358  function BlockPatternSlide({
65359    active,
65360    className,
65361    pattern,
65362    minHeight
65363  }) {
65364    const {
65365      blocks,
65366      title,
65367      description
65368    } = pattern;
65369    const descriptionId = (0,external_wp_compose_namespaceObject.useInstanceId)(BlockPatternSlide, 'block-editor-block-pattern-setup-list__item-description');
65370    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
65371      "aria-hidden": !active,
65372      role: "img",
65373      className: `pattern-slide $className}`,
65374      "aria-label": title,
65375      "aria-describedby": description ? descriptionId : undefined,
65376      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_preview, {
65377        blocks: blocks,
65378        minHeight: minHeight
65379      }), !!description && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.VisuallyHidden, {
65380        id: descriptionId,
65381        children: description
65382      })]
65383    });
65384  }
65385  const BlockPatternSetup = ({
65386    clientId,
65387    blockName,
65388    filterPatternsFn,
65389    onBlockPatternSelect,
65390    initialViewMode = VIEWMODES.carousel,
65391    showTitles = false
65392  }) => {
65393    const [viewMode, setViewMode] = (0,external_wp_element_namespaceObject.useState)(initialViewMode);
65394    const [activeSlide, setActiveSlide] = (0,external_wp_element_namespaceObject.useState)(0);
65395    const {
65396      replaceBlock
65397    } = (0,external_wp_data_namespaceObject.useDispatch)(store);
65398    const patterns = use_patterns_setup(clientId, blockName, filterPatternsFn);
65399    if (!patterns?.length) {
65400      return null;
65401    }
65402    const onBlockPatternSelectDefault = blocks => {
65403      const clonedBlocks = blocks.map(block => (0,external_wp_blocks_namespaceObject.cloneBlock)(block));
65404      replaceBlock(clientId, clonedBlocks);
65405    };
65406    const onPatternSelectCallback = onBlockPatternSelect || onBlockPatternSelectDefault;
65407    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_ReactJSXRuntime_namespaceObject.Fragment, {
65408      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
65409        className: `block-editor-block-pattern-setup view-mode-$viewMode}`,
65410        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(SetupContent, {
65411          viewMode: viewMode,
65412          activeSlide: activeSlide,
65413          patterns: patterns,
65414          onBlockPatternSelect: onPatternSelectCallback,
65415          showTitles: showTitles
65416        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(setup_toolbar, {
65417          viewMode: viewMode,
65418          setViewMode: setViewMode,
65419          activeSlide: activeSlide,
65420          totalSlides: patterns.length,
65421          handleNext: () => {
65422            setActiveSlide(active => Math.min(active + 1, patterns.length - 1));
65423          },
65424          handlePrevious: () => {
65425            setActiveSlide(active => Math.max(active - 1, 0));
65426          },
65427          onBlockPatternSelect: () => {
65428            onPatternSelectCallback(patterns[activeSlide].blocks);
65429          }
65430        })]
65431      })
65432    });
65433  };
65434  /* harmony default export */ const block_pattern_setup = (BlockPatternSetup);
65435  
65436  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-variation-transforms/index.js
65437  /**
65438   * WordPress dependencies
65439   */
65440  
65441  
65442  
65443  
65444  
65445  
65446  
65447  /**
65448   * Internal dependencies
65449   */
65450  
65451  
65452  
65453  
65454  function VariationsButtons({
65455    className,
65456    onSelectVariation,
65457    selectedValue,
65458    variations
65459  }) {
65460    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("fieldset", {
65461      className: className,
65462      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.VisuallyHidden, {
65463        as: "legend",
65464        children: (0,external_wp_i18n_namespaceObject.__)('Transform to variation')
65465      }), variations.map(variation => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
65466        __next40pxDefaultSize: true,
65467        size: "compact",
65468        icon: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_icon, {
65469          icon: variation.icon,
65470          showColors: true
65471        }),
65472        isPressed: selectedValue === variation.name,
65473        label: selectedValue === variation.name ? variation.title : (0,external_wp_i18n_namespaceObject.sprintf)(/* translators: %s: Block or block variation name. */
65474        (0,external_wp_i18n_namespaceObject.__)('Transform to %s'), variation.title),
65475        onClick: () => onSelectVariation(variation.name),
65476        "aria-label": variation.title,
65477        showTooltip: true
65478      }, variation.name))]
65479    });
65480  }
65481  function VariationsDropdown({
65482    className,
65483    onSelectVariation,
65484    selectedValue,
65485    variations
65486  }) {
65487    const selectOptions = variations.map(({
65488      name,
65489      title,
65490      description
65491    }) => ({
65492      value: name,
65493      label: title,
65494      info: description
65495    }));
65496    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.DropdownMenu, {
65497      className: className,
65498      label: (0,external_wp_i18n_namespaceObject.__)('Transform to variation'),
65499      text: (0,external_wp_i18n_namespaceObject.__)('Transform to variation'),
65500      popoverProps: {
65501        position: 'bottom center',
65502        className: `$className}__popover`
65503      },
65504      icon: chevron_down,
65505      toggleProps: {
65506        iconPosition: 'right'
65507      },
65508      children: () => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
65509        className: `$className}__container`,
65510        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuGroup, {
65511          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItemsChoice, {
65512            choices: selectOptions,
65513            value: selectedValue,
65514            onSelect: onSelectVariation
65515          })
65516        })
65517      })
65518    });
65519  }
65520  function VariationsToggleGroupControl({
65521    className,
65522    onSelectVariation,
65523    selectedValue,
65524    variations
65525  }) {
65526    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
65527      className: className,
65528      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControl, {
65529        label: (0,external_wp_i18n_namespaceObject.__)('Transform to variation'),
65530        value: selectedValue,
65531        hideLabelFromVision: true,
65532        onChange: onSelectVariation,
65533        __next40pxDefaultSize: true,
65534        __nextHasNoMarginBottom: true,
65535        children: variations.map(variation => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControlOptionIcon, {
65536          icon: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_icon, {
65537            icon: variation.icon,
65538            showColors: true
65539          }),
65540          value: variation.name,
65541          label: selectedValue === variation.name ? variation.title : (0,external_wp_i18n_namespaceObject.sprintf)(/* translators: %s: Block or block variation name. */
65542          (0,external_wp_i18n_namespaceObject.__)('Transform to %s'), variation.title)
65543        }, variation.name))
65544      })
65545    });
65546  }
65547  function __experimentalBlockVariationTransforms({
65548    blockClientId
65549  }) {
65550    const {
65551      updateBlockAttributes
65552    } = (0,external_wp_data_namespaceObject.useDispatch)(store);
65553    const {
65554      activeBlockVariation,
65555      variations,
65556      isContentOnly
65557    } = (0,external_wp_data_namespaceObject.useSelect)(select => {
65558      const {
65559        getActiveBlockVariation,
65560        getBlockVariations
65561      } = select(external_wp_blocks_namespaceObject.store);
65562      const {
65563        getBlockName,
65564        getBlockAttributes,
65565        getBlockEditingMode
65566      } = select(store);
65567      const name = blockClientId && getBlockName(blockClientId);
65568      const {
65569        hasContentRoleAttribute
65570      } = unlock(select(external_wp_blocks_namespaceObject.store));
65571      const isContentBlock = hasContentRoleAttribute(name);
65572      return {
65573        activeBlockVariation: getActiveBlockVariation(name, getBlockAttributes(blockClientId)),
65574        variations: name && getBlockVariations(name, 'transform'),
65575        isContentOnly: getBlockEditingMode(blockClientId) === 'contentOnly' && !isContentBlock
65576      };
65577    }, [blockClientId]);
65578    const selectedValue = activeBlockVariation?.name;
65579  
65580    // Check if each variation has a unique icon.
65581    const hasUniqueIcons = (0,external_wp_element_namespaceObject.useMemo)(() => {
65582      const variationIcons = new Set();
65583      if (!variations) {
65584        return false;
65585      }
65586      variations.forEach(variation => {
65587        if (variation.icon) {
65588          variationIcons.add(variation.icon?.src || variation.icon);
65589        }
65590      });
65591      return variationIcons.size === variations.length;
65592    }, [variations]);
65593    const onSelectVariation = variationName => {
65594      updateBlockAttributes(blockClientId, {
65595        ...variations.find(({
65596          name
65597        }) => name === variationName).attributes
65598      });
65599    };
65600    if (!variations?.length || isContentOnly) {
65601      return null;
65602    }
65603    const baseClass = 'block-editor-block-variation-transforms';
65604  
65605    // Show buttons if there are more than 5 variations because the ToggleGroupControl does not wrap
65606    const showButtons = variations.length > 5;
65607    const ButtonComponent = showButtons ? VariationsButtons : VariationsToggleGroupControl;
65608    const Component = hasUniqueIcons ? ButtonComponent : VariationsDropdown;
65609    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Component, {
65610      className: baseClass,
65611      onSelectVariation: onSelectVariation,
65612      selectedValue: selectedValue,
65613      variations: variations
65614    });
65615  }
65616  /* harmony default export */ const block_variation_transforms = (__experimentalBlockVariationTransforms);
65617  
65618  ;// ./node_modules/@wordpress/block-editor/build-module/components/color-palette/with-color-context.js
65619  /**
65620   * WordPress dependencies
65621   */
65622  
65623  
65624  /**
65625   * Internal dependencies
65626   */
65627  
65628  
65629  /* harmony default export */ const with_color_context = ((0,external_wp_compose_namespaceObject.createHigherOrderComponent)(WrappedComponent => {
65630    return props => {
65631      // Get the default colors, theme colors, and custom colors
65632      const [defaultColors, themeColors, customColors, enableCustomColors, enableDefaultColors] = use_settings_useSettings('color.palette.default', 'color.palette.theme', 'color.palette.custom', 'color.custom', 'color.defaultPalette');
65633      const _colors = enableDefaultColors ? [...(themeColors || []), ...(defaultColors || []), ...(customColors || [])] : [...(themeColors || []), ...(customColors || [])];
65634      const {
65635        colors = _colors,
65636        disableCustomColors = !enableCustomColors
65637      } = props;
65638      const hasColorsToChoose = colors && colors.length > 0 || !disableCustomColors;
65639      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(WrappedComponent, {
65640        ...props,
65641        colors,
65642        disableCustomColors,
65643        hasColorsToChoose
65644      });
65645    };
65646  }, 'withColorContext'));
65647  
65648  ;// ./node_modules/@wordpress/block-editor/build-module/components/color-palette/index.js
65649  /**
65650   * WordPress dependencies
65651   */
65652  
65653  
65654  /**
65655   * Internal dependencies
65656   */
65657  
65658  /* harmony default export */ const color_palette = (with_color_context(external_wp_components_namespaceObject.ColorPalette));
65659  
65660  ;// ./node_modules/@wordpress/block-editor/build-module/components/color-palette/control.js
65661  /**
65662   * Internal dependencies
65663   */
65664  
65665  
65666  function ColorPaletteControl({
65667    onChange,
65668    value,
65669    ...otherProps
65670  }) {
65671    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(control, {
65672      ...otherProps,
65673      onColorChange: onChange,
65674      colorValue: value,
65675      gradients: [],
65676      disableCustomGradients: true
65677    });
65678  }
65679  
65680  ;// external ["wp","date"]
65681  const external_wp_date_namespaceObject = window["wp"]["date"];
65682  ;// ./node_modules/@wordpress/block-editor/build-module/components/date-format-picker/index.js
65683  /**
65684   * WordPress dependencies
65685   */
65686  
65687  
65688  
65689  
65690  
65691  // So that we illustrate the different formats in the dropdown properly, show a date that is
65692  // somewhat recent, has a day greater than 12, and a month with more than three letters.
65693  
65694  const exampleDate = new Date();
65695  exampleDate.setDate(20);
65696  exampleDate.setMonth(exampleDate.getMonth() - 3);
65697  if (exampleDate.getMonth() === 4) {
65698    // May has three letters, so use March.
65699    exampleDate.setMonth(3);
65700  }
65701  
65702  /**
65703   * The `DateFormatPicker` component renders controls that let the user choose a
65704   * _date format_. That is, how they want their dates to be formatted.
65705   *
65706   * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/date-format-picker/README.md
65707   *
65708   * @param {Object}      props
65709   * @param {string|null} props.format        The selected date format. If `null`, _Default_ is selected.
65710   * @param {string}      props.defaultFormat The date format that will be used if the user selects 'Default'.
65711   * @param {Function}    props.onChange      Called when a selection is made. If `null`, _Default_ is selected.
65712   */
65713  function DateFormatPicker({
65714    format,
65715    defaultFormat,
65716    onChange
65717  }) {
65718    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalVStack, {
65719      as: "fieldset",
65720      spacing: 4,
65721      className: "block-editor-date-format-picker",
65722      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.VisuallyHidden, {
65723        as: "legend",
65724        children: (0,external_wp_i18n_namespaceObject.__)('Date format')
65725      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToggleControl, {
65726        __nextHasNoMarginBottom: true,
65727        label: (0,external_wp_i18n_namespaceObject.__)('Default format'),
65728        help: `${(0,external_wp_i18n_namespaceObject.__)('Example:')}  ${(0,external_wp_date_namespaceObject.dateI18n)(defaultFormat, exampleDate)}`,
65729        checked: !format,
65730        onChange: checked => onChange(checked ? null : defaultFormat)
65731      }), format && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(NonDefaultControls, {
65732        format: format,
65733        onChange: onChange
65734      })]
65735    });
65736  }
65737  function NonDefaultControls({
65738    format,
65739    onChange
65740  }) {
65741    var _suggestedOptions$fin;
65742    // Suggest a short format, medium format, long format, and a standardised
65743    // (YYYY-MM-DD) format. The short, medium, and long formats are localised as
65744    // different languages have different ways of writing these. For example, 'F
65745    // j, Y' (April 20, 2022) in American English (en_US) is 'j. F Y' (20. April
65746    // 2022) in German (de). The resultant array is de-duplicated as some
65747    // languages will use the same format string for short, medium, and long
65748    // formats.
65749    const suggestedFormats = [...new Set([/* translators: See https://www.php.net/manual/datetime.format.php */
65750    'Y-m-d', /* translators: See https://www.php.net/manual/datetime.format.php */
65751    (0,external_wp_i18n_namespaceObject._x)('n/j/Y', 'short date format'), /* translators: See https://www.php.net/manual/datetime.format.php */
65752    (0,external_wp_i18n_namespaceObject._x)('n/j/Y g:i A', 'short date format with time'), /* translators: See https://www.php.net/manual/datetime.format.php */
65753    (0,external_wp_i18n_namespaceObject._x)('M j, Y', 'medium date format'), /* translators: See https://www.php.net/manual/datetime.format.php */
65754    (0,external_wp_i18n_namespaceObject._x)('M j, Y g:i A', 'medium date format with time'), /* translators: See https://www.php.net/manual/datetime.format.php */
65755    (0,external_wp_i18n_namespaceObject._x)('F j, Y', 'long date format'), /* translators: See https://www.php.net/manual/datetime.format.php */
65756    (0,external_wp_i18n_namespaceObject._x)('M j', 'short date format without the year')])];
65757    const suggestedOptions = [...suggestedFormats.map((suggestedFormat, index) => ({
65758      key: `suggested-$index}`,
65759      name: (0,external_wp_date_namespaceObject.dateI18n)(suggestedFormat, exampleDate),
65760      format: suggestedFormat
65761    })), {
65762      key: 'human-diff',
65763      name: (0,external_wp_date_namespaceObject.humanTimeDiff)(exampleDate),
65764      format: 'human-diff'
65765    }];
65766    const customOption = {
65767      key: 'custom',
65768      name: (0,external_wp_i18n_namespaceObject.__)('Custom'),
65769      className: 'block-editor-date-format-picker__custom-format-select-control__custom-option',
65770      hint: (0,external_wp_i18n_namespaceObject.__)('Enter your own date format')
65771    };
65772    const [isCustom, setIsCustom] = (0,external_wp_element_namespaceObject.useState)(() => !!format && !suggestedOptions.some(option => option.format === format));
65773    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalVStack, {
65774      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.CustomSelectControl, {
65775        __next40pxDefaultSize: true,
65776        label: (0,external_wp_i18n_namespaceObject.__)('Choose a format'),
65777        options: [...suggestedOptions, customOption],
65778        value: isCustom ? customOption : (_suggestedOptions$fin = suggestedOptions.find(option => option.format === format)) !== null && _suggestedOptions$fin !== void 0 ? _suggestedOptions$fin : customOption,
65779        onChange: ({
65780          selectedItem
65781        }) => {
65782          if (selectedItem === customOption) {
65783            setIsCustom(true);
65784          } else {
65785            setIsCustom(false);
65786            onChange(selectedItem.format);
65787          }
65788        }
65789      }), isCustom && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.TextControl, {
65790        __next40pxDefaultSize: true,
65791        __nextHasNoMarginBottom: true,
65792        label: (0,external_wp_i18n_namespaceObject.__)('Custom format'),
65793        hideLabelFromVision: true,
65794        help: (0,external_wp_element_namespaceObject.createInterpolateElement)((0,external_wp_i18n_namespaceObject.__)('Enter a date or time <Link>format string</Link>.'), {
65795          Link: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ExternalLink, {
65796            href: (0,external_wp_i18n_namespaceObject.__)('https://wordpress.org/documentation/article/customize-date-and-time-format/')
65797          })
65798        }),
65799        value: format,
65800        onChange: value => onChange(value)
65801      })]
65802    });
65803  }
65804  
65805  ;// ./node_modules/@wordpress/block-editor/build-module/components/colors-gradients/dropdown.js
65806  /**
65807   * External dependencies
65808   */
65809  
65810  
65811  /**
65812   * WordPress dependencies
65813   */
65814  
65815  
65816  
65817  
65818  /**
65819   * Internal dependencies
65820   */
65821  
65822  
65823  /**
65824   * Internal dependencies
65825   */
65826  
65827  
65828  // When the `ColorGradientSettingsDropdown` controls are being rendered to a
65829  // `ToolsPanel` they must be wrapped in a `ToolsPanelItem`.
65830  
65831  const WithToolsPanelItem = ({
65832    setting,
65833    children,
65834    panelId,
65835    ...props
65836  }) => {
65837    const clearValue = () => {
65838      if (setting.colorValue) {
65839        setting.onColorChange();
65840      } else if (setting.gradientValue) {
65841        setting.onGradientChange();
65842      }
65843    };
65844    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanelItem, {
65845      hasValue: () => {
65846        return !!setting.colorValue || !!setting.gradientValue;
65847      },
65848      label: setting.label,
65849      onDeselect: clearValue,
65850      isShownByDefault: setting.isShownByDefault !== undefined ? setting.isShownByDefault : true,
65851      ...props,
65852      className: "block-editor-tools-panel-color-gradient-settings__item",
65853      panelId: panelId
65854      // Pass resetAllFilter if supplied due to rendering via SlotFill
65855      // into parent ToolsPanel.
65856      ,
65857      resetAllFilter: setting.resetAllFilter,
65858      children: children
65859    });
65860  };
65861  const dropdown_LabeledColorIndicator = ({
65862    colorValue,
65863    label
65864  }) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalHStack, {
65865    justify: "flex-start",
65866    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ColorIndicator, {
65867      className: "block-editor-panel-color-gradient-settings__color-indicator",
65868      colorValue: colorValue
65869    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FlexItem, {
65870      className: "block-editor-panel-color-gradient-settings__color-name",
65871      title: label,
65872      children: label
65873    })]
65874  });
65875  
65876  // Renders a color dropdown's toggle as an `Item` if it is within an `ItemGroup`
65877  // or as a `Button` if it isn't e.g. the controls are being rendered in
65878  // a `ToolsPanel`.
65879  const dropdown_renderToggle = settings => ({
65880    onToggle,
65881    isOpen
65882  }) => {
65883    const {
65884      clearable,
65885      colorValue,
65886      gradientValue,
65887      onColorChange,
65888      onGradientChange,
65889      label
65890    } = settings;
65891    const colorButtonRef = (0,external_wp_element_namespaceObject.useRef)(undefined);
65892    const toggleProps = {
65893      onClick: onToggle,
65894      className: dist_clsx('block-editor-panel-color-gradient-settings__dropdown', {
65895        'is-open': isOpen
65896      }),
65897      'aria-expanded': isOpen,
65898      ref: colorButtonRef
65899    };
65900    const clearValue = () => {
65901      if (colorValue) {
65902        onColorChange();
65903      } else if (gradientValue) {
65904        onGradientChange();
65905      }
65906    };
65907    const value = colorValue !== null && colorValue !== void 0 ? colorValue : gradientValue;
65908    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
65909      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
65910        __next40pxDefaultSize: true,
65911        ...toggleProps,
65912        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(dropdown_LabeledColorIndicator, {
65913          colorValue: value,
65914          label: label
65915        })
65916      }), clearable && value && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
65917        __next40pxDefaultSize: true,
65918        label: (0,external_wp_i18n_namespaceObject.__)('Reset'),
65919        className: "block-editor-panel-color-gradient-settings__reset",
65920        size: "small",
65921        icon: library_reset,
65922        onClick: () => {
65923          clearValue();
65924          if (isOpen) {
65925            onToggle();
65926          }
65927          // Return focus to parent button
65928          colorButtonRef.current?.focus();
65929        }
65930      })]
65931    });
65932  };
65933  
65934  // Renders a collection of color controls as dropdowns. Depending upon the
65935  // context in which these dropdowns are being rendered, they may be wrapped
65936  // in an `ItemGroup` with each dropdown's toggle as an `Item`, or alternatively,
65937  // the may be individually wrapped in a `ToolsPanelItem` with the toggle as
65938  // a regular `Button`.
65939  //
65940  // For more context see: https://github.com/WordPress/gutenberg/pull/40084
65941  function ColorGradientSettingsDropdown({
65942    colors,
65943    disableCustomColors,
65944    disableCustomGradients,
65945    enableAlpha,
65946    gradients,
65947    settings,
65948    __experimentalIsRenderedInSidebar,
65949    ...props
65950  }) {
65951    let popoverProps;
65952    if (__experimentalIsRenderedInSidebar) {
65953      popoverProps = {
65954        placement: 'left-start',
65955        offset: 36,
65956        shift: true
65957      };
65958    }
65959    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_ReactJSXRuntime_namespaceObject.Fragment, {
65960      children: settings.map((setting, index) => {
65961        const controlProps = {
65962          clearable: false,
65963          colorValue: setting.colorValue,
65964          colors,
65965          disableCustomColors,
65966          disableCustomGradients,
65967          enableAlpha,
65968          gradientValue: setting.gradientValue,
65969          gradients,
65970          label: setting.label,
65971          onColorChange: setting.onColorChange,
65972          onGradientChange: setting.onGradientChange,
65973          showTitle: false,
65974          __experimentalIsRenderedInSidebar,
65975          ...setting
65976        };
65977        const toggleSettings = {
65978          clearable: setting.clearable,
65979          label: setting.label,
65980          colorValue: setting.colorValue,
65981          gradientValue: setting.gradientValue,
65982          onColorChange: setting.onColorChange,
65983          onGradientChange: setting.onGradientChange
65984        };
65985        return setting &&
65986        /*#__PURE__*/
65987        // If not in an `ItemGroup` wrap the dropdown in a
65988        // `ToolsPanelItem`
65989        (0,external_ReactJSXRuntime_namespaceObject.jsx)(WithToolsPanelItem, {
65990          setting: setting,
65991          ...props,
65992          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Dropdown, {
65993            popoverProps: popoverProps,
65994            className: "block-editor-tools-panel-color-gradient-settings__dropdown",
65995            renderToggle: dropdown_renderToggle(toggleSettings),
65996            renderContent: () => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalDropdownContentWrapper, {
65997              paddingSize: "none",
65998              children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
65999                className: "block-editor-panel-color-gradient-settings__dropdown-content",
66000                children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(control, {
66001                  ...controlProps
66002                })
66003              })
66004            })
66005          })
66006        }, index);
66007      })
66008    });
66009  }
66010  
66011  ;// ./node_modules/@wordpress/block-editor/build-module/components/colors-gradients/panel-color-gradient-settings.js
66012  /**
66013   * External dependencies
66014   */
66015  
66016  
66017  /**
66018   * WordPress dependencies
66019   */
66020  
66021  
66022  
66023  
66024  /**
66025   * Internal dependencies
66026   */
66027  
66028  
66029  
66030  const panel_color_gradient_settings_colorsAndGradientKeys = ['colors', 'disableCustomColors', 'gradients', 'disableCustomGradients'];
66031  const PanelColorGradientSettingsInner = ({
66032    className,
66033    colors,
66034    gradients,
66035    disableCustomColors,
66036    disableCustomGradients,
66037    children,
66038    settings,
66039    title,
66040    showTitle = true,
66041    __experimentalIsRenderedInSidebar,
66042    enableAlpha
66043  }) => {
66044    const panelId = (0,external_wp_compose_namespaceObject.useInstanceId)(PanelColorGradientSettingsInner);
66045    const {
66046      batch
66047    } = (0,external_wp_data_namespaceObject.useRegistry)();
66048    if ((!colors || colors.length === 0) && (!gradients || gradients.length === 0) && disableCustomColors && disableCustomGradients && settings?.every(setting => (!setting.colors || setting.colors.length === 0) && (!setting.gradients || setting.gradients.length === 0) && (setting.disableCustomColors === undefined || setting.disableCustomColors) && (setting.disableCustomGradients === undefined || setting.disableCustomGradients))) {
66049      return null;
66050    }
66051    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalToolsPanel, {
66052      className: dist_clsx('block-editor-panel-color-gradient-settings', className),
66053      label: showTitle ? title : undefined,
66054      resetAll: () => {
66055        batch(() => {
66056          settings.forEach(({
66057            colorValue,
66058            gradientValue,
66059            onColorChange,
66060            onGradientChange
66061          }) => {
66062            if (colorValue) {
66063              onColorChange();
66064            } else if (gradientValue) {
66065              onGradientChange();
66066            }
66067          });
66068        });
66069      },
66070      panelId: panelId,
66071      __experimentalFirstVisibleItemClass: "first",
66072      __experimentalLastVisibleItemClass: "last",
66073      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ColorGradientSettingsDropdown, {
66074        settings: settings,
66075        panelId: panelId,
66076        colors,
66077        gradients,
66078        disableCustomColors,
66079        disableCustomGradients,
66080        __experimentalIsRenderedInSidebar,
66081        enableAlpha
66082      }), !!children && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
66083        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalSpacer, {
66084          marginY: 4
66085        }), " ", children]
66086      })]
66087    });
66088  };
66089  const PanelColorGradientSettingsSelect = props => {
66090    const colorGradientSettings = useMultipleOriginColorsAndGradients();
66091    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PanelColorGradientSettingsInner, {
66092      ...colorGradientSettings,
66093      ...props
66094    });
66095  };
66096  const PanelColorGradientSettings = props => {
66097    if (panel_color_gradient_settings_colorsAndGradientKeys.every(key => props.hasOwnProperty(key))) {
66098      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PanelColorGradientSettingsInner, {
66099        ...props
66100      });
66101    }
66102    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PanelColorGradientSettingsSelect, {
66103      ...props
66104    });
66105  };
66106  /* harmony default export */ const panel_color_gradient_settings = (PanelColorGradientSettings);
66107  
66108  ;// ./node_modules/@wordpress/icons/build-module/library/aspect-ratio.js
66109  /**
66110   * WordPress dependencies
66111   */
66112  
66113  
66114  const aspectRatio = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
66115    xmlns: "http://www.w3.org/2000/svg",
66116    viewBox: "0 0 24 24",
66117    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
66118      d: "M18.5 5.5h-13c-1.1 0-2 .9-2 2v9c0 1.1.9 2 2 2h13c1.1 0 2-.9 2-2v-9c0-1.1-.9-2-2-2zm.5 11c0 .3-.2.5-.5.5h-13c-.3 0-.5-.2-.5-.5v-9c0-.3.2-.5.5-.5h13c.3 0 .5.2.5.5v9zM6.5 12H8v-2h2V8.5H6.5V12zm9.5 2h-2v1.5h3.5V12H16v2z"
66119    })
66120  });
66121  /* harmony default export */ const aspect_ratio = (aspectRatio);
66122  
66123  ;// ./node_modules/@wordpress/block-editor/build-module/components/image-editor/constants.js
66124  const MIN_ZOOM = 100;
66125  const MAX_ZOOM = 300;
66126  const constants_POPOVER_PROPS = {
66127    placement: 'bottom-start'
66128  };
66129  
66130  ;// ./node_modules/@wordpress/block-editor/build-module/components/image-editor/use-save-image.js
66131  /**
66132   * WordPress dependencies
66133   */
66134  // Disable Reason: Needs to be refactored.
66135  // eslint-disable-next-line no-restricted-imports
66136  
66137  
66138  
66139  
66140  
66141  
66142  const messages = {
66143    crop: (0,external_wp_i18n_namespaceObject.__)('Image cropped.'),
66144    rotate: (0,external_wp_i18n_namespaceObject.__)('Image rotated.'),
66145    cropAndRotate: (0,external_wp_i18n_namespaceObject.__)('Image cropped and rotated.')
66146  };
66147  function useSaveImage({
66148    crop,
66149    rotation,
66150    url,
66151    id,
66152    onSaveImage,
66153    onFinishEditing
66154  }) {
66155    const {
66156      createErrorNotice,
66157      createSuccessNotice
66158    } = (0,external_wp_data_namespaceObject.useDispatch)(external_wp_notices_namespaceObject.store);
66159    const [isInProgress, setIsInProgress] = (0,external_wp_element_namespaceObject.useState)(false);
66160    const cancel = (0,external_wp_element_namespaceObject.useCallback)(() => {
66161      setIsInProgress(false);
66162      onFinishEditing();
66163    }, [onFinishEditing]);
66164    const apply = (0,external_wp_element_namespaceObject.useCallback)(() => {
66165      setIsInProgress(true);
66166      const modifiers = [];
66167      if (rotation > 0) {
66168        modifiers.push({
66169          type: 'rotate',
66170          args: {
66171            angle: rotation
66172          }
66173        });
66174      }
66175  
66176      // The crop script may return some very small, sub-pixel values when the image was not cropped.
66177      // Crop only when the new size has changed by more than 0.1%.
66178      if (crop.width < 99.9 || crop.height < 99.9) {
66179        modifiers.push({
66180          type: 'crop',
66181          args: {
66182            left: crop.x,
66183            top: crop.y,
66184            width: crop.width,
66185            height: crop.height
66186          }
66187        });
66188      }
66189      if (modifiers.length === 0) {
66190        // No changes to apply.
66191        setIsInProgress(false);
66192        onFinishEditing();
66193        return;
66194      }
66195      const modifierType = modifiers.length === 1 ? modifiers[0].type : 'cropAndRotate';
66196      external_wp_apiFetch_default()({
66197        path: `/wp/v2/media/$id}/edit`,
66198        method: 'POST',
66199        data: {
66200          src: url,
66201          modifiers
66202        }
66203      }).then(response => {
66204        onSaveImage({
66205          id: response.id,
66206          url: response.source_url
66207        });
66208        createSuccessNotice(messages[modifierType], {
66209          type: 'snackbar',
66210          actions: [{
66211            label: (0,external_wp_i18n_namespaceObject.__)('Undo'),
66212            onClick: () => {
66213              onSaveImage({
66214                id,
66215                url
66216              });
66217            }
66218          }]
66219        });
66220      }).catch(error => {
66221        createErrorNotice((0,external_wp_i18n_namespaceObject.sprintf)(/* translators: %s: Error message. */
66222        (0,external_wp_i18n_namespaceObject.__)('Could not edit image. %s'), (0,external_wp_dom_namespaceObject.__unstableStripHTML)(error.message)), {
66223          id: 'image-editing-error',
66224          type: 'snackbar'
66225        });
66226      }).finally(() => {
66227        setIsInProgress(false);
66228        onFinishEditing();
66229      });
66230    }, [crop, rotation, id, url, onSaveImage, createErrorNotice, createSuccessNotice, onFinishEditing]);
66231    return (0,external_wp_element_namespaceObject.useMemo)(() => ({
66232      isInProgress,
66233      apply,
66234      cancel
66235    }), [isInProgress, apply, cancel]);
66236  }
66237  
66238  ;// ./node_modules/@wordpress/block-editor/build-module/components/image-editor/use-transform-image.js
66239  /* wp:polyfill */
66240  /**
66241   * WordPress dependencies
66242   */
66243  
66244  
66245  function useTransformImage({
66246    url,
66247    naturalWidth,
66248    naturalHeight
66249  }) {
66250    const [editedUrl, setEditedUrl] = (0,external_wp_element_namespaceObject.useState)();
66251    const [crop, setCrop] = (0,external_wp_element_namespaceObject.useState)();
66252    const [position, setPosition] = (0,external_wp_element_namespaceObject.useState)({
66253      x: 0,
66254      y: 0
66255    });
66256    const [zoom, setZoom] = (0,external_wp_element_namespaceObject.useState)(100);
66257    const [rotation, setRotation] = (0,external_wp_element_namespaceObject.useState)(0);
66258    const defaultAspect = naturalWidth / naturalHeight;
66259    const [aspect, setAspect] = (0,external_wp_element_namespaceObject.useState)(defaultAspect);
66260    const rotateClockwise = (0,external_wp_element_namespaceObject.useCallback)(() => {
66261      const angle = (rotation + 90) % 360;
66262      let naturalAspectRatio = defaultAspect;
66263      if (rotation % 180 === 90) {
66264        naturalAspectRatio = 1 / defaultAspect;
66265      }
66266      if (angle === 0) {
66267        setEditedUrl();
66268        setRotation(angle);
66269        setAspect(defaultAspect);
66270        setPosition(prevPosition => ({
66271          x: -(prevPosition.y * naturalAspectRatio),
66272          y: prevPosition.x * naturalAspectRatio
66273        }));
66274        return;
66275      }
66276      function editImage(event) {
66277        const canvas = document.createElement('canvas');
66278        let translateX = 0;
66279        let translateY = 0;
66280        if (angle % 180) {
66281          canvas.width = event.target.height;
66282          canvas.height = event.target.width;
66283        } else {
66284          canvas.width = event.target.width;
66285          canvas.height = event.target.height;
66286        }
66287        if (angle === 90 || angle === 180) {
66288          translateX = canvas.width;
66289        }
66290        if (angle === 270 || angle === 180) {
66291          translateY = canvas.height;
66292        }
66293        const context = canvas.getContext('2d');
66294        context.translate(translateX, translateY);
66295        context.rotate(angle * Math.PI / 180);
66296        context.drawImage(event.target, 0, 0);
66297        canvas.toBlob(blob => {
66298          setEditedUrl(URL.createObjectURL(blob));
66299          setRotation(angle);
66300          setAspect(canvas.width / canvas.height);
66301          setPosition(prevPosition => ({
66302            x: -(prevPosition.y * naturalAspectRatio),
66303            y: prevPosition.x * naturalAspectRatio
66304          }));
66305        });
66306      }
66307      const el = new window.Image();
66308      el.src = url;
66309      el.onload = editImage;
66310      const imgCrossOrigin = (0,external_wp_hooks_namespaceObject.applyFilters)('media.crossOrigin', undefined, url);
66311      if (typeof imgCrossOrigin === 'string') {
66312        el.crossOrigin = imgCrossOrigin;
66313      }
66314    }, [rotation, defaultAspect, url]);
66315    return (0,external_wp_element_namespaceObject.useMemo)(() => ({
66316      editedUrl,
66317      setEditedUrl,
66318      crop,
66319      setCrop,
66320      position,
66321      setPosition,
66322      zoom,
66323      setZoom,
66324      rotation,
66325      setRotation,
66326      rotateClockwise,
66327      aspect,
66328      setAspect,
66329      defaultAspect
66330    }), [editedUrl, crop, position, zoom, rotation, rotateClockwise, aspect, defaultAspect]);
66331  }
66332  
66333  ;// ./node_modules/@wordpress/block-editor/build-module/components/image-editor/context.js
66334  /**
66335   * WordPress dependencies
66336   */
66337  
66338  
66339  /**
66340   * Internal dependencies
66341   */
66342  
66343  
66344  
66345  const ImageEditingContext = (0,external_wp_element_namespaceObject.createContext)({});
66346  const useImageEditingContext = () => (0,external_wp_element_namespaceObject.useContext)(ImageEditingContext);
66347  function ImageEditingProvider({
66348    id,
66349    url,
66350    naturalWidth,
66351    naturalHeight,
66352    onFinishEditing,
66353    onSaveImage,
66354    children
66355  }) {
66356    const transformImage = useTransformImage({
66357      url,
66358      naturalWidth,
66359      naturalHeight
66360    });
66361    const saveImage = useSaveImage({
66362      id,
66363      url,
66364      onSaveImage,
66365      onFinishEditing,
66366      ...transformImage
66367    });
66368    const providerValue = (0,external_wp_element_namespaceObject.useMemo)(() => ({
66369      ...transformImage,
66370      ...saveImage
66371    }), [transformImage, saveImage]);
66372    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ImageEditingContext.Provider, {
66373      value: providerValue,
66374      children: children
66375    });
66376  }
66377  
66378  ;// ./node_modules/@wordpress/block-editor/build-module/components/image-editor/aspect-ratio-dropdown.js
66379  /**
66380   * WordPress dependencies
66381   */
66382  
66383  
66384  
66385  
66386  /**
66387   * Internal dependencies
66388   */
66389  
66390  
66391  
66392  
66393  function AspectRatioGroup({
66394    aspectRatios,
66395    isDisabled,
66396    label,
66397    onClick,
66398    value
66399  }) {
66400    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuGroup, {
66401      label: label,
66402      children: aspectRatios.map(({
66403        name,
66404        slug,
66405        ratio
66406      }) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, {
66407        disabled: isDisabled,
66408        onClick: () => {
66409          onClick(ratio);
66410        },
66411        role: "menuitemradio",
66412        isSelected: ratio === value,
66413        icon: ratio === value ? library_check : undefined,
66414        children: name
66415      }, slug))
66416    });
66417  }
66418  function ratioToNumber(str) {
66419    // TODO: support two-value aspect ratio?
66420    // https://css-tricks.com/almanac/properties/a/aspect-ratio/#aa-it-can-take-two-values
66421    const [a, b, ...rest] = str.split('/').map(Number);
66422    if (a <= 0 || b <= 0 || Number.isNaN(a) || Number.isNaN(b) || rest.length) {
66423      return NaN;
66424    }
66425    return b ? a / b : a;
66426  }
66427  function presetRatioAsNumber({
66428    ratio,
66429    ...rest
66430  }) {
66431    return {
66432      ratio: ratioToNumber(ratio),
66433      ...rest
66434    };
66435  }
66436  function AspectRatioDropdown({
66437    toggleProps
66438  }) {
66439    const {
66440      isInProgress,
66441      aspect,
66442      setAspect,
66443      defaultAspect
66444    } = useImageEditingContext();
66445    const [defaultRatios, themeRatios, showDefaultRatios] = use_settings_useSettings('dimensions.aspectRatios.default', 'dimensions.aspectRatios.theme', 'dimensions.defaultAspectRatios');
66446    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.DropdownMenu, {
66447      icon: aspect_ratio,
66448      label: (0,external_wp_i18n_namespaceObject.__)('Aspect Ratio'),
66449      popoverProps: constants_POPOVER_PROPS,
66450      toggleProps: toggleProps,
66451      children: ({
66452        onClose
66453      }) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
66454        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(AspectRatioGroup, {
66455          isDisabled: isInProgress,
66456          onClick: newAspect => {
66457            setAspect(newAspect);
66458            onClose();
66459          },
66460          value: aspect,
66461          aspectRatios: [
66462          // All ratios should be mirrored in AspectRatioTool in @wordpress/block-editor.
66463          {
66464            slug: 'original',
66465            name: (0,external_wp_i18n_namespaceObject.__)('Original'),
66466            ratio: defaultAspect
66467          }, ...(showDefaultRatios ? defaultRatios.map(presetRatioAsNumber).filter(({
66468            ratio
66469          }) => ratio === 1) : [])]
66470        }), themeRatios?.length > 0 && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(AspectRatioGroup, {
66471          label: (0,external_wp_i18n_namespaceObject.__)('Theme'),
66472          isDisabled: isInProgress,
66473          onClick: newAspect => {
66474            setAspect(newAspect);
66475            onClose();
66476          },
66477          value: aspect,
66478          aspectRatios: themeRatios
66479        }), showDefaultRatios && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(AspectRatioGroup, {
66480          label: (0,external_wp_i18n_namespaceObject.__)('Landscape'),
66481          isDisabled: isInProgress,
66482          onClick: newAspect => {
66483            setAspect(newAspect);
66484            onClose();
66485          },
66486          value: aspect,
66487          aspectRatios: defaultRatios.map(presetRatioAsNumber).filter(({
66488            ratio
66489          }) => ratio > 1)
66490        }), showDefaultRatios && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(AspectRatioGroup, {
66491          label: (0,external_wp_i18n_namespaceObject.__)('Portrait'),
66492          isDisabled: isInProgress,
66493          onClick: newAspect => {
66494            setAspect(newAspect);
66495            onClose();
66496          },
66497          value: aspect,
66498          aspectRatios: defaultRatios.map(presetRatioAsNumber).filter(({
66499            ratio
66500          }) => ratio < 1)
66501        })]
66502      })
66503    });
66504  }
66505  
66506  ;// ./node_modules/tslib/tslib.es6.mjs
66507  /******************************************************************************
66508  Copyright (c) Microsoft Corporation.
66509  
66510  Permission to use, copy, modify, and/or distribute this software for any
66511  purpose with or without fee is hereby granted.
66512  
66513  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
66514  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
66515  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
66516  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
66517  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
66518  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
66519  PERFORMANCE OF THIS SOFTWARE.
66520  ***************************************************************************** */
66521  /* global Reflect, Promise, SuppressedError, Symbol, Iterator */
66522  
66523  var extendStatics = function(d, b) {
66524    extendStatics = Object.setPrototypeOf ||
66525        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
66526        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
66527    return extendStatics(d, b);
66528  };
66529  
66530  function __extends(d, b) {
66531    if (typeof b !== "function" && b !== null)
66532        throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
66533    extendStatics(d, b);
66534    function __() { this.constructor = d; }
66535    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
66536  }
66537  
66538  var __assign = function() {
66539    __assign = Object.assign || function __assign(t) {
66540        for (var s, i = 1, n = arguments.length; i < n; i++) {
66541            s = arguments[i];
66542            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
66543        }
66544        return t;
66545    }
66546    return __assign.apply(this, arguments);
66547  }
66548  
66549  function __rest(s, e) {
66550    var t = {};
66551    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
66552        t[p] = s[p];
66553    if (s != null && typeof Object.getOwnPropertySymbols === "function")
66554        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
66555            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
66556                t[p[i]] = s[p[i]];
66557        }
66558    return t;
66559  }
66560  
66561  function __decorate(decorators, target, key, desc) {
66562    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
66563    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
66564    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
66565    return c > 3 && r && Object.defineProperty(target, key, r), r;
66566  }
66567  
66568  function __param(paramIndex, decorator) {
66569    return function (target, key) { decorator(target, key, paramIndex); }
66570  }
66571  
66572  function __esDecorate(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
66573    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
66574    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
66575    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
66576    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
66577    var _, done = false;
66578    for (var i = decorators.length - 1; i >= 0; i--) {
66579        var context = {};
66580        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
66581        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
66582        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
66583        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
66584        if (kind === "accessor") {
66585            if (result === void 0) continue;
66586            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
66587            if (_ = accept(result.get)) descriptor.get = _;
66588            if (_ = accept(result.set)) descriptor.set = _;
66589            if (_ = accept(result.init)) initializers.unshift(_);
66590        }
66591        else if (_ = accept(result)) {
66592            if (kind === "field") initializers.unshift(_);
66593            else descriptor[key] = _;
66594        }
66595    }
66596    if (target) Object.defineProperty(target, contextIn.name, descriptor);
66597    done = true;
66598  };
66599  
66600  function __runInitializers(thisArg, initializers, value) {
66601    var useValue = arguments.length > 2;
66602    for (var i = 0; i < initializers.length; i++) {
66603        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
66604    }
66605    return useValue ? value : void 0;
66606  };
66607  
66608  function __propKey(x) {
66609    return typeof x === "symbol" ? x : "".concat(x);
66610  };
66611  
66612  function __setFunctionName(f, name, prefix) {
66613    if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
66614    return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
66615  };
66616  
66617  function __metadata(metadataKey, metadataValue) {
66618    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
66619  }
66620  
66621  function __awaiter(thisArg, _arguments, P, generator) {
66622    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
66623    return new (P || (P = Promise))(function (resolve, reject) {
66624        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
66625        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
66626        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
66627        step((generator = generator.apply(thisArg, _arguments || [])).next());
66628    });
66629  }
66630  
66631  function __generator(thisArg, body) {
66632    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
66633    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
66634    function verb(n) { return function (v) { return step([n, v]); }; }
66635    function step(op) {
66636        if (f) throw new TypeError("Generator is already executing.");
66637        while (g && (g = 0, op[0] && (_ = 0)), _) try {
66638            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
66639            if (y = 0, t) op = [op[0] & 2, t.value];
66640            switch (op[0]) {
66641                case 0: case 1: t = op; break;
66642                case 4: _.label++; return { value: op[1], done: false };
66643                case 5: _.label++; y = op[1]; op = [0]; continue;
66644                case 7: op = _.ops.pop(); _.trys.pop(); continue;
66645                default:
66646                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
66647                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
66648                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
66649                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
66650                    if (t[2]) _.ops.pop();
66651                    _.trys.pop(); continue;
66652            }
66653            op = body.call(thisArg, _);
66654        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
66655        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
66656    }
66657  }
66658  
66659  var __createBinding = Object.create ? (function(o, m, k, k2) {
66660    if (k2 === undefined) k2 = k;
66661    var desc = Object.getOwnPropertyDescriptor(m, k);
66662    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
66663        desc = { enumerable: true, get: function() { return m[k]; } };
66664    }
66665    Object.defineProperty(o, k2, desc);
66666  }) : (function(o, m, k, k2) {
66667    if (k2 === undefined) k2 = k;
66668    o[k2] = m[k];
66669  });
66670  
66671  function __exportStar(m, o) {
66672    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);
66673  }
66674  
66675  function __values(o) {
66676    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
66677    if (m) return m.call(o);
66678    if (o && typeof o.length === "number") return {
66679        next: function () {
66680            if (o && i >= o.length) o = void 0;
66681            return { value: o && o[i++], done: !o };
66682        }
66683    };
66684    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
66685  }
66686  
66687  function __read(o, n) {
66688    var m = typeof Symbol === "function" && o[Symbol.iterator];
66689    if (!m) return o;
66690    var i = m.call(o), r, ar = [], e;
66691    try {
66692        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
66693    }
66694    catch (error) { e = { error: error }; }
66695    finally {
66696        try {
66697            if (r && !r.done && (m = i["return"])) m.call(i);
66698        }
66699        finally { if (e) throw e.error; }
66700    }
66701    return ar;
66702  }
66703  
66704  /** @deprecated */
66705  function __spread() {
66706    for (var ar = [], i = 0; i < arguments.length; i++)
66707        ar = ar.concat(__read(arguments[i]));
66708    return ar;
66709  }
66710  
66711  /** @deprecated */
66712  function __spreadArrays() {
66713    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
66714    for (var r = Array(s), k = 0, i = 0; i < il; i++)
66715        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
66716            r[k] = a[j];
66717    return r;
66718  }
66719  
66720  function __spreadArray(to, from, pack) {
66721    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
66722        if (ar || !(i in from)) {
66723            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
66724            ar[i] = from[i];
66725        }
66726    }
66727    return to.concat(ar || Array.prototype.slice.call(from));
66728  }
66729  
66730  function __await(v) {
66731    return this instanceof __await ? (this.v = v, this) : new __await(v);
66732  }
66733  
66734  function __asyncGenerator(thisArg, _arguments, generator) {
66735    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
66736    var g = generator.apply(thisArg, _arguments || []), i, q = [];
66737    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
66738    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
66739    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
66740    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
66741    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
66742    function fulfill(value) { resume("next", value); }
66743    function reject(value) { resume("throw", value); }
66744    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
66745  }
66746  
66747  function __asyncDelegator(o) {
66748    var i, p;
66749    return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
66750    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; } : f; }
66751  }
66752  
66753  function __asyncValues(o) {
66754    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
66755    var m = o[Symbol.asyncIterator], i;
66756    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
66757    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
66758    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
66759  }
66760  
66761  function __makeTemplateObject(cooked, raw) {
66762    if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
66763    return cooked;
66764  };
66765  
66766  var __setModuleDefault = Object.create ? (function(o, v) {
66767    Object.defineProperty(o, "default", { enumerable: true, value: v });
66768  }) : function(o, v) {
66769    o["default"] = v;
66770  };
66771  
66772  var ownKeys = function(o) {
66773    ownKeys = Object.getOwnPropertyNames || function (o) {
66774      var ar = [];
66775      for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
66776      return ar;
66777    };
66778    return ownKeys(o);
66779  };
66780  
66781  function __importStar(mod) {
66782    if (mod && mod.__esModule) return mod;
66783    var result = {};
66784    if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
66785    __setModuleDefault(result, mod);
66786    return result;
66787  }
66788  
66789  function __importDefault(mod) {
66790    return (mod && mod.__esModule) ? mod : { default: mod };
66791  }
66792  
66793  function __classPrivateFieldGet(receiver, state, kind, f) {
66794    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
66795    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
66796    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
66797  }
66798  
66799  function __classPrivateFieldSet(receiver, state, value, kind, f) {
66800    if (kind === "m") throw new TypeError("Private method is not writable");
66801    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
66802    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
66803    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
66804  }
66805  
66806  function __classPrivateFieldIn(state, receiver) {
66807    if (receiver === null || (typeof receiver !== "object" && typeof receiver !== "function")) throw new TypeError("Cannot use 'in' operator on non-object");
66808    return typeof state === "function" ? receiver === state : state.has(receiver);
66809  }
66810  
66811  function __addDisposableResource(env, value, async) {
66812    if (value !== null && value !== void 0) {
66813      if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
66814      var dispose, inner;
66815      if (async) {
66816        if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
66817        dispose = value[Symbol.asyncDispose];
66818      }
66819      if (dispose === void 0) {
66820        if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
66821        dispose = value[Symbol.dispose];
66822        if (async) inner = dispose;
66823      }
66824      if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
66825      if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
66826      env.stack.push({ value: value, dispose: dispose, async: async });
66827    }
66828    else if (async) {
66829      env.stack.push({ async: true });
66830    }
66831    return value;
66832  }
66833  
66834  var _SuppressedError = typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
66835    var e = new Error(message);
66836    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
66837  };
66838  
66839  function __disposeResources(env) {
66840    function fail(e) {
66841      env.error = env.hasError ? new _SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
66842      env.hasError = true;
66843    }
66844    var r, s = 0;
66845    function next() {
66846      while (r = env.stack.pop()) {
66847        try {
66848          if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
66849          if (r.dispose) {
66850            var result = r.dispose.call(r.value);
66851            if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
66852          }
66853          else s |= 1;
66854        }
66855        catch (e) {
66856          fail(e);
66857        }
66858      }
66859      if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
66860      if (env.hasError) throw env.error;
66861    }
66862    return next();
66863  }
66864  
66865  function __rewriteRelativeImportExtension(path, preserveJsx) {
66866    if (typeof path === "string" && /^\.\.?\//.test(path)) {
66867        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
66868            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
66869        });
66870    }
66871    return path;
66872  }
66873  
66874  /* harmony default export */ const tslib_es6 = ({
66875    __extends,
66876    __assign,
66877    __rest,
66878    __decorate,
66879    __param,
66880    __esDecorate,
66881    __runInitializers,
66882    __propKey,
66883    __setFunctionName,
66884    __metadata,
66885    __awaiter,
66886    __generator,
66887    __createBinding,
66888    __exportStar,
66889    __values,
66890    __read,
66891    __spread,
66892    __spreadArrays,
66893    __spreadArray,
66894    __await,
66895    __asyncGenerator,
66896    __asyncDelegator,
66897    __asyncValues,
66898    __makeTemplateObject,
66899    __importStar,
66900    __importDefault,
66901    __classPrivateFieldGet,
66902    __classPrivateFieldSet,
66903    __classPrivateFieldIn,
66904    __addDisposableResource,
66905    __disposeResources,
66906    __rewriteRelativeImportExtension,
66907  });
66908  
66909  // EXTERNAL MODULE: ./node_modules/normalize-wheel/index.js
66910  var normalize_wheel = __webpack_require__(7520);
66911  var normalize_wheel_default = /*#__PURE__*/__webpack_require__.n(normalize_wheel);
66912  ;// ./node_modules/react-easy-crop/index.module.js
66913  
66914  
66915  
66916  
66917  /**

66918   * Compute the dimension of the crop area based on media size,

66919   * aspect ratio and optionally rotation

66920   */
66921  function getCropSize(mediaWidth, mediaHeight, containerWidth, containerHeight, aspect, rotation) {
66922    if (rotation === void 0) {
66923      rotation = 0;
66924    }
66925    var _a = rotateSize(mediaWidth, mediaHeight, rotation),
66926      width = _a.width,
66927      height = _a.height;
66928    var fittingWidth = Math.min(width, containerWidth);
66929    var fittingHeight = Math.min(height, containerHeight);
66930    if (fittingWidth > fittingHeight * aspect) {
66931      return {
66932        width: fittingHeight * aspect,
66933        height: fittingHeight
66934      };
66935    }
66936    return {
66937      width: fittingWidth,
66938      height: fittingWidth / aspect
66939    };
66940  }
66941  /**

66942   * Compute media zoom.

66943   * We fit the media into the container with "max-width: 100%; max-height: 100%;"

66944   */
66945  function getMediaZoom(mediaSize) {
66946    // Take the axis with more pixels to improve accuracy
66947    return mediaSize.width > mediaSize.height ? mediaSize.width / mediaSize.naturalWidth : mediaSize.height / mediaSize.naturalHeight;
66948  }
66949  /**

66950   * Ensure a new media position stays in the crop area.

66951   */
66952  function restrictPosition(position, mediaSize, cropSize, zoom, rotation) {
66953    if (rotation === void 0) {
66954      rotation = 0;
66955    }
66956    var _a = rotateSize(mediaSize.width, mediaSize.height, rotation),
66957      width = _a.width,
66958      height = _a.height;
66959    return {
66960      x: restrictPositionCoord(position.x, width, cropSize.width, zoom),
66961      y: restrictPositionCoord(position.y, height, cropSize.height, zoom)
66962    };
66963  }
66964  function restrictPositionCoord(position, mediaSize, cropSize, zoom) {
66965    var maxPosition = mediaSize * zoom / 2 - cropSize / 2;
66966    return clamp(position, -maxPosition, maxPosition);
66967  }
66968  function getDistanceBetweenPoints(pointA, pointB) {
66969    return Math.sqrt(Math.pow(pointA.y - pointB.y, 2) + Math.pow(pointA.x - pointB.x, 2));
66970  }
66971  function getRotationBetweenPoints(pointA, pointB) {
66972    return Math.atan2(pointB.y - pointA.y, pointB.x - pointA.x) * 180 / Math.PI;
66973  }
66974  /**

66975   * Compute the output cropped area of the media in percentages and pixels.

66976   * x/y are the top-left coordinates on the src media

66977   */
66978  function computeCroppedArea(crop, mediaSize, cropSize, aspect, zoom, rotation, restrictPosition) {
66979    if (rotation === void 0) {
66980      rotation = 0;
66981    }
66982    if (restrictPosition === void 0) {
66983      restrictPosition = true;
66984    }
66985    // if the media is rotated by the user, we cannot limit the position anymore
66986    // as it might need to be negative.
66987    var limitAreaFn = restrictPosition ? limitArea : noOp;
66988    var mediaBBoxSize = rotateSize(mediaSize.width, mediaSize.height, rotation);
66989    var mediaNaturalBBoxSize = rotateSize(mediaSize.naturalWidth, mediaSize.naturalHeight, rotation);
66990    // calculate the crop area in percentages
66991    // in the rotated space
66992    var croppedAreaPercentages = {
66993      x: limitAreaFn(100, ((mediaBBoxSize.width - cropSize.width / zoom) / 2 - crop.x / zoom) / mediaBBoxSize.width * 100),
66994      y: limitAreaFn(100, ((mediaBBoxSize.height - cropSize.height / zoom) / 2 - crop.y / zoom) / mediaBBoxSize.height * 100),
66995      width: limitAreaFn(100, cropSize.width / mediaBBoxSize.width * 100 / zoom),
66996      height: limitAreaFn(100, cropSize.height / mediaBBoxSize.height * 100 / zoom)
66997    };
66998    // we compute the pixels size naively
66999    var widthInPixels = Math.round(limitAreaFn(mediaNaturalBBoxSize.width, croppedAreaPercentages.width * mediaNaturalBBoxSize.width / 100));
67000    var heightInPixels = Math.round(limitAreaFn(mediaNaturalBBoxSize.height, croppedAreaPercentages.height * mediaNaturalBBoxSize.height / 100));
67001    var isImgWiderThanHigh = mediaNaturalBBoxSize.width >= mediaNaturalBBoxSize.height * aspect;
67002    // then we ensure the width and height exactly match the aspect (to avoid rounding approximations)
67003    // if the media is wider than high, when zoom is 0, the crop height will be equals to image height
67004    // thus we want to compute the width from the height and aspect for accuracy.
67005    // Otherwise, we compute the height from width and aspect.
67006    var sizePixels = isImgWiderThanHigh ? {
67007      width: Math.round(heightInPixels * aspect),
67008      height: heightInPixels
67009    } : {
67010      width: widthInPixels,
67011      height: Math.round(widthInPixels / aspect)
67012    };
67013    var croppedAreaPixels = __assign(__assign({}, sizePixels), {
67014      x: Math.round(limitAreaFn(mediaNaturalBBoxSize.width - sizePixels.width, croppedAreaPercentages.x * mediaNaturalBBoxSize.width / 100)),
67015      y: Math.round(limitAreaFn(mediaNaturalBBoxSize.height - sizePixels.height, croppedAreaPercentages.y * mediaNaturalBBoxSize.height / 100))
67016    });
67017    return {
67018      croppedAreaPercentages: croppedAreaPercentages,
67019      croppedAreaPixels: croppedAreaPixels
67020    };
67021  }
67022  /**

67023   * Ensure the returned value is between 0 and max

67024   */
67025  function limitArea(max, value) {
67026    return Math.min(max, Math.max(0, value));
67027  }
67028  function noOp(_max, value) {
67029    return value;
67030  }
67031  /**

67032   * Compute crop and zoom from the croppedAreaPercentages.

67033   */
67034  function getInitialCropFromCroppedAreaPercentages(croppedAreaPercentages, mediaSize, rotation, cropSize, minZoom, maxZoom) {
67035    var mediaBBoxSize = rotateSize(mediaSize.width, mediaSize.height, rotation);
67036    // This is the inverse process of computeCroppedArea
67037    var zoom = clamp(cropSize.width / mediaBBoxSize.width * (100 / croppedAreaPercentages.width), minZoom, maxZoom);
67038    var crop = {
67039      x: zoom * mediaBBoxSize.width / 2 - cropSize.width / 2 - mediaBBoxSize.width * zoom * (croppedAreaPercentages.x / 100),
67040      y: zoom * mediaBBoxSize.height / 2 - cropSize.height / 2 - mediaBBoxSize.height * zoom * (croppedAreaPercentages.y / 100)
67041    };
67042    return {
67043      crop: crop,
67044      zoom: zoom
67045    };
67046  }
67047  /**

67048   * Compute zoom from the croppedAreaPixels

67049   */
67050  function getZoomFromCroppedAreaPixels(croppedAreaPixels, mediaSize, cropSize) {
67051    var mediaZoom = getMediaZoom(mediaSize);
67052    return cropSize.height > cropSize.width ? cropSize.height / (croppedAreaPixels.height * mediaZoom) : cropSize.width / (croppedAreaPixels.width * mediaZoom);
67053  }
67054  /**

67055   * Compute crop and zoom from the croppedAreaPixels

67056   */
67057  function getInitialCropFromCroppedAreaPixels(croppedAreaPixels, mediaSize, rotation, cropSize, minZoom, maxZoom) {
67058    if (rotation === void 0) {
67059      rotation = 0;
67060    }
67061    var mediaNaturalBBoxSize = rotateSize(mediaSize.naturalWidth, mediaSize.naturalHeight, rotation);
67062    var zoom = clamp(getZoomFromCroppedAreaPixels(croppedAreaPixels, mediaSize, cropSize), minZoom, maxZoom);
67063    var cropZoom = cropSize.height > cropSize.width ? cropSize.height / croppedAreaPixels.height : cropSize.width / croppedAreaPixels.width;
67064    var crop = {
67065      x: ((mediaNaturalBBoxSize.width - croppedAreaPixels.width) / 2 - croppedAreaPixels.x) * cropZoom,
67066      y: ((mediaNaturalBBoxSize.height - croppedAreaPixels.height) / 2 - croppedAreaPixels.y) * cropZoom
67067    };
67068    return {
67069      crop: crop,
67070      zoom: zoom
67071    };
67072  }
67073  /**

67074   * Return the point that is the center of point a and b

67075   */
67076  function getCenter(a, b) {
67077    return {
67078      x: (b.x + a.x) / 2,
67079      y: (b.y + a.y) / 2
67080    };
67081  }
67082  function getRadianAngle(degreeValue) {
67083    return degreeValue * Math.PI / 180;
67084  }
67085  /**

67086   * Returns the new bounding area of a rotated rectangle.

67087   */
67088  function rotateSize(width, height, rotation) {
67089    var rotRad = getRadianAngle(rotation);
67090    return {
67091      width: Math.abs(Math.cos(rotRad) * width) + Math.abs(Math.sin(rotRad) * height),
67092      height: Math.abs(Math.sin(rotRad) * width) + Math.abs(Math.cos(rotRad) * height)
67093    };
67094  }
67095  /**

67096   * Clamp value between min and max

67097   */
67098  function clamp(value, min, max) {
67099    return Math.min(Math.max(value, min), max);
67100  }
67101  /**

67102   * Combine multiple class names into a single string.

67103   */
67104  function classNames() {
67105    var args = [];
67106    for (var _i = 0; _i < arguments.length; _i++) {
67107      args[_i] = arguments[_i];
67108    }
67109    return args.filter(function (value) {
67110      if (typeof value === 'string' && value.length > 0) {
67111        return true;
67112      }
67113      return false;
67114    }).join(' ').trim();
67115  }
67116  
67117  var css_248z = ".reactEasyCrop_Container {\n  position: absolute;\n  top: 0;\n  left: 0;\n  right: 0;\n  bottom: 0;\n  overflow: hidden;\n  user-select: none;\n  touch-action: none;\n  cursor: move;\n  display: flex;\n  justify-content: center;\n  align-items: center;\n}\n\n.reactEasyCrop_Image,\n.reactEasyCrop_Video {\n  will-change: transform; /* this improves performances and prevent painting issues on iOS Chrome */\n}\n\n.reactEasyCrop_Contain {\n  max-width: 100%;\n  max-height: 100%;\n  margin: auto;\n  position: absolute;\n  top: 0;\n  bottom: 0;\n  left: 0;\n  right: 0;\n}\n.reactEasyCrop_Cover_Horizontal {\n  width: 100%;\n  height: auto;\n}\n.reactEasyCrop_Cover_Vertical {\n  width: auto;\n  height: 100%;\n}\n\n.reactEasyCrop_CropArea {\n  position: absolute;\n  left: 50%;\n  top: 50%;\n  transform: translate(-50%, -50%);\n  border: 1px solid rgba(255, 255, 255, 0.5);\n  box-sizing: border-box;\n  box-shadow: 0 0 0 9999em;\n  color: rgba(0, 0, 0, 0.5);\n  overflow: hidden;\n}\n\n.reactEasyCrop_CropAreaRound {\n  border-radius: 50%;\n}\n\n.reactEasyCrop_CropAreaGrid::before {\n  content: ' ';\n  box-sizing: border-box;\n  position: absolute;\n  border: 1px solid rgba(255, 255, 255, 0.5);\n  top: 0;\n  bottom: 0;\n  left: 33.33%;\n  right: 33.33%;\n  border-top: 0;\n  border-bottom: 0;\n}\n\n.reactEasyCrop_CropAreaGrid::after {\n  content: ' ';\n  box-sizing: border-box;\n  position: absolute;\n  border: 1px solid rgba(255, 255, 255, 0.5);\n  top: 33.33%;\n  bottom: 33.33%;\n  left: 0;\n  right: 0;\n  border-left: 0;\n  border-right: 0;\n}\n";
67118  
67119  var index_module_MIN_ZOOM = 1;
67120  var index_module_MAX_ZOOM = 3;
67121  var Cropper = /** @class */function (_super) {
67122    __extends(Cropper, _super);
67123    function Cropper() {
67124      var _this = _super !== null && _super.apply(this, arguments) || this;
67125      _this.imageRef = external_React_.createRef();
67126      _this.videoRef = external_React_.createRef();
67127      _this.containerPosition = {
67128        x: 0,
67129        y: 0
67130      };
67131      _this.containerRef = null;
67132      _this.styleRef = null;
67133      _this.containerRect = null;
67134      _this.mediaSize = {
67135        width: 0,
67136        height: 0,
67137        naturalWidth: 0,
67138        naturalHeight: 0
67139      };
67140      _this.dragStartPosition = {
67141        x: 0,
67142        y: 0
67143      };
67144      _this.dragStartCrop = {
67145        x: 0,
67146        y: 0
67147      };
67148      _this.gestureZoomStart = 0;
67149      _this.gestureRotationStart = 0;
67150      _this.isTouching = false;
67151      _this.lastPinchDistance = 0;
67152      _this.lastPinchRotation = 0;
67153      _this.rafDragTimeout = null;
67154      _this.rafPinchTimeout = null;
67155      _this.wheelTimer = null;
67156      _this.currentDoc = typeof document !== 'undefined' ? document : null;
67157      _this.currentWindow = typeof window !== 'undefined' ? window : null;
67158      _this.resizeObserver = null;
67159      _this.state = {
67160        cropSize: null,
67161        hasWheelJustStarted: false,
67162        mediaObjectFit: undefined
67163      };
67164      _this.initResizeObserver = function () {
67165        if (typeof window.ResizeObserver === 'undefined' || !_this.containerRef) {
67166          return;
67167        }
67168        var isFirstResize = true;
67169        _this.resizeObserver = new window.ResizeObserver(function (entries) {
67170          if (isFirstResize) {
67171            isFirstResize = false; // observe() is called on mount, we don't want to trigger a recompute on mount
67172            return;
67173          }
67174          _this.computeSizes();
67175        });
67176        _this.resizeObserver.observe(_this.containerRef);
67177      };
67178      // this is to prevent Safari on iOS >= 10 to zoom the page
67179      _this.preventZoomSafari = function (e) {
67180        return e.preventDefault();
67181      };
67182      _this.cleanEvents = function () {
67183        if (!_this.currentDoc) return;
67184        _this.currentDoc.removeEventListener('mousemove', _this.onMouseMove);
67185        _this.currentDoc.removeEventListener('mouseup', _this.onDragStopped);
67186        _this.currentDoc.removeEventListener('touchmove', _this.onTouchMove);
67187        _this.currentDoc.removeEventListener('touchend', _this.onDragStopped);
67188        _this.currentDoc.removeEventListener('gesturemove', _this.onGestureMove);
67189        _this.currentDoc.removeEventListener('gestureend', _this.onGestureEnd);
67190        _this.currentDoc.removeEventListener('scroll', _this.onScroll);
67191      };
67192      _this.clearScrollEvent = function () {
67193        if (_this.containerRef) _this.containerRef.removeEventListener('wheel', _this.onWheel);
67194        if (_this.wheelTimer) {
67195          clearTimeout(_this.wheelTimer);
67196        }
67197      };
67198      _this.onMediaLoad = function () {
67199        var cropSize = _this.computeSizes();
67200        if (cropSize) {
67201          _this.emitCropData();
67202          _this.setInitialCrop(cropSize);
67203        }
67204        if (_this.props.onMediaLoaded) {
67205          _this.props.onMediaLoaded(_this.mediaSize);
67206        }
67207      };
67208      _this.setInitialCrop = function (cropSize) {
67209        if (_this.props.initialCroppedAreaPercentages) {
67210          var _a = getInitialCropFromCroppedAreaPercentages(_this.props.initialCroppedAreaPercentages, _this.mediaSize, _this.props.rotation, cropSize, _this.props.minZoom, _this.props.maxZoom),
67211            crop = _a.crop,
67212            zoom = _a.zoom;
67213          _this.props.onCropChange(crop);
67214          _this.props.onZoomChange && _this.props.onZoomChange(zoom);
67215        } else if (_this.props.initialCroppedAreaPixels) {
67216          var _b = getInitialCropFromCroppedAreaPixels(_this.props.initialCroppedAreaPixels, _this.mediaSize, _this.props.rotation, cropSize, _this.props.minZoom, _this.props.maxZoom),
67217            crop = _b.crop,
67218            zoom = _b.zoom;
67219          _this.props.onCropChange(crop);
67220          _this.props.onZoomChange && _this.props.onZoomChange(zoom);
67221        }
67222      };
67223      _this.computeSizes = function () {
67224        var _a, _b, _c, _d, _e, _f;
67225        var mediaRef = _this.imageRef.current || _this.videoRef.current;
67226        if (mediaRef && _this.containerRef) {
67227          _this.containerRect = _this.containerRef.getBoundingClientRect();
67228          _this.saveContainerPosition();
67229          var containerAspect = _this.containerRect.width / _this.containerRect.height;
67230          var naturalWidth = ((_a = _this.imageRef.current) === null || _a === void 0 ? void 0 : _a.naturalWidth) || ((_b = _this.videoRef.current) === null || _b === void 0 ? void 0 : _b.videoWidth) || 0;
67231          var naturalHeight = ((_c = _this.imageRef.current) === null || _c === void 0 ? void 0 : _c.naturalHeight) || ((_d = _this.videoRef.current) === null || _d === void 0 ? void 0 : _d.videoHeight) || 0;
67232          var isMediaScaledDown = mediaRef.offsetWidth < naturalWidth || mediaRef.offsetHeight < naturalHeight;
67233          var mediaAspect = naturalWidth / naturalHeight;
67234          // We do not rely on the offsetWidth/offsetHeight if the media is scaled down
67235          // as the values they report are rounded. That will result in precision losses
67236          // when calculating zoom. We use the fact that the media is positionned relative
67237          // to the container. That allows us to use the container's dimensions
67238          // and natural aspect ratio of the media to calculate accurate media size.
67239          // However, for this to work, the container should not be rotated
67240          var renderedMediaSize = void 0;
67241          if (isMediaScaledDown) {
67242            switch (_this.state.mediaObjectFit) {
67243              default:
67244              case 'contain':
67245                renderedMediaSize = containerAspect > mediaAspect ? {
67246                  width: _this.containerRect.height * mediaAspect,
67247                  height: _this.containerRect.height
67248                } : {
67249                  width: _this.containerRect.width,
67250                  height: _this.containerRect.width / mediaAspect
67251                };
67252                break;
67253              case 'horizontal-cover':
67254                renderedMediaSize = {
67255                  width: _this.containerRect.width,
67256                  height: _this.containerRect.width / mediaAspect
67257                };
67258                break;
67259              case 'vertical-cover':
67260                renderedMediaSize = {
67261                  width: _this.containerRect.height * mediaAspect,
67262                  height: _this.containerRect.height
67263                };
67264                break;
67265            }
67266          } else {
67267            renderedMediaSize = {
67268              width: mediaRef.offsetWidth,
67269              height: mediaRef.offsetHeight
67270            };
67271          }
67272          _this.mediaSize = __assign(__assign({}, renderedMediaSize), {
67273            naturalWidth: naturalWidth,
67274            naturalHeight: naturalHeight
67275          });
67276          // set media size in the parent
67277          if (_this.props.setMediaSize) {
67278            _this.props.setMediaSize(_this.mediaSize);
67279          }
67280          var cropSize = _this.props.cropSize ? _this.props.cropSize : getCropSize(_this.mediaSize.width, _this.mediaSize.height, _this.containerRect.width, _this.containerRect.height, _this.props.aspect, _this.props.rotation);
67281          if (((_e = _this.state.cropSize) === null || _e === void 0 ? void 0 : _e.height) !== cropSize.height || ((_f = _this.state.cropSize) === null || _f === void 0 ? void 0 : _f.width) !== cropSize.width) {
67282            _this.props.onCropSizeChange && _this.props.onCropSizeChange(cropSize);
67283          }
67284          _this.setState({
67285            cropSize: cropSize
67286          }, _this.recomputeCropPosition);
67287          // pass crop size to parent
67288          if (_this.props.setCropSize) {
67289            _this.props.setCropSize(cropSize);
67290          }
67291          return cropSize;
67292        }
67293      };
67294      _this.saveContainerPosition = function () {
67295        if (_this.containerRef) {
67296          var bounds = _this.containerRef.getBoundingClientRect();
67297          _this.containerPosition = {
67298            x: bounds.left,
67299            y: bounds.top
67300          };
67301        }
67302      };
67303      _this.onMouseDown = function (e) {
67304        if (!_this.currentDoc) return;
67305        e.preventDefault();
67306        _this.currentDoc.addEventListener('mousemove', _this.onMouseMove);
67307        _this.currentDoc.addEventListener('mouseup', _this.onDragStopped);
67308        _this.saveContainerPosition();
67309        _this.onDragStart(Cropper.getMousePoint(e));
67310      };
67311      _this.onMouseMove = function (e) {
67312        return _this.onDrag(Cropper.getMousePoint(e));
67313      };
67314      _this.onScroll = function (e) {
67315        if (!_this.currentDoc) return;
67316        e.preventDefault();
67317        _this.saveContainerPosition();
67318      };
67319      _this.onTouchStart = function (e) {
67320        if (!_this.currentDoc) return;
67321        _this.isTouching = true;
67322        if (_this.props.onTouchRequest && !_this.props.onTouchRequest(e)) {
67323          return;
67324        }
67325        _this.currentDoc.addEventListener('touchmove', _this.onTouchMove, {
67326          passive: false
67327        }); // iOS 11 now defaults to passive: true
67328        _this.currentDoc.addEventListener('touchend', _this.onDragStopped);
67329        _this.saveContainerPosition();
67330        if (e.touches.length === 2) {
67331          _this.onPinchStart(e);
67332        } else if (e.touches.length === 1) {
67333          _this.onDragStart(Cropper.getTouchPoint(e.touches[0]));
67334        }
67335      };
67336      _this.onTouchMove = function (e) {
67337        // Prevent whole page from scrolling on iOS.
67338        e.preventDefault();
67339        if (e.touches.length === 2) {
67340          _this.onPinchMove(e);
67341        } else if (e.touches.length === 1) {
67342          _this.onDrag(Cropper.getTouchPoint(e.touches[0]));
67343        }
67344      };
67345      _this.onGestureStart = function (e) {
67346        if (!_this.currentDoc) return;
67347        e.preventDefault();
67348        _this.currentDoc.addEventListener('gesturechange', _this.onGestureMove);
67349        _this.currentDoc.addEventListener('gestureend', _this.onGestureEnd);
67350        _this.gestureZoomStart = _this.props.zoom;
67351        _this.gestureRotationStart = _this.props.rotation;
67352      };
67353      _this.onGestureMove = function (e) {
67354        e.preventDefault();
67355        if (_this.isTouching) {
67356          // this is to avoid conflict between gesture and touch events
67357          return;
67358        }
67359        var point = Cropper.getMousePoint(e);
67360        var newZoom = _this.gestureZoomStart - 1 + e.scale;
67361        _this.setNewZoom(newZoom, point, {
67362          shouldUpdatePosition: true
67363        });
67364        if (_this.props.onRotationChange) {
67365          var newRotation = _this.gestureRotationStart + e.rotation;
67366          _this.props.onRotationChange(newRotation);
67367        }
67368      };
67369      _this.onGestureEnd = function (e) {
67370        _this.cleanEvents();
67371      };
67372      _this.onDragStart = function (_a) {
67373        var _b, _c;
67374        var x = _a.x,
67375          y = _a.y;
67376        _this.dragStartPosition = {
67377          x: x,
67378          y: y
67379        };
67380        _this.dragStartCrop = __assign({}, _this.props.crop);
67381        (_c = (_b = _this.props).onInteractionStart) === null || _c === void 0 ? void 0 : _c.call(_b);
67382      };
67383      _this.onDrag = function (_a) {
67384        var x = _a.x,
67385          y = _a.y;
67386        if (!_this.currentWindow) return;
67387        if (_this.rafDragTimeout) _this.currentWindow.cancelAnimationFrame(_this.rafDragTimeout);
67388        _this.rafDragTimeout = _this.currentWindow.requestAnimationFrame(function () {
67389          if (!_this.state.cropSize) return;
67390          if (x === undefined || y === undefined) return;
67391          var offsetX = x - _this.dragStartPosition.x;
67392          var offsetY = y - _this.dragStartPosition.y;
67393          var requestedPosition = {
67394            x: _this.dragStartCrop.x + offsetX,
67395            y: _this.dragStartCrop.y + offsetY
67396          };
67397          var newPosition = _this.props.restrictPosition ? restrictPosition(requestedPosition, _this.mediaSize, _this.state.cropSize, _this.props.zoom, _this.props.rotation) : requestedPosition;
67398          _this.props.onCropChange(newPosition);
67399        });
67400      };
67401      _this.onDragStopped = function () {
67402        var _a, _b;
67403        _this.isTouching = false;
67404        _this.cleanEvents();
67405        _this.emitCropData();
67406        (_b = (_a = _this.props).onInteractionEnd) === null || _b === void 0 ? void 0 : _b.call(_a);
67407      };
67408      _this.onWheel = function (e) {
67409        if (!_this.currentWindow) return;
67410        if (_this.props.onWheelRequest && !_this.props.onWheelRequest(e)) {
67411          return;
67412        }
67413        e.preventDefault();
67414        var point = Cropper.getMousePoint(e);
67415        var pixelY = normalize_wheel_default()(e).pixelY;
67416        var newZoom = _this.props.zoom - pixelY * _this.props.zoomSpeed / 200;
67417        _this.setNewZoom(newZoom, point, {
67418          shouldUpdatePosition: true
67419        });
67420        if (!_this.state.hasWheelJustStarted) {
67421          _this.setState({
67422            hasWheelJustStarted: true
67423          }, function () {
67424            var _a, _b;
67425            return (_b = (_a = _this.props).onInteractionStart) === null || _b === void 0 ? void 0 : _b.call(_a);
67426          });
67427        }
67428        if (_this.wheelTimer) {
67429          clearTimeout(_this.wheelTimer);
67430        }
67431        _this.wheelTimer = _this.currentWindow.setTimeout(function () {
67432          return _this.setState({
67433            hasWheelJustStarted: false
67434          }, function () {
67435            var _a, _b;
67436            return (_b = (_a = _this.props).onInteractionEnd) === null || _b === void 0 ? void 0 : _b.call(_a);
67437          });
67438        }, 250);
67439      };
67440      _this.getPointOnContainer = function (_a, containerTopLeft) {
67441        var x = _a.x,
67442          y = _a.y;
67443        if (!_this.containerRect) {
67444          throw new Error('The Cropper is not mounted');
67445        }
67446        return {
67447          x: _this.containerRect.width / 2 - (x - containerTopLeft.x),
67448          y: _this.containerRect.height / 2 - (y - containerTopLeft.y)
67449        };
67450      };
67451      _this.getPointOnMedia = function (_a) {
67452        var x = _a.x,
67453          y = _a.y;
67454        var _b = _this.props,
67455          crop = _b.crop,
67456          zoom = _b.zoom;
67457        return {
67458          x: (x + crop.x) / zoom,
67459          y: (y + crop.y) / zoom
67460        };
67461      };
67462      _this.setNewZoom = function (zoom, point, _a) {
67463        var _b = _a === void 0 ? {} : _a,
67464          _c = _b.shouldUpdatePosition,
67465          shouldUpdatePosition = _c === void 0 ? true : _c;
67466        if (!_this.state.cropSize || !_this.props.onZoomChange) return;
67467        var newZoom = clamp(zoom, _this.props.minZoom, _this.props.maxZoom);
67468        if (shouldUpdatePosition) {
67469          var zoomPoint = _this.getPointOnContainer(point, _this.containerPosition);
67470          var zoomTarget = _this.getPointOnMedia(zoomPoint);
67471          var requestedPosition = {
67472            x: zoomTarget.x * newZoom - zoomPoint.x,
67473            y: zoomTarget.y * newZoom - zoomPoint.y
67474          };
67475          var newPosition = _this.props.restrictPosition ? restrictPosition(requestedPosition, _this.mediaSize, _this.state.cropSize, newZoom, _this.props.rotation) : requestedPosition;
67476          _this.props.onCropChange(newPosition);
67477        }
67478        _this.props.onZoomChange(newZoom);
67479      };
67480      _this.getCropData = function () {
67481        if (!_this.state.cropSize) {
67482          return null;
67483        }
67484        // this is to ensure the crop is correctly restricted after a zoom back (https://github.com/ValentinH/react-easy-crop/issues/6)
67485        var restrictedPosition = _this.props.restrictPosition ? restrictPosition(_this.props.crop, _this.mediaSize, _this.state.cropSize, _this.props.zoom, _this.props.rotation) : _this.props.crop;
67486        return computeCroppedArea(restrictedPosition, _this.mediaSize, _this.state.cropSize, _this.getAspect(), _this.props.zoom, _this.props.rotation, _this.props.restrictPosition);
67487      };
67488      _this.emitCropData = function () {
67489        var cropData = _this.getCropData();
67490        if (!cropData) return;
67491        var croppedAreaPercentages = cropData.croppedAreaPercentages,
67492          croppedAreaPixels = cropData.croppedAreaPixels;
67493        if (_this.props.onCropComplete) {
67494          _this.props.onCropComplete(croppedAreaPercentages, croppedAreaPixels);
67495        }
67496        if (_this.props.onCropAreaChange) {
67497          _this.props.onCropAreaChange(croppedAreaPercentages, croppedAreaPixels);
67498        }
67499      };
67500      _this.emitCropAreaChange = function () {
67501        var cropData = _this.getCropData();
67502        if (!cropData) return;
67503        var croppedAreaPercentages = cropData.croppedAreaPercentages,
67504          croppedAreaPixels = cropData.croppedAreaPixels;
67505        if (_this.props.onCropAreaChange) {
67506          _this.props.onCropAreaChange(croppedAreaPercentages, croppedAreaPixels);
67507        }
67508      };
67509      _this.recomputeCropPosition = function () {
67510        if (!_this.state.cropSize) return;
67511        var newPosition = _this.props.restrictPosition ? restrictPosition(_this.props.crop, _this.mediaSize, _this.state.cropSize, _this.props.zoom, _this.props.rotation) : _this.props.crop;
67512        _this.props.onCropChange(newPosition);
67513        _this.emitCropData();
67514      };
67515      return _this;
67516    }
67517    Cropper.prototype.componentDidMount = function () {
67518      if (!this.currentDoc || !this.currentWindow) return;
67519      if (this.containerRef) {
67520        if (this.containerRef.ownerDocument) {
67521          this.currentDoc = this.containerRef.ownerDocument;
67522        }
67523        if (this.currentDoc.defaultView) {
67524          this.currentWindow = this.currentDoc.defaultView;
67525        }
67526        this.initResizeObserver();
67527        // only add window resize listener if ResizeObserver is not supported. Otherwise, it would be redundant
67528        if (typeof window.ResizeObserver === 'undefined') {
67529          this.currentWindow.addEventListener('resize', this.computeSizes);
67530        }
67531        this.props.zoomWithScroll && this.containerRef.addEventListener('wheel', this.onWheel, {
67532          passive: false
67533        });
67534        this.containerRef.addEventListener('gesturestart', this.onGestureStart);
67535      }
67536      this.currentDoc.addEventListener('scroll', this.onScroll);
67537      if (!this.props.disableAutomaticStylesInjection) {
67538        this.styleRef = this.currentDoc.createElement('style');
67539        this.styleRef.setAttribute('type', 'text/css');
67540        if (this.props.nonce) {
67541          this.styleRef.setAttribute('nonce', this.props.nonce);
67542        }
67543        this.styleRef.innerHTML = css_248z;
67544        this.currentDoc.head.appendChild(this.styleRef);
67545      }
67546      // when rendered via SSR, the image can already be loaded and its onLoad callback will never be called
67547      if (this.imageRef.current && this.imageRef.current.complete) {
67548        this.onMediaLoad();
67549      }
67550      // set image and video refs in the parent if the callbacks exist
67551      if (this.props.setImageRef) {
67552        this.props.setImageRef(this.imageRef);
67553      }
67554      if (this.props.setVideoRef) {
67555        this.props.setVideoRef(this.videoRef);
67556      }
67557    };
67558    Cropper.prototype.componentWillUnmount = function () {
67559      var _a, _b;
67560      if (!this.currentDoc || !this.currentWindow) return;
67561      if (typeof window.ResizeObserver === 'undefined') {
67562        this.currentWindow.removeEventListener('resize', this.computeSizes);
67563      }
67564      (_a = this.resizeObserver) === null || _a === void 0 ? void 0 : _a.disconnect();
67565      if (this.containerRef) {
67566        this.containerRef.removeEventListener('gesturestart', this.preventZoomSafari);
67567      }
67568      if (this.styleRef) {
67569        (_b = this.styleRef.parentNode) === null || _b === void 0 ? void 0 : _b.removeChild(this.styleRef);
67570      }
67571      this.cleanEvents();
67572      this.props.zoomWithScroll && this.clearScrollEvent();
67573    };
67574    Cropper.prototype.componentDidUpdate = function (prevProps) {
67575      var _a, _b, _c, _d, _e, _f, _g, _h, _j;
67576      if (prevProps.rotation !== this.props.rotation) {
67577        this.computeSizes();
67578        this.recomputeCropPosition();
67579      } else if (prevProps.aspect !== this.props.aspect) {
67580        this.computeSizes();
67581      } else if (prevProps.objectFit !== this.props.objectFit) {
67582        this.computeSizes();
67583      } else if (prevProps.zoom !== this.props.zoom) {
67584        this.recomputeCropPosition();
67585      } else if (((_a = prevProps.cropSize) === null || _a === void 0 ? void 0 : _a.height) !== ((_b = this.props.cropSize) === null || _b === void 0 ? void 0 : _b.height) || ((_c = prevProps.cropSize) === null || _c === void 0 ? void 0 : _c.width) !== ((_d = this.props.cropSize) === null || _d === void 0 ? void 0 : _d.width)) {
67586        this.computeSizes();
67587      } else if (((_e = prevProps.crop) === null || _e === void 0 ? void 0 : _e.x) !== ((_f = this.props.crop) === null || _f === void 0 ? void 0 : _f.x) || ((_g = prevProps.crop) === null || _g === void 0 ? void 0 : _g.y) !== ((_h = this.props.crop) === null || _h === void 0 ? void 0 : _h.y)) {
67588        this.emitCropAreaChange();
67589      }
67590      if (prevProps.zoomWithScroll !== this.props.zoomWithScroll && this.containerRef) {
67591        this.props.zoomWithScroll ? this.containerRef.addEventListener('wheel', this.onWheel, {
67592          passive: false
67593        }) : this.clearScrollEvent();
67594      }
67595      if (prevProps.video !== this.props.video) {
67596        (_j = this.videoRef.current) === null || _j === void 0 ? void 0 : _j.load();
67597      }
67598      var objectFit = this.getObjectFit();
67599      if (objectFit !== this.state.mediaObjectFit) {
67600        this.setState({
67601          mediaObjectFit: objectFit
67602        }, this.computeSizes);
67603      }
67604    };
67605    Cropper.prototype.getAspect = function () {
67606      var _a = this.props,
67607        cropSize = _a.cropSize,
67608        aspect = _a.aspect;
67609      if (cropSize) {
67610        return cropSize.width / cropSize.height;
67611      }
67612      return aspect;
67613    };
67614    Cropper.prototype.getObjectFit = function () {
67615      var _a, _b, _c, _d;
67616      if (this.props.objectFit === 'cover') {
67617        var mediaRef = this.imageRef.current || this.videoRef.current;
67618        if (mediaRef && this.containerRef) {
67619          this.containerRect = this.containerRef.getBoundingClientRect();
67620          var containerAspect = this.containerRect.width / this.containerRect.height;
67621          var naturalWidth = ((_a = this.imageRef.current) === null || _a === void 0 ? void 0 : _a.naturalWidth) || ((_b = this.videoRef.current) === null || _b === void 0 ? void 0 : _b.videoWidth) || 0;
67622          var naturalHeight = ((_c = this.imageRef.current) === null || _c === void 0 ? void 0 : _c.naturalHeight) || ((_d = this.videoRef.current) === null || _d === void 0 ? void 0 : _d.videoHeight) || 0;
67623          var mediaAspect = naturalWidth / naturalHeight;
67624          return mediaAspect < containerAspect ? 'horizontal-cover' : 'vertical-cover';
67625        }
67626        return 'horizontal-cover';
67627      }
67628      return this.props.objectFit;
67629    };
67630    Cropper.prototype.onPinchStart = function (e) {
67631      var pointA = Cropper.getTouchPoint(e.touches[0]);
67632      var pointB = Cropper.getTouchPoint(e.touches[1]);
67633      this.lastPinchDistance = getDistanceBetweenPoints(pointA, pointB);
67634      this.lastPinchRotation = getRotationBetweenPoints(pointA, pointB);
67635      this.onDragStart(getCenter(pointA, pointB));
67636    };
67637    Cropper.prototype.onPinchMove = function (e) {
67638      var _this = this;
67639      if (!this.currentDoc || !this.currentWindow) return;
67640      var pointA = Cropper.getTouchPoint(e.touches[0]);
67641      var pointB = Cropper.getTouchPoint(e.touches[1]);
67642      var center = getCenter(pointA, pointB);
67643      this.onDrag(center);
67644      if (this.rafPinchTimeout) this.currentWindow.cancelAnimationFrame(this.rafPinchTimeout);
67645      this.rafPinchTimeout = this.currentWindow.requestAnimationFrame(function () {
67646        var distance = getDistanceBetweenPoints(pointA, pointB);
67647        var newZoom = _this.props.zoom * (distance / _this.lastPinchDistance);
67648        _this.setNewZoom(newZoom, center, {
67649          shouldUpdatePosition: false
67650        });
67651        _this.lastPinchDistance = distance;
67652        var rotation = getRotationBetweenPoints(pointA, pointB);
67653        var newRotation = _this.props.rotation + (rotation - _this.lastPinchRotation);
67654        _this.props.onRotationChange && _this.props.onRotationChange(newRotation);
67655        _this.lastPinchRotation = rotation;
67656      });
67657    };
67658    Cropper.prototype.render = function () {
67659      var _this = this;
67660      var _a = this.props,
67661        image = _a.image,
67662        video = _a.video,
67663        mediaProps = _a.mediaProps,
67664        transform = _a.transform,
67665        _b = _a.crop,
67666        x = _b.x,
67667        y = _b.y,
67668        rotation = _a.rotation,
67669        zoom = _a.zoom,
67670        cropShape = _a.cropShape,
67671        showGrid = _a.showGrid,
67672        _c = _a.style,
67673        containerStyle = _c.containerStyle,
67674        cropAreaStyle = _c.cropAreaStyle,
67675        mediaStyle = _c.mediaStyle,
67676        _d = _a.classes,
67677        containerClassName = _d.containerClassName,
67678        cropAreaClassName = _d.cropAreaClassName,
67679        mediaClassName = _d.mediaClassName;
67680      var objectFit = this.state.mediaObjectFit;
67681      return external_React_.createElement("div", {
67682        onMouseDown: this.onMouseDown,
67683        onTouchStart: this.onTouchStart,
67684        ref: function ref(el) {
67685          return _this.containerRef = el;
67686        },
67687        "data-testid": "container",
67688        style: containerStyle,
67689        className: classNames('reactEasyCrop_Container', containerClassName)
67690      }, image ? external_React_.createElement("img", __assign({
67691        alt: "",
67692        className: classNames('reactEasyCrop_Image', objectFit === 'contain' && 'reactEasyCrop_Contain', objectFit === 'horizontal-cover' && 'reactEasyCrop_Cover_Horizontal', objectFit === 'vertical-cover' && 'reactEasyCrop_Cover_Vertical', mediaClassName)
67693      }, mediaProps, {
67694        src: image,
67695        ref: this.imageRef,
67696        style: __assign(__assign({}, mediaStyle), {
67697          transform: transform || "translate(".concat(x, "px, ").concat(y, "px) rotate(").concat(rotation, "deg) scale(").concat(zoom, ")")
67698        }),
67699        onLoad: this.onMediaLoad
67700      })) : video && external_React_.createElement("video", __assign({
67701        autoPlay: true,
67702        loop: true,
67703        muted: true,
67704        className: classNames('reactEasyCrop_Video', objectFit === 'contain' && 'reactEasyCrop_Contain', objectFit === 'horizontal-cover' && 'reactEasyCrop_Cover_Horizontal', objectFit === 'vertical-cover' && 'reactEasyCrop_Cover_Vertical', mediaClassName)
67705      }, mediaProps, {
67706        ref: this.videoRef,
67707        onLoadedMetadata: this.onMediaLoad,
67708        style: __assign(__assign({}, mediaStyle), {
67709          transform: transform || "translate(".concat(x, "px, ").concat(y, "px) rotate(").concat(rotation, "deg) scale(").concat(zoom, ")")
67710        }),
67711        controls: false
67712      }), (Array.isArray(video) ? video : [{
67713        src: video
67714      }]).map(function (item) {
67715        return external_React_.createElement("source", __assign({
67716          key: item.src
67717        }, item));
67718      })), this.state.cropSize && external_React_.createElement("div", {
67719        style: __assign(__assign({}, cropAreaStyle), {
67720          width: this.state.cropSize.width,
67721          height: this.state.cropSize.height
67722        }),
67723        "data-testid": "cropper",
67724        className: classNames('reactEasyCrop_CropArea', cropShape === 'round' && 'reactEasyCrop_CropAreaRound', showGrid && 'reactEasyCrop_CropAreaGrid', cropAreaClassName)
67725      }));
67726    };
67727    Cropper.defaultProps = {
67728      zoom: 1,
67729      rotation: 0,
67730      aspect: 4 / 3,
67731      maxZoom: index_module_MAX_ZOOM,
67732      minZoom: index_module_MIN_ZOOM,
67733      cropShape: 'rect',
67734      objectFit: 'contain',
67735      showGrid: true,
67736      style: {},
67737      classes: {},
67738      mediaProps: {},
67739      zoomSpeed: 1,
67740      restrictPosition: true,
67741      zoomWithScroll: true
67742    };
67743    Cropper.getMousePoint = function (e) {
67744      return {
67745        x: Number(e.clientX),
67746        y: Number(e.clientY)
67747      };
67748    };
67749    Cropper.getTouchPoint = function (touch) {
67750      return {
67751        x: Number(touch.clientX),
67752        y: Number(touch.clientY)
67753      };
67754    };
67755    return Cropper;
67756  }(external_React_.Component);
67757  
67758  
67759  
67760  ;// ./node_modules/@wordpress/block-editor/build-module/components/image-editor/cropper.js
67761  /**
67762   * External dependencies
67763   */
67764  
67765  
67766  
67767  /**
67768   * WordPress dependencies
67769   */
67770  
67771  
67772  
67773  /**
67774   * Internal dependencies
67775   */
67776  
67777  
67778  
67779  function ImageCropper({
67780    url,
67781    width,
67782    height,
67783    naturalHeight,
67784    naturalWidth,
67785    borderProps
67786  }) {
67787    const {
67788      isInProgress,
67789      editedUrl,
67790      position,
67791      zoom,
67792      aspect,
67793      setPosition,
67794      setCrop,
67795      setZoom,
67796      rotation
67797    } = useImageEditingContext();
67798    const [contentResizeListener, {
67799      width: clientWidth
67800    }] = (0,external_wp_compose_namespaceObject.useResizeObserver)();
67801    let editedHeight = height || clientWidth * naturalHeight / naturalWidth;
67802    if (rotation % 180 === 90) {
67803      editedHeight = clientWidth * naturalWidth / naturalHeight;
67804    }
67805    const area = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
67806      className: dist_clsx('wp-block-image__crop-area', borderProps?.className, {
67807        'is-applying': isInProgress
67808      }),
67809      style: {
67810        ...borderProps?.style,
67811        width: width || clientWidth,
67812        height: editedHeight
67813      },
67814      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Cropper, {
67815        image: editedUrl || url,
67816        disabled: isInProgress,
67817        minZoom: MIN_ZOOM / 100,
67818        maxZoom: MAX_ZOOM / 100,
67819        crop: position,
67820        zoom: zoom / 100,
67821        aspect: aspect,
67822        onCropChange: pos => {
67823          setPosition(pos);
67824        },
67825        onCropComplete: newCropPercent => {
67826          setCrop(newCropPercent);
67827        },
67828        onZoomChange: newZoom => {
67829          setZoom(newZoom * 100);
67830        }
67831      }), isInProgress && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Spinner, {})]
67832    });
67833    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
67834      children: [contentResizeListener, area]
67835    });
67836  }
67837  
67838  ;// ./node_modules/@wordpress/icons/build-module/library/search.js
67839  /**
67840   * WordPress dependencies
67841   */
67842  
67843  
67844  const search = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
67845    xmlns: "http://www.w3.org/2000/svg",
67846    viewBox: "0 0 24 24",
67847    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
67848      d: "M13 5c-3.3 0-6 2.7-6 6 0 1.4.5 2.7 1.3 3.7l-3.8 3.8 1.1 1.1 3.8-3.8c1 .8 2.3 1.3 3.7 1.3 3.3 0 6-2.7 6-6S16.3 5 13 5zm0 10.5c-2.5 0-4.5-2-4.5-4.5s2-4.5 4.5-4.5 4.5 2 4.5 4.5-2 4.5-4.5 4.5z"
67849    })
67850  });
67851  /* harmony default export */ const library_search = (search);
67852  
67853  ;// ./node_modules/@wordpress/block-editor/build-module/components/image-editor/zoom-dropdown.js
67854  /**
67855   * WordPress dependencies
67856   */
67857  
67858  
67859  
67860  
67861  /**
67862   * Internal dependencies
67863   */
67864  
67865  
67866  
67867  function ZoomDropdown() {
67868    const {
67869      isInProgress,
67870      zoom,
67871      setZoom
67872    } = useImageEditingContext();
67873    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Dropdown, {
67874      contentClassName: "wp-block-image__zoom",
67875      popoverProps: constants_POPOVER_PROPS,
67876      renderToggle: ({
67877        isOpen,
67878        onToggle
67879      }) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarButton, {
67880        icon: library_search,
67881        label: (0,external_wp_i18n_namespaceObject.__)('Zoom'),
67882        onClick: onToggle,
67883        "aria-expanded": isOpen,
67884        disabled: isInProgress
67885      }),
67886      renderContent: () => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalDropdownContentWrapper, {
67887        paddingSize: "medium",
67888        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.RangeControl, {
67889          __next40pxDefaultSize: true,
67890          __nextHasNoMarginBottom: true,
67891          label: (0,external_wp_i18n_namespaceObject.__)('Zoom'),
67892          min: MIN_ZOOM,
67893          max: MAX_ZOOM,
67894          value: Math.round(zoom),
67895          onChange: setZoom
67896        })
67897      })
67898    });
67899  }
67900  
67901  ;// ./node_modules/@wordpress/icons/build-module/library/rotate-right.js
67902  /**
67903   * WordPress dependencies
67904   */
67905  
67906  
67907  const rotateRight = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
67908    xmlns: "http://www.w3.org/2000/svg",
67909    viewBox: "0 0 24 24",
67910    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
67911      d: "M15.1 4.8l-3-2.5V4c-4.4 0-8 3.6-8 8 0 3.7 2.5 6.9 6 7.7.3.1.6.1 1 .2l.2-1.5c-.4 0-.7-.1-1.1-.2l-.1.2v-.2c-2.6-.8-4.5-3.3-4.5-6.2 0-3.6 2.9-6.5 6.5-6.5v1.8l3-2.5zM20 11c-.2-1.4-.7-2.7-1.6-3.8l-1.2.8c.7.9 1.1 2 1.3 3.1L20 11zm-1.5 1.8c-.1.5-.2 1.1-.4 1.6s-.5 1-.8 1.5l1.2.9c.4-.5.8-1.1 1-1.8s.5-1.3.5-2l-1.5-.2zm-5.6 5.6l.2 1.5c1.4-.2 2.7-.7 3.8-1.6l-.9-1.1c-.9.7-2 1.1-3.1 1.2z"
67912    })
67913  });
67914  /* harmony default export */ const rotate_right = (rotateRight);
67915  
67916  ;// ./node_modules/@wordpress/block-editor/build-module/components/image-editor/rotation-button.js
67917  /**
67918   * WordPress dependencies
67919   */
67920  
67921  
67922  
67923  
67924  
67925  /**
67926   * Internal dependencies
67927   */
67928  
67929  
67930  function RotationButton() {
67931    const {
67932      isInProgress,
67933      rotateClockwise
67934    } = useImageEditingContext();
67935    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarButton, {
67936      icon: rotate_right,
67937      label: (0,external_wp_i18n_namespaceObject.__)('Rotate'),
67938      onClick: rotateClockwise,
67939      disabled: isInProgress
67940    });
67941  }
67942  
67943  ;// ./node_modules/@wordpress/block-editor/build-module/components/image-editor/form-controls.js
67944  /**
67945   * WordPress dependencies
67946   */
67947  
67948  
67949  
67950  /**
67951   * Internal dependencies
67952   */
67953  
67954  
67955  function FormControls() {
67956    const {
67957      isInProgress,
67958      apply,
67959      cancel
67960    } = useImageEditingContext();
67961    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
67962      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarButton, {
67963        onClick: apply,
67964        disabled: isInProgress,
67965        children: (0,external_wp_i18n_namespaceObject.__)('Apply')
67966      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarButton, {
67967        onClick: cancel,
67968        children: (0,external_wp_i18n_namespaceObject.__)('Cancel')
67969      })]
67970    });
67971  }
67972  
67973  ;// ./node_modules/@wordpress/block-editor/build-module/components/image-editor/index.js
67974  /**
67975   * WordPress dependencies
67976   */
67977  
67978  
67979  /**
67980   * Internal dependencies
67981   */
67982  
67983  
67984  
67985  
67986  
67987  
67988  
67989  
67990  function ImageEditor({
67991    id,
67992    url,
67993    width,
67994    height,
67995    naturalHeight,
67996    naturalWidth,
67997    onSaveImage,
67998    onFinishEditing,
67999    borderProps
68000  }) {
68001    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(ImageEditingProvider, {
68002      id: id,
68003      url: url,
68004      naturalWidth: naturalWidth,
68005      naturalHeight: naturalHeight,
68006      onSaveImage: onSaveImage,
68007      onFinishEditing: onFinishEditing,
68008      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ImageCropper, {
68009        borderProps: borderProps,
68010        url: url,
68011        width: width,
68012        height: height,
68013        naturalHeight: naturalHeight,
68014        naturalWidth: naturalWidth
68015      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(block_controls, {
68016        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.ToolbarGroup, {
68017          children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ZoomDropdown, {}), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarItem, {
68018            children: toggleProps => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(AspectRatioDropdown, {
68019              toggleProps: toggleProps
68020            })
68021          }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(RotationButton, {})]
68022        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarGroup, {
68023          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(FormControls, {})
68024        })]
68025      })]
68026    });
68027  }
68028  
68029  ;// ./node_modules/@wordpress/block-editor/build-module/components/image-size-control/use-dimension-handler.js
68030  /**
68031   * WordPress dependencies
68032   */
68033  
68034  function useDimensionHandler(customHeight, customWidth, defaultHeight, defaultWidth, onChange) {
68035    var _ref, _ref2;
68036    const [currentWidth, setCurrentWidth] = (0,external_wp_element_namespaceObject.useState)((_ref = customWidth !== null && customWidth !== void 0 ? customWidth : defaultWidth) !== null && _ref !== void 0 ? _ref : '');
68037    const [currentHeight, setCurrentHeight] = (0,external_wp_element_namespaceObject.useState)((_ref2 = customHeight !== null && customHeight !== void 0 ? customHeight : defaultHeight) !== null && _ref2 !== void 0 ? _ref2 : '');
68038  
68039    // When an image is first inserted, the default dimensions are initially
68040    // undefined. This effect updates the dimensions when the default values
68041    // come through.
68042    (0,external_wp_element_namespaceObject.useEffect)(() => {
68043      if (customWidth === undefined && defaultWidth !== undefined) {
68044        setCurrentWidth(defaultWidth);
68045      }
68046      if (customHeight === undefined && defaultHeight !== undefined) {
68047        setCurrentHeight(defaultHeight);
68048      }
68049    }, [defaultWidth, defaultHeight]);
68050  
68051    // If custom values change, it means an outsider has resized the image using some other method (eg resize box)
68052    // this keeps track of these values too. We need to parse before comparing; custom values can be strings.
68053    (0,external_wp_element_namespaceObject.useEffect)(() => {
68054      if (customWidth !== undefined && Number.parseInt(customWidth) !== Number.parseInt(currentWidth)) {
68055        setCurrentWidth(customWidth);
68056      }
68057      if (customHeight !== undefined && Number.parseInt(customHeight) !== Number.parseInt(currentHeight)) {
68058        setCurrentHeight(customHeight);
68059      }
68060    }, [customWidth, customHeight]);
68061    const updateDimension = (dimension, value) => {
68062      const parsedValue = value === '' ? undefined : parseInt(value, 10);
68063      if (dimension === 'width') {
68064        setCurrentWidth(parsedValue);
68065      } else {
68066        setCurrentHeight(parsedValue);
68067      }
68068      onChange({
68069        [dimension]: parsedValue
68070      });
68071    };
68072    const updateDimensions = (nextHeight, nextWidth) => {
68073      setCurrentHeight(nextHeight !== null && nextHeight !== void 0 ? nextHeight : defaultHeight);
68074      setCurrentWidth(nextWidth !== null && nextWidth !== void 0 ? nextWidth : defaultWidth);
68075      onChange({
68076        height: nextHeight,
68077        width: nextWidth
68078      });
68079    };
68080    return {
68081      currentHeight,
68082      currentWidth,
68083      updateDimension,
68084      updateDimensions
68085    };
68086  }
68087  
68088  ;// ./node_modules/@wordpress/block-editor/build-module/components/image-size-control/index.js
68089  /**
68090   * WordPress dependencies
68091   */
68092  
68093  
68094  
68095  /**
68096   * Internal dependencies
68097   */
68098  
68099  
68100  const IMAGE_SIZE_PRESETS = [25, 50, 75, 100];
68101  const image_size_control_noop = () => {};
68102  
68103  /**
68104   * Get scaled width and height for the given scale.
68105   *
68106   * @param {number} scale       The scale to get the scaled width and height for.
68107   * @param {number} imageWidth  The image width.
68108   * @param {number} imageHeight The image height.
68109   *
68110   * @return {Object} The scaled width and height.
68111   */
68112  function getScaledWidthAndHeight(scale, imageWidth, imageHeight) {
68113    const scaledWidth = Math.round(imageWidth * (scale / 100));
68114    const scaledHeight = Math.round(imageHeight * (scale / 100));
68115    return {
68116      scaledWidth,
68117      scaledHeight
68118    };
68119  }
68120  function ImageSizeControl({
68121    imageSizeHelp,
68122    imageWidth,
68123    imageHeight,
68124    imageSizeOptions = [],
68125    isResizable = true,
68126    slug,
68127    width,
68128    height,
68129    onChange,
68130    onChangeImage = image_size_control_noop
68131  }) {
68132    const {
68133      currentHeight,
68134      currentWidth,
68135      updateDimension,
68136      updateDimensions
68137    } = useDimensionHandler(height, width, imageHeight, imageWidth, onChange);
68138  
68139    /**
68140     * Updates the dimensions for the given scale.
68141     * Handler for toggle group control change.
68142     *
68143     * @param {number} scale The scale to update the dimensions for.
68144     */
68145    const handleUpdateDimensions = scale => {
68146      if (undefined === scale) {
68147        updateDimensions();
68148        return;
68149      }
68150      const {
68151        scaledWidth,
68152        scaledHeight
68153      } = getScaledWidthAndHeight(scale, imageWidth, imageHeight);
68154      updateDimensions(scaledHeight, scaledWidth);
68155    };
68156  
68157    /**
68158     * Add the stored image preset value to toggle group control.
68159     */
68160    const selectedValue = IMAGE_SIZE_PRESETS.find(scale => {
68161      const {
68162        scaledWidth,
68163        scaledHeight
68164      } = getScaledWidthAndHeight(scale, imageWidth, imageHeight);
68165      return currentWidth === scaledWidth && currentHeight === scaledHeight;
68166    });
68167    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
68168      children: [imageSizeOptions && imageSizeOptions.length > 0 && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.SelectControl, {
68169        __nextHasNoMarginBottom: true,
68170        label: (0,external_wp_i18n_namespaceObject.__)('Resolution'),
68171        value: slug,
68172        options: imageSizeOptions,
68173        onChange: onChangeImage,
68174        help: imageSizeHelp,
68175        size: "__unstable-large"
68176      }), isResizable && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
68177        className: "block-editor-image-size-control",
68178        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalHStack, {
68179          align: "baseline",
68180          spacing: "3",
68181          children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalNumberControl, {
68182            className: "block-editor-image-size-control__width",
68183            label: (0,external_wp_i18n_namespaceObject.__)('Width'),
68184            value: currentWidth,
68185            min: 1,
68186            onChange: value => updateDimension('width', value),
68187            size: "__unstable-large"
68188          }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalNumberControl, {
68189            className: "block-editor-image-size-control__height",
68190            label: (0,external_wp_i18n_namespaceObject.__)('Height'),
68191            value: currentHeight,
68192            min: 1,
68193            onChange: value => updateDimension('height', value),
68194            size: "__unstable-large"
68195          })]
68196        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControl, {
68197          label: (0,external_wp_i18n_namespaceObject.__)('Image size presets'),
68198          hideLabelFromVision: true,
68199          onChange: handleUpdateDimensions,
68200          value: selectedValue,
68201          isBlock: true,
68202          __next40pxDefaultSize: true,
68203          __nextHasNoMarginBottom: true,
68204          children: IMAGE_SIZE_PRESETS.map(scale => {
68205            return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControlOption, {
68206              value: scale,
68207              label: (0,external_wp_i18n_namespaceObject.sprintf)(/* translators: Percentage value. */
68208              (0,external_wp_i18n_namespaceObject.__)('%d%%'), scale)
68209            }, scale);
68210          })
68211        })]
68212      })]
68213    });
68214  }
68215  
68216  ;// ./node_modules/@wordpress/block-editor/build-module/components/url-popover/link-viewer-url.js
68217  /**
68218   * External dependencies
68219   */
68220  
68221  
68222  /**
68223   * WordPress dependencies
68224   */
68225  
68226  
68227  
68228  function LinkViewerURL({
68229    url,
68230    urlLabel,
68231    className
68232  }) {
68233    const linkClassName = dist_clsx(className, 'block-editor-url-popover__link-viewer-url');
68234    if (!url) {
68235      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("span", {
68236        className: linkClassName
68237      });
68238    }
68239    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ExternalLink, {
68240      className: linkClassName,
68241      href: url,
68242      children: urlLabel || (0,external_wp_url_namespaceObject.filterURLForDisplay)((0,external_wp_url_namespaceObject.safeDecodeURI)(url))
68243    });
68244  }
68245  
68246  ;// ./node_modules/@wordpress/block-editor/build-module/components/url-popover/link-viewer.js
68247  /**
68248   * External dependencies
68249   */
68250  
68251  
68252  /**
68253   * WordPress dependencies
68254   */
68255  
68256  
68257  
68258  
68259  /**
68260   * Internal dependencies
68261   */
68262  
68263  
68264  function LinkViewer({
68265    className,
68266    linkClassName,
68267    onEditLinkClick,
68268    url,
68269    urlLabel,
68270    ...props
68271  }) {
68272    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
68273      className: dist_clsx('block-editor-url-popover__link-viewer', className),
68274      ...props,
68275      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(LinkViewerURL, {
68276        url: url,
68277        urlLabel: urlLabel,
68278        className: linkClassName
68279      }), onEditLinkClick && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
68280        icon: edit,
68281        label: (0,external_wp_i18n_namespaceObject.__)('Edit'),
68282        onClick: onEditLinkClick,
68283        size: "compact"
68284      })]
68285    });
68286  }
68287  
68288  ;// ./node_modules/@wordpress/block-editor/build-module/components/url-popover/link-editor.js
68289  /**
68290   * External dependencies
68291   */
68292  
68293  
68294  /**
68295   * WordPress dependencies
68296   */
68297  
68298  
68299  
68300  
68301  /**
68302   * Internal dependencies
68303   */
68304  
68305  
68306  function LinkEditor({
68307    autocompleteRef,
68308    className,
68309    onChangeInputValue,
68310    value,
68311    ...props
68312  }) {
68313    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("form", {
68314      className: dist_clsx('block-editor-url-popover__link-editor', className),
68315      ...props,
68316      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(url_input, {
68317        value: value,
68318        onChange: onChangeInputValue,
68319        autocompleteRef: autocompleteRef
68320      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
68321        icon: keyboard_return,
68322        label: (0,external_wp_i18n_namespaceObject.__)('Apply'),
68323        type: "submit",
68324        size: "compact"
68325      })]
68326    });
68327  }
68328  
68329  ;// ./node_modules/@wordpress/block-editor/build-module/components/url-popover/index.js
68330  /**
68331   * WordPress dependencies
68332   */
68333  
68334  
68335  
68336  
68337  
68338  
68339  /**
68340   * Internal dependencies
68341   */
68342  
68343  
68344  
68345  
68346  const {
68347    __experimentalPopoverLegacyPositionToPlacement
68348  } = unlock(external_wp_components_namespaceObject.privateApis);
68349  const DEFAULT_PLACEMENT = 'bottom';
68350  const URLPopover = (0,external_wp_element_namespaceObject.forwardRef)(({
68351    additionalControls,
68352    children,
68353    renderSettings,
68354    // The DEFAULT_PLACEMENT value is assigned inside the function's body
68355    placement,
68356    focusOnMount = 'firstElement',
68357    // Deprecated
68358    position,
68359    // Rest
68360    ...popoverProps
68361  }, ref) => {
68362    if (position !== undefined) {
68363      external_wp_deprecated_default()('`position` prop in wp.blockEditor.URLPopover', {
68364        since: '6.2',
68365        alternative: '`placement` prop'
68366      });
68367    }
68368  
68369    // Compute popover's placement:
68370    // - give priority to `placement` prop, if defined
68371    // - otherwise, compute it from the legacy `position` prop (if defined)
68372    // - finally, fallback to the DEFAULT_PLACEMENT.
68373    let computedPlacement;
68374    if (placement !== undefined) {
68375      computedPlacement = placement;
68376    } else if (position !== undefined) {
68377      computedPlacement = __experimentalPopoverLegacyPositionToPlacement(position);
68378    }
68379    computedPlacement = computedPlacement || DEFAULT_PLACEMENT;
68380    const [isSettingsExpanded, setIsSettingsExpanded] = (0,external_wp_element_namespaceObject.useState)(false);
68381    const showSettings = !!renderSettings && isSettingsExpanded;
68382    const toggleSettingsVisibility = () => {
68383      setIsSettingsExpanded(!isSettingsExpanded);
68384    };
68385    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.Popover, {
68386      ref: ref,
68387      role: "dialog",
68388      "aria-modal": "true",
68389      "aria-label": (0,external_wp_i18n_namespaceObject.__)('Edit URL'),
68390      className: "block-editor-url-popover",
68391      focusOnMount: focusOnMount,
68392      placement: computedPlacement,
68393      shift: true,
68394      variant: "toolbar",
68395      ...popoverProps,
68396      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
68397        className: "block-editor-url-popover__input-container",
68398        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
68399          className: "block-editor-url-popover__row",
68400          children: [children, !!renderSettings && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
68401            className: "block-editor-url-popover__settings-toggle",
68402            icon: chevron_down,
68403            label: (0,external_wp_i18n_namespaceObject.__)('Link settings'),
68404            onClick: toggleSettingsVisibility,
68405            "aria-expanded": isSettingsExpanded,
68406            size: "compact"
68407          })]
68408        })
68409      }), showSettings && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
68410        className: "block-editor-url-popover__settings",
68411        children: renderSettings()
68412      }), additionalControls && !showSettings && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
68413        className: "block-editor-url-popover__additional-controls",
68414        children: additionalControls
68415      })]
68416    });
68417  });
68418  URLPopover.LinkEditor = LinkEditor;
68419  URLPopover.LinkViewer = LinkViewer;
68420  
68421  /**
68422   * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/url-popover/README.md
68423   */
68424  /* harmony default export */ const url_popover = (URLPopover);
68425  
68426  ;// ./node_modules/@wordpress/block-editor/build-module/components/media-placeholder/index.js
68427  /**
68428   * External dependencies
68429   */
68430  
68431  
68432  /**
68433   * WordPress dependencies
68434   */
68435  
68436  
68437  
68438  
68439  
68440  
68441  
68442  /**
68443   * Internal dependencies
68444   */
68445  
68446  
68447  
68448  
68449  
68450  
68451  const media_placeholder_noop = () => {};
68452  const InsertFromURLPopover = ({
68453    src,
68454    onChange,
68455    onSubmit,
68456    onClose,
68457    popoverAnchor
68458  }) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(url_popover, {
68459    anchor: popoverAnchor,
68460    onClose: onClose,
68461    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("form", {
68462      className: "block-editor-media-placeholder__url-input-form",
68463      onSubmit: onSubmit,
68464      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalInputControl, {
68465        __next40pxDefaultSize: true,
68466        label: (0,external_wp_i18n_namespaceObject.__)('URL'),
68467        type: "url",
68468        hideLabelFromVision: true,
68469        placeholder: (0,external_wp_i18n_namespaceObject.__)('Paste or type URL'),
68470        onChange: onChange,
68471        value: src,
68472        suffix: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalInputControlSuffixWrapper, {
68473          variant: "control",
68474          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
68475            size: "small",
68476            icon: keyboard_return,
68477            label: (0,external_wp_i18n_namespaceObject.__)('Apply'),
68478            type: "submit"
68479          })
68480        })
68481      })
68482    })
68483  });
68484  const URLSelectionUI = ({
68485    src,
68486    onChangeSrc,
68487    onSelectURL
68488  }) => {
68489    // Use internal state instead of a ref to make sure that the component
68490    // re-renders when the popover's anchor updates.
68491    const [popoverAnchor, setPopoverAnchor] = (0,external_wp_element_namespaceObject.useState)(null);
68492    const [isURLInputVisible, setIsURLInputVisible] = (0,external_wp_element_namespaceObject.useState)(false);
68493    const openURLInput = () => {
68494      setIsURLInputVisible(true);
68495    };
68496    const closeURLInput = () => {
68497      setIsURLInputVisible(false);
68498      popoverAnchor?.focus();
68499    };
68500    const onSubmitSrc = event => {
68501      event.preventDefault();
68502      if (src && onSelectURL) {
68503        onSelectURL(src);
68504        closeURLInput();
68505      }
68506    };
68507    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
68508      className: "block-editor-media-placeholder__url-input-container",
68509      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
68510        __next40pxDefaultSize: true,
68511        className: "block-editor-media-placeholder__button",
68512        onClick: openURLInput,
68513        isPressed: isURLInputVisible,
68514        variant: "secondary",
68515        "aria-haspopup": "dialog",
68516        ref: setPopoverAnchor,
68517        children: (0,external_wp_i18n_namespaceObject.__)('Insert from URL')
68518      }), isURLInputVisible && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(InsertFromURLPopover, {
68519        src: src,
68520        onChange: onChangeSrc,
68521        onSubmit: onSubmitSrc,
68522        onClose: closeURLInput,
68523        popoverAnchor: popoverAnchor
68524      })]
68525    });
68526  };
68527  function MediaPlaceholder({
68528    value = {},
68529    allowedTypes,
68530    className,
68531    icon,
68532    labels = {},
68533    mediaPreview,
68534    notices,
68535    isAppender,
68536    accept,
68537    addToGallery,
68538    multiple = false,
68539    handleUpload = true,
68540    disableDropZone,
68541    disableMediaButtons,
68542    onError,
68543    onSelect,
68544    onCancel,
68545    onSelectURL,
68546    onToggleFeaturedImage,
68547    onDoubleClick,
68548    onFilesPreUpload = media_placeholder_noop,
68549    onHTMLDrop: deprecatedOnHTMLDrop,
68550    children,
68551    mediaLibraryButton,
68552    placeholder,
68553    style
68554  }) {
68555    if (deprecatedOnHTMLDrop) {
68556      external_wp_deprecated_default()('wp.blockEditor.MediaPlaceholder onHTMLDrop prop', {
68557        since: '6.2',
68558        version: '6.4'
68559      });
68560    }
68561    const mediaUpload = (0,external_wp_data_namespaceObject.useSelect)(select => {
68562      const {
68563        getSettings
68564      } = select(store);
68565      return getSettings().mediaUpload;
68566    }, []);
68567    const [src, setSrc] = (0,external_wp_element_namespaceObject.useState)('');
68568    (0,external_wp_element_namespaceObject.useEffect)(() => {
68569      var _value$src;
68570      setSrc((_value$src = value?.src) !== null && _value$src !== void 0 ? _value$src : '');
68571    }, [value?.src]);
68572    const onlyAllowsImages = () => {
68573      if (!allowedTypes || allowedTypes.length === 0) {
68574        return false;
68575      }
68576      return allowedTypes.every(allowedType => allowedType === 'image' || allowedType.startsWith('image/'));
68577    };
68578    const onFilesUpload = files => {
68579      if (!handleUpload || typeof handleUpload === 'function' && !handleUpload(files)) {
68580        return onSelect(files);
68581      }
68582      onFilesPreUpload(files);
68583      let setMedia;
68584      if (multiple) {
68585        if (addToGallery) {
68586          // Since the setMedia function runs multiple times per upload group
68587          // and is passed newMedia containing every item in its group each time, we must
68588          // filter out whatever this upload group had previously returned to the
68589          // gallery before adding and returning the image array with replacement newMedia
68590          // values.
68591  
68592          // Define an array to store urls from newMedia between subsequent function calls.
68593          let lastMediaPassed = [];
68594          setMedia = newMedia => {
68595            // Remove any images this upload group is responsible for (lastMediaPassed).
68596            // Their replacements are contained in newMedia.
68597            const filteredMedia = (value !== null && value !== void 0 ? value : []).filter(item => {
68598              // If Item has id, only remove it if lastMediaPassed has an item with that id.
68599              if (item.id) {
68600                return !lastMediaPassed.some(
68601                // Be sure to convert to number for comparison.
68602                ({
68603                  id
68604                }) => Number(id) === Number(item.id));
68605              }
68606              // Compare transient images via .includes since gallery may append extra info onto the url.
68607              return !lastMediaPassed.some(({
68608                urlSlug
68609              }) => item.url.includes(urlSlug));
68610            });
68611            // Return the filtered media array along with newMedia.
68612            onSelect(filteredMedia.concat(newMedia));
68613            // Reset lastMediaPassed and set it with ids and urls from newMedia.
68614            lastMediaPassed = newMedia.map(media => {
68615              // Add everything up to '.fileType' to compare via .includes.
68616              const cutOffIndex = media.url.lastIndexOf('.');
68617              const urlSlug = media.url.slice(0, cutOffIndex);
68618              return {
68619                id: media.id,
68620                urlSlug
68621              };
68622            });
68623          };
68624        } else {
68625          setMedia = onSelect;
68626        }
68627      } else {
68628        setMedia = ([media]) => onSelect(media);
68629      }
68630      mediaUpload({
68631        allowedTypes,
68632        filesList: files,
68633        onFileChange: setMedia,
68634        onError,
68635        multiple
68636      });
68637    };
68638    async function handleBlocksDrop(event) {
68639      const {
68640        blocks
68641      } = parseDropEvent(event);
68642      if (!blocks?.length) {
68643        return;
68644      }
68645      const uploadedMediaList = await Promise.all(blocks.map(block => {
68646        const blockType = block.name.split('/')[1];
68647        if (block.attributes.id) {
68648          block.attributes.type = blockType;
68649          return block.attributes;
68650        }
68651        return new Promise((resolve, reject) => {
68652          window.fetch(block.attributes.url).then(response => response.blob()).then(blob => mediaUpload({
68653            filesList: [blob],
68654            additionalData: {
68655              title: block.attributes.title,
68656              alt_text: block.attributes.alt,
68657              caption: block.attributes.caption,
68658              type: blockType
68659            },
68660            onFileChange: ([media]) => {
68661              if (media.id) {
68662                resolve(media);
68663              }
68664            },
68665            allowedTypes,
68666            onError: reject
68667          })).catch(() => resolve(block.attributes.url));
68668        });
68669      })).catch(err => onError(err));
68670      if (multiple) {
68671        onSelect(uploadedMediaList);
68672      } else {
68673        onSelect(uploadedMediaList[0]);
68674      }
68675    }
68676    const onUpload = event => {
68677      onFilesUpload(event.target.files);
68678    };
68679    const defaultRenderPlaceholder = content => {
68680      let {
68681        instructions,
68682        title
68683      } = labels;
68684      if (!mediaUpload && !onSelectURL) {
68685        instructions = (0,external_wp_i18n_namespaceObject.__)('To edit this block, you need permission to upload media.');
68686      }
68687      if (instructions === undefined || title === undefined) {
68688        const typesAllowed = allowedTypes !== null && allowedTypes !== void 0 ? allowedTypes : [];
68689        const [firstAllowedType] = typesAllowed;
68690        const isOneType = 1 === typesAllowed.length;
68691        const isAudio = isOneType && 'audio' === firstAllowedType;
68692        const isImage = isOneType && 'image' === firstAllowedType;
68693        const isVideo = isOneType && 'video' === firstAllowedType;
68694        if (instructions === undefined && mediaUpload) {
68695          instructions = (0,external_wp_i18n_namespaceObject.__)('Drag and drop an image or video, upload, or choose from your library.');
68696          if (isAudio) {
68697            instructions = (0,external_wp_i18n_namespaceObject.__)('Drag and drop an audio file, upload, or choose from your library.');
68698          } else if (isImage) {
68699            instructions = (0,external_wp_i18n_namespaceObject.__)('Drag and drop an image, upload, or choose from your library.');
68700          } else if (isVideo) {
68701            instructions = (0,external_wp_i18n_namespaceObject.__)('Drag and drop a video, upload, or choose from your library.');
68702          }
68703        }
68704        if (title === undefined) {
68705          title = (0,external_wp_i18n_namespaceObject.__)('Media');
68706          if (isAudio) {
68707            title = (0,external_wp_i18n_namespaceObject.__)('Audio');
68708          } else if (isImage) {
68709            title = (0,external_wp_i18n_namespaceObject.__)('Image');
68710          } else if (isVideo) {
68711            title = (0,external_wp_i18n_namespaceObject.__)('Video');
68712          }
68713        }
68714      }
68715      const placeholderClassName = dist_clsx('block-editor-media-placeholder', className, {
68716        'is-appender': isAppender
68717      });
68718      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.Placeholder, {
68719        icon: icon,
68720        label: title,
68721        instructions: instructions,
68722        className: placeholderClassName,
68723        notices: notices,
68724        onDoubleClick: onDoubleClick,
68725        preview: mediaPreview,
68726        style: style,
68727        children: [content, children]
68728      });
68729    };
68730    const renderPlaceholder = placeholder !== null && placeholder !== void 0 ? placeholder : defaultRenderPlaceholder;
68731    const renderDropZone = () => {
68732      if (disableDropZone) {
68733        return null;
68734      }
68735      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.DropZone, {
68736        onFilesDrop: onFilesUpload,
68737        onDrop: handleBlocksDrop,
68738        isEligible: dataTransfer => {
68739          const prefix = 'wp-block:core/';
68740          const types = [];
68741          for (const type of dataTransfer.types) {
68742            if (type.startsWith(prefix)) {
68743              types.push(type.slice(prefix.length));
68744            }
68745          }
68746          return types.every(type => allowedTypes.includes(type)) && (multiple ? true : types.length === 1);
68747        }
68748      });
68749    };
68750    const renderCancelLink = () => {
68751      return onCancel && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
68752        __next40pxDefaultSize: true,
68753        className: "block-editor-media-placeholder__cancel-button",
68754        title: (0,external_wp_i18n_namespaceObject.__)('Cancel'),
68755        variant: "link",
68756        onClick: onCancel,
68757        children: (0,external_wp_i18n_namespaceObject.__)('Cancel')
68758      });
68759    };
68760    const renderUrlSelectionUI = () => {
68761      return onSelectURL && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(URLSelectionUI, {
68762        src: src,
68763        onChangeSrc: setSrc,
68764        onSelectURL: onSelectURL
68765      });
68766    };
68767    const renderFeaturedImageToggle = () => {
68768      return onToggleFeaturedImage && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
68769        className: "block-editor-media-placeholder__url-input-container",
68770        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
68771          __next40pxDefaultSize: true,
68772          className: "block-editor-media-placeholder__button",
68773          onClick: onToggleFeaturedImage,
68774          variant: "secondary",
68775          children: (0,external_wp_i18n_namespaceObject.__)('Use featured image')
68776        })
68777      });
68778    };
68779    const renderMediaUploadChecked = () => {
68780      const defaultButton = ({
68781        open
68782      }) => {
68783        return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
68784          __next40pxDefaultSize: true,
68785          variant: "secondary",
68786          onClick: () => {
68787            open();
68788          },
68789          children: (0,external_wp_i18n_namespaceObject.__)('Media Library')
68790        });
68791      };
68792      const libraryButton = mediaLibraryButton !== null && mediaLibraryButton !== void 0 ? mediaLibraryButton : defaultButton;
68793      const uploadMediaLibraryButton = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(media_upload, {
68794        addToGallery: addToGallery,
68795        gallery: multiple && onlyAllowsImages(),
68796        multiple: multiple,
68797        onSelect: onSelect,
68798        allowedTypes: allowedTypes,
68799        mode: "browse",
68800        value: Array.isArray(value) ? value.map(({
68801          id
68802        }) => id) : value.id,
68803        render: libraryButton
68804      });
68805      if (mediaUpload && isAppender) {
68806        return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
68807          children: [renderDropZone(), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FormFileUpload, {
68808            onChange: onUpload,
68809            accept: accept,
68810            multiple: !!multiple,
68811            render: ({
68812              openFileDialog
68813            }) => {
68814              const content = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
68815                children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
68816                  __next40pxDefaultSize: true,
68817                  variant: "primary",
68818                  className: dist_clsx('block-editor-media-placeholder__button', 'block-editor-media-placeholder__upload-button'),
68819                  onClick: openFileDialog,
68820                  children: (0,external_wp_i18n_namespaceObject._x)('Upload', 'verb')
68821                }), uploadMediaLibraryButton, renderUrlSelectionUI(), renderFeaturedImageToggle(), renderCancelLink()]
68822              });
68823              return renderPlaceholder(content);
68824            }
68825          })]
68826        });
68827      }
68828      if (mediaUpload) {
68829        const content = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
68830          children: [renderDropZone(), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FormFileUpload, {
68831            render: ({
68832              openFileDialog
68833            }) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
68834              __next40pxDefaultSize: true,
68835              onClick: openFileDialog,
68836              variant: "primary",
68837              className: dist_clsx('block-editor-media-placeholder__button', 'block-editor-media-placeholder__upload-button'),
68838              children: (0,external_wp_i18n_namespaceObject._x)('Upload', 'verb')
68839            }),
68840            onChange: onUpload,
68841            accept: accept,
68842            multiple: !!multiple
68843          }), uploadMediaLibraryButton, renderUrlSelectionUI(), renderFeaturedImageToggle(), renderCancelLink()]
68844        });
68845        return renderPlaceholder(content);
68846      }
68847      return renderPlaceholder(uploadMediaLibraryButton);
68848    };
68849    if (disableMediaButtons) {
68850      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(check, {
68851        children: renderDropZone()
68852      });
68853    }
68854    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(check, {
68855      fallback: renderPlaceholder(renderUrlSelectionUI()),
68856      children: renderMediaUploadChecked()
68857    });
68858  }
68859  
68860  /**
68861   * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/media-placeholder/README.md
68862   */
68863  /* harmony default export */ const media_placeholder = ((0,external_wp_components_namespaceObject.withFilters)('editor.MediaPlaceholder')(MediaPlaceholder));
68864  
68865  ;// ./node_modules/@wordpress/block-editor/build-module/components/panel-color-settings/index.js
68866  /**
68867   * Internal dependencies
68868   */
68869  
68870  
68871  const PanelColorSettings = ({
68872    colorSettings,
68873    ...props
68874  }) => {
68875    const settings = colorSettings.map(setting => {
68876      if (!setting) {
68877        return setting;
68878      }
68879      const {
68880        value,
68881        onChange,
68882        ...otherSettings
68883      } = setting;
68884      return {
68885        ...otherSettings,
68886        colorValue: value,
68887        onColorChange: onChange
68888      };
68889    });
68890    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(panel_color_gradient_settings, {
68891      settings: settings,
68892      gradients: [],
68893      disableCustomGradients: true,
68894      ...props
68895    });
68896  };
68897  /* harmony default export */ const panel_color_settings = (PanelColorSettings);
68898  
68899  ;// ./node_modules/@wordpress/block-editor/build-module/components/rich-text/format-toolbar/index.js
68900  /**
68901   * External dependencies
68902   */
68903  
68904  
68905  /**
68906   * WordPress dependencies
68907   */
68908  
68909  
68910  
68911  
68912  /**
68913   * Internal dependencies
68914   */
68915  
68916  
68917  const format_toolbar_POPOVER_PROPS = {
68918    placement: 'bottom-start'
68919  };
68920  const FormatToolbar = () => {
68921    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
68922      children: [['bold', 'italic', 'link', 'unknown'].map(format => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Slot, {
68923        name: `RichText.ToolbarControls.$format}`
68924      }, format)), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Slot, {
68925        name: "RichText.ToolbarControls",
68926        children: fills => {
68927          if (!fills.length) {
68928            return null;
68929          }
68930          const allProps = fills.map(([{
68931            props
68932          }]) => props);
68933          const hasActive = allProps.some(({
68934            isActive
68935          }) => isActive);
68936          return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarItem, {
68937            children: toggleProps => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.DropdownMenu, {
68938              icon: chevron_down
68939              /* translators: button label text should, if possible, be under 16 characters. */,
68940              label: (0,external_wp_i18n_namespaceObject.__)('More'),
68941              toggleProps: {
68942                ...toggleProps,
68943                className: dist_clsx(toggleProps.className, {
68944                  'is-pressed': hasActive
68945                }),
68946                description: (0,external_wp_i18n_namespaceObject.__)('Displays more block tools')
68947              },
68948              controls: orderBy(fills.map(([{
68949                props
68950              }]) => props), 'title'),
68951              popoverProps: format_toolbar_POPOVER_PROPS
68952            })
68953          });
68954        }
68955      })]
68956    });
68957  };
68958  /* harmony default export */ const format_toolbar = (FormatToolbar);
68959  
68960  ;// ./node_modules/@wordpress/block-editor/build-module/components/rich-text/format-toolbar-container.js
68961  /**
68962   * WordPress dependencies
68963   */
68964  
68965  
68966  
68967  /**
68968   * Internal dependencies
68969   */
68970  
68971  
68972  
68973  
68974  function InlineToolbar({
68975    popoverAnchor
68976  }) {
68977    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Popover, {
68978      placement: "top",
68979      focusOnMount: false,
68980      anchor: popoverAnchor,
68981      className: "block-editor-rich-text__inline-format-toolbar",
68982      __unstableSlotName: "block-toolbar",
68983      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(NavigableToolbar, {
68984        className: "block-editor-rich-text__inline-format-toolbar-group"
68985        /* translators: accessibility text for the inline format toolbar */,
68986        "aria-label": (0,external_wp_i18n_namespaceObject.__)('Format tools'),
68987        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarGroup, {
68988          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(format_toolbar, {})
68989        })
68990      })
68991    });
68992  }
68993  const FormatToolbarContainer = ({
68994    inline,
68995    editableContentElement
68996  }) => {
68997    if (inline) {
68998      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(InlineToolbar, {
68999        popoverAnchor: editableContentElement
69000      });
69001    }
69002  
69003    // Render regular toolbar.
69004    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_controls, {
69005      group: "inline",
69006      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(format_toolbar, {})
69007    });
69008  };
69009  /* harmony default export */ const format_toolbar_container = (FormatToolbarContainer);
69010  
69011  ;// ./node_modules/@wordpress/block-editor/build-module/components/rich-text/use-mark-persistent.js
69012  /**
69013   * WordPress dependencies
69014   */
69015  
69016  
69017  
69018  /**
69019   * Internal dependencies
69020   */
69021  
69022  function useMarkPersistent({
69023    html,
69024    value
69025  }) {
69026    const previousTextRef = (0,external_wp_element_namespaceObject.useRef)();
69027    const hasActiveFormats = !!value.activeFormats?.length;
69028    const {
69029      __unstableMarkLastChangeAsPersistent
69030    } = (0,external_wp_data_namespaceObject.useDispatch)(store);
69031  
69032    // Must be set synchronously to make sure it applies to the last change.
69033    (0,external_wp_element_namespaceObject.useLayoutEffect)(() => {
69034      // Ignore mount.
69035      if (!previousTextRef.current) {
69036        previousTextRef.current = value.text;
69037        return;
69038      }
69039  
69040      // Text input, so don't create an undo level for every character.
69041      // Create an undo level after 1 second of no input.
69042      if (previousTextRef.current !== value.text) {
69043        const timeout = window.setTimeout(() => {
69044          __unstableMarkLastChangeAsPersistent();
69045        }, 1000);
69046        previousTextRef.current = value.text;
69047        return () => {
69048          window.clearTimeout(timeout);
69049        };
69050      }
69051      __unstableMarkLastChangeAsPersistent();
69052    }, [html, hasActiveFormats]);
69053  }
69054  
69055  ;// ./node_modules/@wordpress/block-editor/build-module/components/rich-text/use-format-types.js
69056  /**
69057   * WordPress dependencies
69058   */
69059  
69060  
69061  
69062  function formatTypesSelector(select) {
69063    return select(external_wp_richText_namespaceObject.store).getFormatTypes();
69064  }
69065  
69066  /**
69067   * Set of all interactive content tags.
69068   *
69069   * @see https://html.spec.whatwg.org/multipage/dom.html#interactive-content
69070   */
69071  const interactiveContentTags = new Set(['a', 'audio', 'button', 'details', 'embed', 'iframe', 'input', 'label', 'select', 'textarea', 'video']);
69072  function prefixSelectKeys(selected, prefix) {
69073    if (typeof selected !== 'object') {
69074      return {
69075        [prefix]: selected
69076      };
69077    }
69078    return Object.fromEntries(Object.entries(selected).map(([key, value]) => [`$prefix}.$key}`, value]));
69079  }
69080  function getPrefixedSelectKeys(selected, prefix) {
69081    if (selected[prefix]) {
69082      return selected[prefix];
69083    }
69084    return Object.keys(selected).filter(key => key.startsWith(prefix + '.')).reduce((accumulator, key) => {
69085      accumulator[key.slice(prefix.length + 1)] = selected[key];
69086      return accumulator;
69087    }, {});
69088  }
69089  
69090  /**
69091   * This hook provides RichText with the `formatTypes` and its derived props from
69092   * experimental format type settings.
69093   *
69094   * @param {Object}  $0                              Options
69095   * @param {string}  $0.clientId                     Block client ID.
69096   * @param {string}  $0.identifier                   Block attribute.
69097   * @param {boolean} $0.withoutInteractiveFormatting Whether to clean the interactive formatting or not.
69098   * @param {Array}   $0.allowedFormats               Allowed formats
69099   */
69100  function useFormatTypes({
69101    clientId,
69102    identifier,
69103    withoutInteractiveFormatting,
69104    allowedFormats
69105  }) {
69106    const allFormatTypes = (0,external_wp_data_namespaceObject.useSelect)(formatTypesSelector, []);
69107    const formatTypes = (0,external_wp_element_namespaceObject.useMemo)(() => {
69108      return allFormatTypes.filter(({
69109        name,
69110        interactive,
69111        tagName
69112      }) => {
69113        if (allowedFormats && !allowedFormats.includes(name)) {
69114          return false;
69115        }
69116        if (withoutInteractiveFormatting && (interactive || interactiveContentTags.has(tagName))) {
69117          return false;
69118        }
69119        return true;
69120      });
69121    }, [allFormatTypes, allowedFormats, withoutInteractiveFormatting]);
69122    const keyedSelected = (0,external_wp_data_namespaceObject.useSelect)(select => formatTypes.reduce((accumulator, type) => {
69123      if (!type.__experimentalGetPropsForEditableTreePreparation) {
69124        return accumulator;
69125      }
69126      return {
69127        ...accumulator,
69128        ...prefixSelectKeys(type.__experimentalGetPropsForEditableTreePreparation(select, {
69129          richTextIdentifier: identifier,
69130          blockClientId: clientId
69131        }), type.name)
69132      };
69133    }, {}), [formatTypes, clientId, identifier]);
69134    const dispatch = (0,external_wp_data_namespaceObject.useDispatch)();
69135    const prepareHandlers = [];
69136    const valueHandlers = [];
69137    const changeHandlers = [];
69138    const dependencies = [];
69139    for (const key in keyedSelected) {
69140      dependencies.push(keyedSelected[key]);
69141    }
69142    formatTypes.forEach(type => {
69143      if (type.__experimentalCreatePrepareEditableTree) {
69144        const handler = type.__experimentalCreatePrepareEditableTree(getPrefixedSelectKeys(keyedSelected, type.name), {
69145          richTextIdentifier: identifier,
69146          blockClientId: clientId
69147        });
69148        if (type.__experimentalCreateOnChangeEditableValue) {
69149          valueHandlers.push(handler);
69150        } else {
69151          prepareHandlers.push(handler);
69152        }
69153      }
69154      if (type.__experimentalCreateOnChangeEditableValue) {
69155        let dispatchers = {};
69156        if (type.__experimentalGetPropsForEditableTreeChangeHandler) {
69157          dispatchers = type.__experimentalGetPropsForEditableTreeChangeHandler(dispatch, {
69158            richTextIdentifier: identifier,
69159            blockClientId: clientId
69160          });
69161        }
69162        const selected = getPrefixedSelectKeys(keyedSelected, type.name);
69163        changeHandlers.push(type.__experimentalCreateOnChangeEditableValue({
69164          ...(typeof selected === 'object' ? selected : {}),
69165          ...dispatchers
69166        }, {
69167          richTextIdentifier: identifier,
69168          blockClientId: clientId
69169        }));
69170      }
69171    });
69172    return {
69173      formatTypes,
69174      prepareHandlers,
69175      valueHandlers,
69176      changeHandlers,
69177      dependencies
69178    };
69179  }
69180  
69181  ;// ./node_modules/@wordpress/block-editor/build-module/components/rich-text/event-listeners/before-input-rules.js
69182  /**
69183   * WordPress dependencies
69184   */
69185  
69186  
69187  
69188  /**
69189   * Internal dependencies
69190   */
69191  
69192  
69193  /**
69194   * When typing over a selection, the selection will we wrapped by a matching
69195   * character pair. The second character is optional, it defaults to the first
69196   * character.
69197   *
69198   * @type {string[]} Array of character pairs.
69199   */
69200  const wrapSelectionSettings = ['`', '"', "'", '“”', '‘’'];
69201  /* harmony default export */ const before_input_rules = (props => element => {
69202    function onInput(event) {
69203      const {
69204        inputType,
69205        data
69206      } = event;
69207      const {
69208        value,
69209        onChange,
69210        registry
69211      } = props.current;
69212  
69213      // Only run the rules when inserting text.
69214      if (inputType !== 'insertText') {
69215        return;
69216      }
69217      if ((0,external_wp_richText_namespaceObject.isCollapsed)(value)) {
69218        return;
69219      }
69220      const pair = (0,external_wp_hooks_namespaceObject.applyFilters)('blockEditor.wrapSelectionSettings', wrapSelectionSettings).find(([startChar, endChar]) => startChar === data || endChar === data);
69221      if (!pair) {
69222        return;
69223      }
69224      const [startChar, endChar = startChar] = pair;
69225      const start = value.start;
69226      const end = value.end + startChar.length;
69227      let newValue = (0,external_wp_richText_namespaceObject.insert)(value, startChar, start, start);
69228      newValue = (0,external_wp_richText_namespaceObject.insert)(newValue, endChar, end, end);
69229      const {
69230        __unstableMarkLastChangeAsPersistent,
69231        __unstableMarkAutomaticChange
69232      } = registry.dispatch(store);
69233      __unstableMarkLastChangeAsPersistent();
69234      onChange(newValue);
69235      __unstableMarkAutomaticChange();
69236      const init = {};
69237      for (const key in event) {
69238        init[key] = event[key];
69239      }
69240      init.data = endChar;
69241      const {
69242        ownerDocument
69243      } = element;
69244      const {
69245        defaultView
69246      } = ownerDocument;
69247      const newEvent = new defaultView.InputEvent('input', init);
69248  
69249      // Dispatch an `input` event with the new data. This will trigger the
69250      // input rules.
69251      // Postpone the `input` to the next event loop tick so that the dispatch
69252      // doesn't happen synchronously in the middle of `beforeinput` dispatch.
69253      // This is closer to how native `input` event would be timed, and also
69254      // makes sure that the `input` event is dispatched only after the `onChange`
69255      // call few lines above has fully updated the data store state and rerendered
69256      // all affected components.
69257      window.queueMicrotask(() => {
69258        event.target.dispatchEvent(newEvent);
69259      });
69260      event.preventDefault();
69261    }
69262    element.addEventListener('beforeinput', onInput);
69263    return () => {
69264      element.removeEventListener('beforeinput', onInput);
69265    };
69266  });
69267  
69268  ;// ./node_modules/@wordpress/block-editor/build-module/components/rich-text/prevent-event-discovery.js
69269  /**
69270   * WordPress dependencies
69271   */
69272  
69273  function preventEventDiscovery(value) {
69274    const searchText = 'tales of gutenberg';
69275    const addText = ' 🐡🐢🦀🐤🦋🐘🐧🐹🦁🦄🦍🐼🐿🎃🐴🐝🐆🦕🦔🌱🍇π🍌🐉💧🥨🌌🍂🍠🥦🥚🥝🎟🥥🥒🛵🥖🍒🍯🎾🎲🐺🐚🐮⌛️';
69276    const {
69277      start,
69278      text
69279    } = value;
69280    if (start < searchText.length) {
69281      return value;
69282    }
69283    const charactersBefore = text.slice(start - searchText.length, start);
69284    if (charactersBefore.toLowerCase() !== searchText) {
69285      return value;
69286    }
69287    return (0,external_wp_richText_namespaceObject.insert)(value, addText);
69288  }
69289  
69290  ;// ./node_modules/@wordpress/block-editor/build-module/components/rich-text/event-listeners/input-rules.js
69291  /**
69292   * WordPress dependencies
69293   */
69294  
69295  
69296  
69297  /**
69298   * Internal dependencies
69299   */
69300  
69301  
69302  
69303  function findSelection(blocks) {
69304    let i = blocks.length;
69305    while (i--) {
69306      const attributeKey = retrieveSelectedAttribute(blocks[i].attributes);
69307      if (attributeKey) {
69308        blocks[i].attributes[attributeKey] = blocks[i].attributes[attributeKey]
69309        // To do: refactor this to use rich text's selection instead, so
69310        // we no longer have to use on this hack inserting a special
69311        // character.
69312        .toString().replace(START_OF_SELECTED_AREA, '');
69313        return [blocks[i].clientId, attributeKey, 0, 0];
69314      }
69315      const nestedSelection = findSelection(blocks[i].innerBlocks);
69316      if (nestedSelection) {
69317        return nestedSelection;
69318      }
69319    }
69320    return [];
69321  }
69322  /* harmony default export */ const input_rules = (props => element => {
69323    function inputRule() {
69324      const {
69325        getValue,
69326        onReplace,
69327        selectionChange,
69328        registry
69329      } = props.current;
69330      if (!onReplace) {
69331        return;
69332      }
69333  
69334      // We must use getValue() here because value may be update
69335      // asynchronously.
69336      const value = getValue();
69337      const {
69338        start,
69339        text
69340      } = value;
69341      const characterBefore = text.slice(start - 1, start);
69342  
69343      // The character right before the caret must be a plain space.
69344      if (characterBefore !== ' ') {
69345        return;
69346      }
69347      const trimmedTextBefore = text.slice(0, start).trim();
69348      const prefixTransforms = (0,external_wp_blocks_namespaceObject.getBlockTransforms)('from').filter(({
69349        type
69350      }) => type === 'prefix');
69351      const transformation = (0,external_wp_blocks_namespaceObject.findTransform)(prefixTransforms, ({
69352        prefix
69353      }) => {
69354        return trimmedTextBefore === prefix;
69355      });
69356      if (!transformation) {
69357        return;
69358      }
69359      const content = (0,external_wp_richText_namespaceObject.toHTMLString)({
69360        value: (0,external_wp_richText_namespaceObject.insert)(value, START_OF_SELECTED_AREA, 0, start)
69361      });
69362      const block = transformation.transform(content);
69363      selectionChange(...findSelection([block]));
69364      onReplace([block]);
69365      registry.dispatch(store).__unstableMarkAutomaticChange();
69366      return true;
69367    }
69368    function onInput(event) {
69369      const {
69370        inputType,
69371        type
69372      } = event;
69373      const {
69374        getValue,
69375        onChange,
69376        __unstableAllowPrefixTransformations,
69377        formatTypes,
69378        registry
69379      } = props.current;
69380  
69381      // Only run input rules when inserting text.
69382      if (inputType !== 'insertText' && type !== 'compositionend') {
69383        return;
69384      }
69385      if (__unstableAllowPrefixTransformations && inputRule()) {
69386        return;
69387      }
69388      const value = getValue();
69389      const transformed = formatTypes.reduce((accumulator, {
69390        __unstableInputRule
69391      }) => {
69392        if (__unstableInputRule) {
69393          accumulator = __unstableInputRule(accumulator);
69394        }
69395        return accumulator;
69396      }, preventEventDiscovery(value));
69397      const {
69398        __unstableMarkLastChangeAsPersistent,
69399        __unstableMarkAutomaticChange
69400      } = registry.dispatch(store);
69401      if (transformed !== value) {
69402        __unstableMarkLastChangeAsPersistent();
69403        onChange({
69404          ...transformed,
69405          activeFormats: value.activeFormats
69406        });
69407        __unstableMarkAutomaticChange();
69408      }
69409    }
69410    element.addEventListener('input', onInput);
69411    element.addEventListener('compositionend', onInput);
69412    return () => {
69413      element.removeEventListener('input', onInput);
69414      element.removeEventListener('compositionend', onInput);
69415    };
69416  });
69417  
69418  ;// ./node_modules/@wordpress/block-editor/build-module/components/rich-text/event-listeners/insert-replacement-text.js
69419  /**
69420   * Internal dependencies
69421   */
69422  
69423  
69424  /**
69425   * When the browser is about to auto correct, add an undo level so the user can
69426   * revert the change.
69427   *
69428   * @param {Object} props
69429   */
69430  /* harmony default export */ const insert_replacement_text = (props => element => {
69431    function onInput(event) {
69432      if (event.inputType !== 'insertReplacementText') {
69433        return;
69434      }
69435      const {
69436        registry
69437      } = props.current;
69438      registry.dispatch(store).__unstableMarkLastChangeAsPersistent();
69439    }
69440    element.addEventListener('beforeinput', onInput);
69441    return () => {
69442      element.removeEventListener('beforeinput', onInput);
69443    };
69444  });
69445  
69446  ;// ./node_modules/@wordpress/block-editor/build-module/components/rich-text/event-listeners/remove-browser-shortcuts.js
69447  /**
69448   * WordPress dependencies
69449   */
69450  
69451  
69452  /**
69453   * Hook to prevent default behaviors for key combinations otherwise handled
69454   * internally by RichText.
69455   */
69456  /* harmony default export */ const remove_browser_shortcuts = (() => node => {
69457    function onKeydown(event) {
69458      if (external_wp_keycodes_namespaceObject.isKeyboardEvent.primary(event, 'z') || external_wp_keycodes_namespaceObject.isKeyboardEvent.primary(event, 'y') || external_wp_keycodes_namespaceObject.isKeyboardEvent.primaryShift(event, 'z')) {
69459        event.preventDefault();
69460      }
69461    }
69462    node.addEventListener('keydown', onKeydown);
69463    return () => {
69464      node.removeEventListener('keydown', onKeydown);
69465    };
69466  });
69467  
69468  ;// ./node_modules/@wordpress/block-editor/build-module/components/rich-text/event-listeners/shortcuts.js
69469  /* harmony default export */ const shortcuts = (props => element => {
69470    const {
69471      keyboardShortcuts
69472    } = props.current;
69473    function onKeyDown(event) {
69474      for (const keyboardShortcut of keyboardShortcuts.current) {
69475        keyboardShortcut(event);
69476      }
69477    }
69478    element.addEventListener('keydown', onKeyDown);
69479    return () => {
69480      element.removeEventListener('keydown', onKeyDown);
69481    };
69482  });
69483  
69484  ;// ./node_modules/@wordpress/block-editor/build-module/components/rich-text/event-listeners/input-events.js
69485  /* harmony default export */ const input_events = (props => element => {
69486    const {
69487      inputEvents
69488    } = props.current;
69489    function onInput(event) {
69490      for (const keyboardShortcut of inputEvents.current) {
69491        keyboardShortcut(event);
69492      }
69493    }
69494    element.addEventListener('input', onInput);
69495    return () => {
69496      element.removeEventListener('input', onInput);
69497    };
69498  });
69499  
69500  ;// ./node_modules/@wordpress/block-editor/build-module/components/rich-text/event-listeners/undo-automatic-change.js
69501  /**
69502   * WordPress dependencies
69503   */
69504  
69505  
69506  /**
69507   * Internal dependencies
69508   */
69509  
69510  /* harmony default export */ const undo_automatic_change = (props => element => {
69511    function onKeyDown(event) {
69512      const {
69513        keyCode
69514      } = event;
69515      if (event.defaultPrevented) {
69516        return;
69517      }
69518      if (keyCode !== external_wp_keycodes_namespaceObject.BACKSPACE && keyCode !== external_wp_keycodes_namespaceObject.ESCAPE) {
69519        return;
69520      }
69521      const {
69522        registry
69523      } = props.current;
69524      const {
69525        didAutomaticChange,
69526        getSettings
69527      } = registry.select(store);
69528      const {
69529        __experimentalUndo
69530      } = getSettings();
69531      if (!__experimentalUndo) {
69532        return;
69533      }
69534      if (!didAutomaticChange()) {
69535        return;
69536      }
69537      event.preventDefault();
69538      __experimentalUndo();
69539    }
69540    element.addEventListener('keydown', onKeyDown);
69541    return () => {
69542      element.removeEventListener('keydown', onKeyDown);
69543    };
69544  });
69545  
69546  ;// ./node_modules/@wordpress/block-editor/build-module/components/rich-text/utils.js
69547  /**
69548   * WordPress dependencies
69549   */
69550  
69551  
69552  
69553  function addActiveFormats(value, activeFormats) {
69554    if (activeFormats?.length) {
69555      let index = value.formats.length;
69556      while (index--) {
69557        value.formats[index] = [...activeFormats, ...(value.formats[index] || [])];
69558      }
69559    }
69560  }
69561  
69562  /**
69563   * Get the multiline tag based on the multiline prop.
69564   *
69565   * @param {?(string|boolean)} multiline The multiline prop.
69566   *
69567   * @return {string | undefined} The multiline tag.
69568   */
69569  function getMultilineTag(multiline) {
69570    if (multiline !== true && multiline !== 'p' && multiline !== 'li') {
69571      return;
69572    }
69573    return multiline === true ? 'p' : multiline;
69574  }
69575  function getAllowedFormats({
69576    allowedFormats,
69577    disableFormats
69578  }) {
69579    if (disableFormats) {
69580      return getAllowedFormats.EMPTY_ARRAY;
69581    }
69582    return allowedFormats;
69583  }
69584  getAllowedFormats.EMPTY_ARRAY = [];
69585  
69586  /**
69587   * Creates a link from pasted URL.
69588   * Creates a paragraph block containing a link to the URL, and calls `onReplace`.
69589   *
69590   * @param {string}   url       The URL that could not be embedded.
69591   * @param {Function} onReplace Function to call with the created fallback block.
69592   */
69593  function createLinkInParagraph(url, onReplace) {
69594    const link = /*#__PURE__*/_jsx("a", {
69595      href: url,
69596      children: url
69597    });
69598    onReplace(createBlock('core/paragraph', {
69599      content: renderToString(link)
69600    }));
69601  }
69602  
69603  ;// ./node_modules/@wordpress/block-editor/build-module/components/rich-text/event-listeners/paste-handler.js
69604  /**
69605   * WordPress dependencies
69606   */
69607  
69608  
69609  
69610  
69611  /**
69612   * Internal dependencies
69613   */
69614  
69615  
69616  
69617  /** @typedef {import('@wordpress/rich-text').RichTextValue} RichTextValue */
69618  
69619  /* harmony default export */ const paste_handler = (props => element => {
69620    function _onPaste(event) {
69621      const {
69622        disableFormats,
69623        onChange,
69624        value,
69625        formatTypes,
69626        tagName,
69627        onReplace,
69628        __unstableEmbedURLOnPaste,
69629        preserveWhiteSpace,
69630        pastePlainText
69631      } = props.current;
69632  
69633      // The event listener is attached to the window, so we need to check if
69634      // the target is the element or inside the element.
69635      if (!element.contains(event.target)) {
69636        return;
69637      }
69638      if (event.defaultPrevented) {
69639        return;
69640      }
69641      const {
69642        plainText,
69643        html
69644      } = getPasteEventData(event);
69645      event.preventDefault();
69646  
69647      // Allows us to ask for this information when we get a report.
69648      window.console.log('Received HTML:\n\n', html);
69649      window.console.log('Received plain text:\n\n', plainText);
69650      if (disableFormats) {
69651        onChange((0,external_wp_richText_namespaceObject.insert)(value, plainText));
69652        return;
69653      }
69654      const isInternal = event.clipboardData.getData('rich-text') === 'true';
69655      function pasteInline(content) {
69656        const transformed = formatTypes.reduce((accumulator, {
69657          __unstablePasteRule
69658        }) => {
69659          // Only allow one transform.
69660          if (__unstablePasteRule && accumulator === value) {
69661            accumulator = __unstablePasteRule(value, {
69662              html,
69663              plainText
69664            });
69665          }
69666          return accumulator;
69667        }, value);
69668        if (transformed !== value) {
69669          onChange(transformed);
69670        } else {
69671          const valueToInsert = (0,external_wp_richText_namespaceObject.create)({
69672            html: content
69673          });
69674          addActiveFormats(valueToInsert, value.activeFormats);
69675          onChange((0,external_wp_richText_namespaceObject.insert)(value, valueToInsert));
69676        }
69677      }
69678  
69679      // If the data comes from a rich text instance, we can directly use it
69680      // without filtering the data. The filters are only meant for externally
69681      // pasted content and remove inline styles.
69682      if (isInternal) {
69683        pasteInline(html);
69684        return;
69685      }
69686      if (pastePlainText) {
69687        onChange((0,external_wp_richText_namespaceObject.insert)(value, (0,external_wp_richText_namespaceObject.create)({
69688          text: plainText
69689        })));
69690        return;
69691      }
69692      let mode = 'INLINE';
69693      const trimmedPlainText = plainText.trim();
69694      if (__unstableEmbedURLOnPaste && (0,external_wp_richText_namespaceObject.isEmpty)(value) && (0,external_wp_url_namespaceObject.isURL)(trimmedPlainText) &&
69695      // For the link pasting feature, allow only http(s) protocols.
69696      /^https?:/.test(trimmedPlainText)) {
69697        mode = 'BLOCKS';
69698      }
69699      const content = (0,external_wp_blocks_namespaceObject.pasteHandler)({
69700        HTML: html,
69701        plainText,
69702        mode,
69703        tagName,
69704        preserveWhiteSpace
69705      });
69706      if (typeof content === 'string') {
69707        pasteInline(content);
69708      } else if (content.length > 0) {
69709        if (onReplace && (0,external_wp_richText_namespaceObject.isEmpty)(value)) {
69710          onReplace(content, content.length - 1, -1);
69711        }
69712      }
69713    }
69714    const {
69715      defaultView
69716    } = element.ownerDocument;
69717  
69718    // Attach the listener to the window so parent elements have the chance to
69719    // prevent the default behavior.
69720    defaultView.addEventListener('paste', _onPaste);
69721    return () => {
69722      defaultView.removeEventListener('paste', _onPaste);
69723    };
69724  });
69725  
69726  ;// ./node_modules/@wordpress/block-editor/build-module/components/rich-text/event-listeners/delete.js
69727  /**
69728   * WordPress dependencies
69729   */
69730  
69731  
69732  /* harmony default export */ const event_listeners_delete = (props => element => {
69733    function onKeyDown(event) {
69734      const {
69735        keyCode,
69736        shiftKey,
69737        ctrlKey,
69738        metaKey
69739      } = event;
69740      if (event.defaultPrevented) {
69741        return;
69742      }
69743      const {
69744        value,
69745        onMerge,
69746        onRemove
69747      } = props.current;
69748      if (keyCode === external_wp_keycodes_namespaceObject.DELETE || keyCode === external_wp_keycodes_namespaceObject.BACKSPACE) {
69749        const {
69750          start,
69751          end,
69752          text
69753        } = value;
69754        const isReverse = keyCode === external_wp_keycodes_namespaceObject.BACKSPACE;
69755        const hasActiveFormats = value.activeFormats && !!value.activeFormats.length;
69756  
69757        // Only process delete if the key press occurs at an uncollapsed edge.
69758        if (!(0,external_wp_richText_namespaceObject.isCollapsed)(value) || hasActiveFormats || isReverse && start !== 0 || !isReverse && end !== text.length) {
69759          return;
69760        }
69761  
69762        // Exclude (command|ctrl)+shift+backspace as they are shortcuts for deleting blocks.
69763        if (shiftKey && (ctrlKey || metaKey)) {
69764          return;
69765        }
69766        if (onMerge) {
69767          onMerge(!isReverse);
69768        }
69769  
69770        // Only handle remove on Backspace. This serves dual-purpose of being
69771        // an intentional user interaction distinguishing between Backspace and
69772        // Delete to remove the empty field, but also to avoid merge & remove
69773        // causing destruction of two fields (merge, then removed merged).
69774        else if (onRemove && (0,external_wp_richText_namespaceObject.isEmpty)(value) && isReverse) {
69775          onRemove(!isReverse);
69776        }
69777        event.preventDefault();
69778      }
69779    }
69780    element.addEventListener('keydown', onKeyDown);
69781    return () => {
69782      element.removeEventListener('keydown', onKeyDown);
69783    };
69784  });
69785  
69786  ;// ./node_modules/@wordpress/block-editor/build-module/components/rich-text/event-listeners/enter.js
69787  /**
69788   * WordPress dependencies
69789   */
69790  
69791  
69792  /* harmony default export */ const enter = (props => element => {
69793    function onKeyDownDeprecated(event) {
69794      if (event.keyCode !== external_wp_keycodes_namespaceObject.ENTER) {
69795        return;
69796      }
69797      const {
69798        onReplace,
69799        onSplit
69800      } = props.current;
69801      if (onReplace && onSplit) {
69802        event.__deprecatedOnSplit = true;
69803      }
69804    }
69805    function onKeyDown(event) {
69806      if (event.defaultPrevented) {
69807        return;
69808      }
69809  
69810      // The event listener is attached to the window, so we need to check if
69811      // the target is the element.
69812      if (event.target !== element) {
69813        return;
69814      }
69815      if (event.keyCode !== external_wp_keycodes_namespaceObject.ENTER) {
69816        return;
69817      }
69818      const {
69819        value,
69820        onChange,
69821        disableLineBreaks,
69822        onSplitAtEnd,
69823        onSplitAtDoubleLineEnd,
69824        registry
69825      } = props.current;
69826      event.preventDefault();
69827      const {
69828        text,
69829        start,
69830        end
69831      } = value;
69832      if (event.shiftKey) {
69833        if (!disableLineBreaks) {
69834          onChange((0,external_wp_richText_namespaceObject.insert)(value, '\n'));
69835        }
69836      } else if (onSplitAtEnd && start === end && end === text.length) {
69837        onSplitAtEnd();
69838      } else if (
69839      // For some blocks it's desirable to split at the end of the
69840      // block when there are two line breaks at the end of the
69841      // block, so triple Enter exits the block.
69842      onSplitAtDoubleLineEnd && start === end && end === text.length && text.slice(-2) === '\n\n') {
69843        registry.batch(() => {
69844          const _value = {
69845            ...value
69846          };
69847          _value.start = _value.end - 2;
69848          onChange((0,external_wp_richText_namespaceObject.remove)(_value));
69849          onSplitAtDoubleLineEnd();
69850        });
69851      } else if (!disableLineBreaks) {
69852        onChange((0,external_wp_richText_namespaceObject.insert)(value, '\n'));
69853      }
69854    }
69855    const {
69856      defaultView
69857    } = element.ownerDocument;
69858  
69859    // Attach the listener to the window so parent elements have the chance to
69860    // prevent the default behavior.
69861    defaultView.addEventListener('keydown', onKeyDown);
69862    element.addEventListener('keydown', onKeyDownDeprecated);
69863    return () => {
69864      defaultView.removeEventListener('keydown', onKeyDown);
69865      element.removeEventListener('keydown', onKeyDownDeprecated);
69866    };
69867  });
69868  
69869  ;// ./node_modules/@wordpress/block-editor/build-module/components/rich-text/event-listeners/firefox-compat.js
69870  /**
69871   * Internal dependencies
69872   */
69873  
69874  /* harmony default export */ const firefox_compat = (props => element => {
69875    function onFocus() {
69876      const {
69877        registry
69878      } = props.current;
69879      if (!registry.select(store).isMultiSelecting()) {
69880        return;
69881      }
69882  
69883      // This is a little hack to work around focus issues with nested
69884      // editable elements in Firefox. For some reason the editable child
69885      // element sometimes regains focus, while it should not be focusable
69886      // and focus should remain on the editable parent element.
69887      // To do: try to find the cause of the shifting focus.
69888      const parentEditable = element.parentElement.closest('[contenteditable="true"]');
69889      if (parentEditable) {
69890        parentEditable.focus();
69891      }
69892    }
69893    element.addEventListener('focus', onFocus);
69894    return () => {
69895      element.removeEventListener('focus', onFocus);
69896    };
69897  });
69898  
69899  ;// ./node_modules/@wordpress/block-editor/build-module/components/rich-text/event-listeners/index.js
69900  /**
69901   * WordPress dependencies
69902   */
69903  
69904  
69905  
69906  /**
69907   * Internal dependencies
69908   */
69909  
69910  
69911  
69912  
69913  
69914  
69915  
69916  
69917  
69918  
69919  
69920  const allEventListeners = [before_input_rules, input_rules, insert_replacement_text, remove_browser_shortcuts, shortcuts, input_events, undo_automatic_change, paste_handler, event_listeners_delete, enter, firefox_compat];
69921  function useEventListeners(props) {
69922    const propsRef = (0,external_wp_element_namespaceObject.useRef)(props);
69923    (0,external_wp_element_namespaceObject.useInsertionEffect)(() => {
69924      propsRef.current = props;
69925    });
69926    const refEffects = (0,external_wp_element_namespaceObject.useMemo)(() => allEventListeners.map(refEffect => refEffect(propsRef)), [propsRef]);
69927    return (0,external_wp_compose_namespaceObject.useRefEffect)(element => {
69928      if (!props.isSelected) {
69929        return;
69930      }
69931      const cleanups = refEffects.map(effect => effect(element));
69932      return () => {
69933        cleanups.forEach(cleanup => cleanup());
69934      };
69935    }, [refEffects, props.isSelected]);
69936  }
69937  
69938  ;// ./node_modules/@wordpress/block-editor/build-module/components/rich-text/format-edit.js
69939  /**
69940   * WordPress dependencies
69941   */
69942  
69943  
69944  
69945  /**
69946   * Internal dependencies
69947   */
69948  
69949  
69950  
69951  const format_edit_DEFAULT_BLOCK_CONTEXT = {};
69952  const usesContextKey = Symbol('usesContext');
69953  function format_edit_Edit({
69954    onChange,
69955    onFocus,
69956    value,
69957    forwardedRef,
69958    settings
69959  }) {
69960    const {
69961      name,
69962      edit: EditFunction,
69963      [usesContextKey]: usesContext
69964    } = settings;
69965    const blockContext = (0,external_wp_element_namespaceObject.useContext)(block_context);
69966  
69967    // Assign context values using the block type's declared context needs.
69968    const context = (0,external_wp_element_namespaceObject.useMemo)(() => {
69969      return usesContext ? Object.fromEntries(Object.entries(blockContext).filter(([key]) => usesContext.includes(key))) : format_edit_DEFAULT_BLOCK_CONTEXT;
69970    }, [usesContext, blockContext]);
69971    if (!EditFunction) {
69972      return null;
69973    }
69974    const activeFormat = (0,external_wp_richText_namespaceObject.getActiveFormat)(value, name);
69975    const isActive = activeFormat !== undefined;
69976    const activeObject = (0,external_wp_richText_namespaceObject.getActiveObject)(value);
69977    const isObjectActive = activeObject !== undefined && activeObject.type === name;
69978    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(EditFunction, {
69979      isActive: isActive,
69980      activeAttributes: isActive ? activeFormat.attributes || {} : {},
69981      isObjectActive: isObjectActive,
69982      activeObjectAttributes: isObjectActive ? activeObject.attributes || {} : {},
69983      value: value,
69984      onChange: onChange,
69985      onFocus: onFocus,
69986      contentRef: forwardedRef,
69987      context: context
69988    }, name);
69989  }
69990  function FormatEdit({
69991    formatTypes,
69992    ...props
69993  }) {
69994    return formatTypes.map(settings => /*#__PURE__*/(0,external_React_.createElement)(format_edit_Edit, {
69995      settings: settings,
69996      ...props,
69997      key: settings.name
69998    }));
69999  }
70000  
70001  ;// ./node_modules/@wordpress/block-editor/build-module/components/rich-text/content.js
70002  /**
70003   * WordPress dependencies
70004   */
70005  
70006  
70007  
70008  
70009  /**
70010   * Internal dependencies
70011   */
70012  
70013  
70014  /**
70015   * Internal dependencies
70016   */
70017  
70018  
70019  function valueToHTMLString(value, multiline) {
70020    if (rich_text.isEmpty(value)) {
70021      const multilineTag = getMultilineTag(multiline);
70022      return multilineTag ? `<$multilineTag}></$multilineTag}>` : '';
70023    }
70024    if (Array.isArray(value)) {
70025      external_wp_deprecated_default()('wp.blockEditor.RichText value prop as children type', {
70026        since: '6.1',
70027        version: '6.3',
70028        alternative: 'value prop as string',
70029        link: 'https://developer.wordpress.org/block-editor/how-to-guides/block-tutorial/introducing-attributes-and-editable-fields/'
70030      });
70031      return external_wp_blocks_namespaceObject.children.toHTML(value);
70032    }
70033  
70034    // To do: deprecate string type.
70035    if (typeof value === 'string') {
70036      return value;
70037    }
70038  
70039    // To do: create a toReactComponent method on RichTextData, which we
70040    // might in the future also use for the editable tree. See
70041    // https://github.com/WordPress/gutenberg/pull/41655.
70042    return value.toHTMLString();
70043  }
70044  function Content({
70045    value,
70046    tagName: Tag,
70047    multiline,
70048    format,
70049    ...props
70050  }) {
70051    value = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_element_namespaceObject.RawHTML, {
70052      children: valueToHTMLString(value, multiline)
70053    });
70054    return Tag ? /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Tag, {
70055      ...props,
70056      children: value
70057    }) : value;
70058  }
70059  
70060  ;// ./node_modules/@wordpress/block-editor/build-module/components/rich-text/multiline.js
70061  /**
70062   * WordPress dependencies
70063   */
70064  
70065  
70066  
70067  
70068  
70069  
70070  /**
70071   * Internal dependencies
70072   */
70073  
70074  
70075  
70076  
70077  
70078  function RichTextMultiline({
70079    children,
70080    identifier,
70081    tagName: TagName = 'div',
70082    value = '',
70083    onChange,
70084    multiline,
70085    ...props
70086  }, forwardedRef) {
70087    external_wp_deprecated_default()('wp.blockEditor.RichText multiline prop', {
70088      since: '6.1',
70089      version: '6.3',
70090      alternative: 'nested blocks (InnerBlocks)',
70091      link: 'https://developer.wordpress.org/block-editor/how-to-guides/block-tutorial/nested-blocks-inner-blocks/'
70092    });
70093    const {
70094      clientId
70095    } = useBlockEditContext();
70096    const {
70097      getSelectionStart,
70098      getSelectionEnd
70099    } = (0,external_wp_data_namespaceObject.useSelect)(store);
70100    const {
70101      selectionChange
70102    } = (0,external_wp_data_namespaceObject.useDispatch)(store);
70103    const multilineTagName = getMultilineTag(multiline);
70104    value = value || `<$multilineTagName}></$multilineTagName}>`;
70105    const padded = `</$multilineTagName}>$value}<$multilineTagName}>`;
70106    const values = padded.split(`</$multilineTagName}><$multilineTagName}>`);
70107    values.shift();
70108    values.pop();
70109    function _onChange(newValues) {
70110      onChange(`<$multilineTagName}>$newValues.join(`</$multilineTagName}><$multilineTagName}>`)}</$multilineTagName}>`);
70111    }
70112    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(TagName, {
70113      ref: forwardedRef,
70114      children: values.map((_value, index) => {
70115        return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(RichTextWrapper, {
70116          identifier: `$identifier}-$index}`,
70117          tagName: multilineTagName,
70118          value: _value,
70119          onChange: newValue => {
70120            const newValues = values.slice();
70121            newValues[index] = newValue;
70122            _onChange(newValues);
70123          },
70124          isSelected: undefined,
70125          onKeyDown: event => {
70126            if (event.keyCode !== external_wp_keycodes_namespaceObject.ENTER) {
70127              return;
70128            }
70129            event.preventDefault();
70130            const {
70131              offset: start
70132            } = getSelectionStart();
70133            const {
70134              offset: end
70135            } = getSelectionEnd();
70136  
70137            // Cannot split if there is no selection.
70138            if (typeof start !== 'number' || typeof end !== 'number') {
70139              return;
70140            }
70141            const richTextValue = (0,external_wp_richText_namespaceObject.create)({
70142              html: _value
70143            });
70144            richTextValue.start = start;
70145            richTextValue.end = end;
70146            const array = (0,external_wp_richText_namespaceObject.split)(richTextValue).map(v => (0,external_wp_richText_namespaceObject.toHTMLString)({
70147              value: v
70148            }));
70149            const newValues = values.slice();
70150            newValues.splice(index, 1, ...array);
70151            _onChange(newValues);
70152            selectionChange(clientId, `$identifier}-$index + 1}`, 0, 0);
70153          },
70154          onMerge: forward => {
70155            const newValues = values.slice();
70156            let offset = 0;
70157            if (forward) {
70158              if (!newValues[index + 1]) {
70159                return;
70160              }
70161              newValues.splice(index, 2, newValues[index] + newValues[index + 1]);
70162              offset = newValues[index].length - 1;
70163            } else {
70164              if (!newValues[index - 1]) {
70165                return;
70166              }
70167              newValues.splice(index - 1, 2, newValues[index - 1] + newValues[index]);
70168              offset = newValues[index - 1].length - 1;
70169            }
70170            _onChange(newValues);
70171            selectionChange(clientId, `$identifier}-$index - (forward ? 0 : 1)}`, offset, offset);
70172          },
70173          ...props
70174        }, index);
70175      })
70176    });
70177  }
70178  /* harmony default export */ const multiline = ((0,external_wp_element_namespaceObject.forwardRef)(RichTextMultiline));
70179  
70180  ;// ./node_modules/@wordpress/block-editor/build-module/components/rich-text/with-deprecations.js
70181  /**
70182   * WordPress dependencies
70183   */
70184  
70185  
70186  
70187  
70188  
70189  /**
70190   * Internal dependencies
70191   */
70192  
70193  
70194  function withDeprecations(Component) {
70195    return (0,external_wp_element_namespaceObject.forwardRef)((props, ref) => {
70196      let value = props.value;
70197      let onChange = props.onChange;
70198  
70199      // Handle deprecated format.
70200      if (Array.isArray(value)) {
70201        external_wp_deprecated_default()('wp.blockEditor.RichText value prop as children type', {
70202          since: '6.1',
70203          version: '6.3',
70204          alternative: 'value prop as string',
70205          link: 'https://developer.wordpress.org/block-editor/how-to-guides/block-tutorial/introducing-attributes-and-editable-fields/'
70206        });
70207        value = external_wp_blocks_namespaceObject.children.toHTML(props.value);
70208        onChange = newValue => props.onChange(external_wp_blocks_namespaceObject.children.fromDOM((0,external_wp_richText_namespaceObject.__unstableCreateElement)(document, newValue).childNodes));
70209      }
70210      const NewComponent = props.multiline ? multiline : Component;
70211      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(NewComponent, {
70212        ...props,
70213        value: value,
70214        onChange: onChange,
70215        ref: ref
70216      });
70217    });
70218  }
70219  
70220  ;// ./node_modules/@wordpress/block-editor/build-module/components/rich-text/index.js
70221  /**
70222   * External dependencies
70223   */
70224  
70225  
70226  /**
70227   * WordPress dependencies
70228   */
70229  
70230  
70231  
70232  
70233  
70234  
70235  
70236  
70237  
70238  /**
70239   * Internal dependencies
70240   */
70241  
70242  
70243  
70244  
70245  
70246  
70247  
70248  
70249  
70250  
70251  
70252  
70253  
70254  
70255  
70256  const keyboardShortcutContext = (0,external_wp_element_namespaceObject.createContext)();
70257  const inputEventContext = (0,external_wp_element_namespaceObject.createContext)();
70258  const instanceIdKey = Symbol('instanceId');
70259  
70260  /**
70261   * Removes props used for the native version of RichText so that they are not
70262   * passed to the DOM element and log warnings.
70263   *
70264   * @param {Object} props Props to filter.
70265   *
70266   * @return {Object} Filtered props.
70267   */
70268  function removeNativeProps(props) {
70269    const {
70270      __unstableMobileNoFocusOnMount,
70271      deleteEnter,
70272      placeholderTextColor,
70273      textAlign,
70274      selectionColor,
70275      tagsToEliminate,
70276      disableEditingMenu,
70277      fontSize,
70278      fontFamily,
70279      fontWeight,
70280      fontStyle,
70281      minWidth,
70282      maxWidth,
70283      disableSuggestions,
70284      disableAutocorrection,
70285      ...restProps
70286    } = props;
70287    return restProps;
70288  }
70289  function RichTextWrapper({
70290    children,
70291    tagName = 'div',
70292    value: adjustedValue = '',
70293    onChange: adjustedOnChange,
70294    isSelected: originalIsSelected,
70295    multiline,
70296    inlineToolbar,
70297    wrapperClassName,
70298    autocompleters,
70299    onReplace,
70300    placeholder,
70301    allowedFormats,
70302    withoutInteractiveFormatting,
70303    onRemove,
70304    onMerge,
70305    onSplit,
70306    __unstableOnSplitAtEnd: onSplitAtEnd,
70307    __unstableOnSplitAtDoubleLineEnd: onSplitAtDoubleLineEnd,
70308    identifier,
70309    preserveWhiteSpace,
70310    __unstablePastePlainText: pastePlainText,
70311    __unstableEmbedURLOnPaste,
70312    __unstableDisableFormats: disableFormats,
70313    disableLineBreaks,
70314    __unstableAllowPrefixTransformations,
70315    readOnly,
70316    ...props
70317  }, forwardedRef) {
70318    props = removeNativeProps(props);
70319    if (onSplit) {
70320      external_wp_deprecated_default()('wp.blockEditor.RichText onSplit prop', {
70321        since: '6.4',
70322        alternative: 'block.json support key: "splitting"'
70323      });
70324    }
70325    const instanceId = (0,external_wp_compose_namespaceObject.useInstanceId)(RichTextWrapper);
70326    const anchorRef = (0,external_wp_element_namespaceObject.useRef)();
70327    const context = useBlockEditContext();
70328    const {
70329      clientId,
70330      isSelected: isBlockSelected,
70331      name: blockName
70332    } = context;
70333    const blockBindings = context[blockBindingsKey];
70334    const blockContext = (0,external_wp_element_namespaceObject.useContext)(block_context);
70335    const registry = (0,external_wp_data_namespaceObject.useRegistry)();
70336    const selector = select => {
70337      // Avoid subscribing to the block editor store if the block is not
70338      // selected.
70339      if (!isBlockSelected) {
70340        return {
70341          isSelected: false
70342        };
70343      }
70344      const {
70345        getSelectionStart,
70346        getSelectionEnd
70347      } = select(store);
70348      const selectionStart = getSelectionStart();
70349      const selectionEnd = getSelectionEnd();
70350      let isSelected;
70351      if (originalIsSelected === undefined) {
70352        isSelected = selectionStart.clientId === clientId && selectionEnd.clientId === clientId && (identifier ? selectionStart.attributeKey === identifier : selectionStart[instanceIdKey] === instanceId);
70353      } else if (originalIsSelected) {
70354        isSelected = selectionStart.clientId === clientId;
70355      }
70356      return {
70357        selectionStart: isSelected ? selectionStart.offset : undefined,
70358        selectionEnd: isSelected ? selectionEnd.offset : undefined,
70359        isSelected
70360      };
70361    };
70362    const {
70363      selectionStart,
70364      selectionEnd,
70365      isSelected
70366    } = (0,external_wp_data_namespaceObject.useSelect)(selector, [clientId, identifier, instanceId, originalIsSelected, isBlockSelected]);
70367    const {
70368      disableBoundBlock,
70369      bindingsPlaceholder,
70370      bindingsLabel
70371    } = (0,external_wp_data_namespaceObject.useSelect)(select => {
70372      var _fieldsList$relatedBi;
70373      if (!blockBindings?.[identifier] || !canBindBlock(blockName)) {
70374        return {};
70375      }
70376      const relatedBinding = blockBindings[identifier];
70377      const blockBindingsSource = (0,external_wp_blocks_namespaceObject.getBlockBindingsSource)(relatedBinding.source);
70378      const blockBindingsContext = {};
70379      if (blockBindingsSource?.usesContext?.length) {
70380        for (const key of blockBindingsSource.usesContext) {
70381          blockBindingsContext[key] = blockContext[key];
70382        }
70383      }
70384      const _disableBoundBlock = !blockBindingsSource?.canUserEditValue?.({
70385        select,
70386        context: blockBindingsContext,
70387        args: relatedBinding.args
70388      });
70389  
70390      // Don't modify placeholders if value is not empty.
70391      if (adjustedValue.length > 0) {
70392        return {
70393          disableBoundBlock: _disableBoundBlock,
70394          // Null values will make them fall back to the default behavior.
70395          bindingsPlaceholder: null,
70396          bindingsLabel: null
70397        };
70398      }
70399      const {
70400        getBlockAttributes
70401      } = select(store);
70402      const blockAttributes = getBlockAttributes(clientId);
70403      const fieldsList = blockBindingsSource?.getFieldsList?.({
70404        select,
70405        context: blockBindingsContext
70406      });
70407      const bindingKey = (_fieldsList$relatedBi = fieldsList?.[relatedBinding?.args?.key]?.label) !== null && _fieldsList$relatedBi !== void 0 ? _fieldsList$relatedBi : blockBindingsSource?.label;
70408      const _bindingsPlaceholder = _disableBoundBlock ? bindingKey : (0,external_wp_i18n_namespaceObject.sprintf)(/* translators: %s: connected field label or source label */
70409      (0,external_wp_i18n_namespaceObject.__)('Add %s'), bindingKey);
70410      const _bindingsLabel = _disableBoundBlock ? relatedBinding?.args?.key || blockBindingsSource?.label : (0,external_wp_i18n_namespaceObject.sprintf)(/* translators: %s: source label or key */
70411      (0,external_wp_i18n_namespaceObject.__)('Empty %s; start writing to edit its value'), relatedBinding?.args?.key || blockBindingsSource?.label);
70412      return {
70413        disableBoundBlock: _disableBoundBlock,
70414        bindingsPlaceholder: blockAttributes?.placeholder || _bindingsPlaceholder,
70415        bindingsLabel: _bindingsLabel
70416      };
70417    }, [blockBindings, identifier, blockName, adjustedValue, clientId, blockContext]);
70418    const shouldDisableEditing = readOnly || disableBoundBlock;
70419    const {
70420      getSelectionStart,
70421      getSelectionEnd,
70422      getBlockRootClientId
70423    } = (0,external_wp_data_namespaceObject.useSelect)(store);
70424    const {
70425      selectionChange
70426    } = (0,external_wp_data_namespaceObject.useDispatch)(store);
70427    const adjustedAllowedFormats = getAllowedFormats({
70428      allowedFormats,
70429      disableFormats
70430    });
70431    const hasFormats = !adjustedAllowedFormats || adjustedAllowedFormats.length > 0;
70432    const onSelectionChange = (0,external_wp_element_namespaceObject.useCallback)((start, end) => {
70433      const selection = {};
70434      const unset = start === undefined && end === undefined;
70435      const baseSelection = {
70436        clientId,
70437        [identifier ? 'attributeKey' : instanceIdKey]: identifier ? identifier : instanceId
70438      };
70439      if (typeof start === 'number' || unset) {
70440        // If we are only setting the start (or the end below), which
70441        // means a partial selection, and we're not updating a selection
70442        // with the same client ID, abort. This means the selected block
70443        // is a parent block.
70444        if (end === undefined && getBlockRootClientId(clientId) !== getBlockRootClientId(getSelectionEnd().clientId)) {
70445          return;
70446        }
70447        selection.start = {
70448          ...baseSelection,
70449          offset: start
70450        };
70451      }
70452      if (typeof end === 'number' || unset) {
70453        if (start === undefined && getBlockRootClientId(clientId) !== getBlockRootClientId(getSelectionStart().clientId)) {
70454          return;
70455        }
70456        selection.end = {
70457          ...baseSelection,
70458          offset: end
70459        };
70460      }
70461      selectionChange(selection);
70462    }, [clientId, getBlockRootClientId, getSelectionEnd, getSelectionStart, identifier, instanceId, selectionChange]);
70463    const {
70464      formatTypes,
70465      prepareHandlers,
70466      valueHandlers,
70467      changeHandlers,
70468      dependencies
70469    } = useFormatTypes({
70470      clientId,
70471      identifier,
70472      withoutInteractiveFormatting,
70473      allowedFormats: adjustedAllowedFormats
70474    });
70475    function addEditorOnlyFormats(value) {
70476      return valueHandlers.reduce((accumulator, fn) => fn(accumulator, value.text), value.formats);
70477    }
70478    function removeEditorOnlyFormats(value) {
70479      formatTypes.forEach(formatType => {
70480        // Remove formats created by prepareEditableTree, because they are editor only.
70481        if (formatType.__experimentalCreatePrepareEditableTree) {
70482          value = (0,external_wp_richText_namespaceObject.removeFormat)(value, formatType.name, 0, value.text.length);
70483        }
70484      });
70485      return value.formats;
70486    }
70487    function addInvisibleFormats(value) {
70488      return prepareHandlers.reduce((accumulator, fn) => fn(accumulator, value.text), value.formats);
70489    }
70490    const {
70491      value,
70492      getValue,
70493      onChange,
70494      ref: richTextRef
70495    } = (0,external_wp_richText_namespaceObject.__unstableUseRichText)({
70496      value: adjustedValue,
70497      onChange(html, {
70498        __unstableFormats,
70499        __unstableText
70500      }) {
70501        adjustedOnChange(html);
70502        Object.values(changeHandlers).forEach(changeHandler => {
70503          changeHandler(__unstableFormats, __unstableText);
70504        });
70505      },
70506      selectionStart,
70507      selectionEnd,
70508      onSelectionChange,
70509      placeholder: bindingsPlaceholder || placeholder,
70510      __unstableIsSelected: isSelected,
70511      __unstableDisableFormats: disableFormats,
70512      preserveWhiteSpace,
70513      __unstableDependencies: [...dependencies, tagName],
70514      __unstableAfterParse: addEditorOnlyFormats,
70515      __unstableBeforeSerialize: removeEditorOnlyFormats,
70516      __unstableAddInvisibleFormats: addInvisibleFormats
70517    });
70518    const autocompleteProps = useBlockEditorAutocompleteProps({
70519      onReplace,
70520      completers: autocompleters,
70521      record: value,
70522      onChange
70523    });
70524    useMarkPersistent({
70525      html: adjustedValue,
70526      value
70527    });
70528    const keyboardShortcuts = (0,external_wp_element_namespaceObject.useRef)(new Set());
70529    const inputEvents = (0,external_wp_element_namespaceObject.useRef)(new Set());
70530    function onFocus() {
70531      anchorRef.current?.focus();
70532    }
70533    const TagName = tagName;
70534    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
70535      children: [isSelected && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(keyboardShortcutContext.Provider, {
70536        value: keyboardShortcuts,
70537        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inputEventContext.Provider, {
70538          value: inputEvents,
70539          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.Popover.__unstableSlotNameProvider, {
70540            value: "__unstable-block-tools-after",
70541            children: [children && children({
70542              value,
70543              onChange,
70544              onFocus
70545            }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(FormatEdit, {
70546              value: value,
70547              onChange: onChange,
70548              onFocus: onFocus,
70549              formatTypes: formatTypes,
70550              forwardedRef: anchorRef
70551            })]
70552          })
70553        })
70554      }), isSelected && hasFormats && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(format_toolbar_container, {
70555        inline: inlineToolbar,
70556        editableContentElement: anchorRef.current
70557      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(TagName
70558      // Overridable props.
70559      , {
70560        role: "textbox",
70561        "aria-multiline": !disableLineBreaks,
70562        "aria-readonly": shouldDisableEditing,
70563        ...props,
70564        // Unset draggable (coming from block props) for contentEditable
70565        // elements because it will interfere with multi block selection
70566        // when the contentEditable and draggable elements are the same
70567        // element.
70568        draggable: undefined,
70569        "aria-label": bindingsLabel || props['aria-label'] || placeholder,
70570        ...autocompleteProps,
70571        ref: (0,external_wp_compose_namespaceObject.useMergeRefs)([
70572        // Rich text ref must be first because its focus listener
70573        // must be set up before any other ref calls .focus() on
70574        // mount.
70575        richTextRef, forwardedRef, autocompleteProps.ref, props.ref, useEventListeners({
70576          registry,
70577          getValue,
70578          onChange,
70579          __unstableAllowPrefixTransformations,
70580          formatTypes,
70581          onReplace,
70582          selectionChange,
70583          isSelected,
70584          disableFormats,
70585          value,
70586          tagName,
70587          onSplit,
70588          __unstableEmbedURLOnPaste,
70589          pastePlainText,
70590          onMerge,
70591          onRemove,
70592          removeEditorOnlyFormats,
70593          disableLineBreaks,
70594          onSplitAtEnd,
70595          onSplitAtDoubleLineEnd,
70596          keyboardShortcuts,
70597          inputEvents
70598        }), anchorRef]),
70599        contentEditable: !shouldDisableEditing,
70600        suppressContentEditableWarning: true,
70601        className: dist_clsx('block-editor-rich-text__editable', props.className, 'rich-text')
70602        // Setting tabIndex to 0 is unnecessary, the element is already
70603        // focusable because it's contentEditable. This also fixes a
70604        // Safari bug where it's not possible to Shift+Click multi
70605        // select blocks when Shift Clicking into an element with
70606        // tabIndex because Safari will focus the element. However,
70607        // Safari will correctly ignore nested contentEditable elements.
70608        ,
70609        tabIndex: props.tabIndex === 0 && !shouldDisableEditing ? null : props.tabIndex,
70610        "data-wp-block-attribute-key": identifier
70611      })]
70612    });
70613  }
70614  
70615  // This is the private API for the RichText component.
70616  // It allows access to all props, not just the public ones.
70617  const PrivateRichText = withDeprecations((0,external_wp_element_namespaceObject.forwardRef)(RichTextWrapper));
70618  PrivateRichText.Content = Content;
70619  PrivateRichText.isEmpty = value => {
70620    return !value || value.length === 0;
70621  };
70622  
70623  // This is the public API for the RichText component.
70624  // We wrap the PrivateRichText component to hide some props from the public API.
70625  /**
70626   * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/rich-text/README.md
70627   */
70628  const PublicForwardedRichTextContainer = (0,external_wp_element_namespaceObject.forwardRef)((props, ref) => {
70629    const context = useBlockEditContext();
70630    const isPreviewMode = context[isPreviewModeKey];
70631    if (isPreviewMode) {
70632      // Remove all non-content props.
70633      const {
70634        children,
70635        tagName: Tag = 'div',
70636        value,
70637        onChange,
70638        isSelected,
70639        multiline,
70640        inlineToolbar,
70641        wrapperClassName,
70642        autocompleters,
70643        onReplace,
70644        placeholder,
70645        allowedFormats,
70646        withoutInteractiveFormatting,
70647        onRemove,
70648        onMerge,
70649        onSplit,
70650        __unstableOnSplitAtEnd,
70651        __unstableOnSplitAtDoubleLineEnd,
70652        identifier,
70653        preserveWhiteSpace,
70654        __unstablePastePlainText,
70655        __unstableEmbedURLOnPaste,
70656        __unstableDisableFormats,
70657        disableLineBreaks,
70658        __unstableAllowPrefixTransformations,
70659        readOnly,
70660        ...contentProps
70661      } = removeNativeProps(props);
70662      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Tag, {
70663        ...contentProps,
70664        dangerouslySetInnerHTML: {
70665          __html: valueToHTMLString(value, multiline)
70666        }
70667      });
70668    }
70669    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PrivateRichText, {
70670      ref: ref,
70671      ...props,
70672      readOnly: false
70673    });
70674  });
70675  PublicForwardedRichTextContainer.Content = Content;
70676  PublicForwardedRichTextContainer.isEmpty = value => {
70677    return !value || value.length === 0;
70678  };
70679  /* harmony default export */ const rich_text = (PublicForwardedRichTextContainer);
70680  
70681  
70682  
70683  
70684  ;// ./node_modules/@wordpress/block-editor/build-module/components/editable-text/index.js
70685  /**
70686   * WordPress dependencies
70687   */
70688  
70689  
70690  /**
70691   * Internal dependencies
70692   */
70693  
70694  
70695  const EditableText = (0,external_wp_element_namespaceObject.forwardRef)((props, ref) => {
70696    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(rich_text, {
70697      ref: ref,
70698      ...props,
70699      __unstableDisableFormats: true
70700    });
70701  });
70702  EditableText.Content = ({
70703    value = '',
70704    tagName: Tag = 'div',
70705    ...props
70706  }) => {
70707    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Tag, {
70708      ...props,
70709      children: value
70710    });
70711  };
70712  
70713  /**
70714   * Renders an editable text input in which text formatting is not allowed.
70715   */
70716  /* harmony default export */ const editable_text = (EditableText);
70717  
70718  ;// ./node_modules/@wordpress/block-editor/build-module/components/plain-text/index.js
70719  /**
70720   * External dependencies
70721   */
70722  
70723  
70724  
70725  /**
70726   * WordPress dependencies
70727   */
70728  
70729  
70730  /**
70731   * Internal dependencies
70732   */
70733  
70734  
70735  /**
70736   * Render an auto-growing textarea allow users to fill any textual content.
70737   *
70738   * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/plain-text/README.md
70739   *
70740   * @example
70741   * ```jsx
70742   * import { registerBlockType } from '@wordpress/blocks';
70743   * import { PlainText } from '@wordpress/block-editor';
70744   *
70745   * registerBlockType( 'my-plugin/example-block', {
70746   *   // ...
70747   *
70748   *   attributes: {
70749   *     content: {
70750   *       type: 'string',
70751   *     },
70752   *   },
70753   *
70754   *   edit( { className, attributes, setAttributes } ) {
70755   *     return (
70756   *       <PlainText
70757   *         className={ className }
70758   *         value={ attributes.content }
70759   *         onChange={ ( content ) => setAttributes( { content } ) }
70760   *       />
70761   *     );
70762   *   },
70763   * } );
70764   * ````
70765   *
70766   * @param {Object}   props          Component props.
70767   * @param {string}   props.value    String value of the textarea.
70768   * @param {Function} props.onChange Function called when the text value changes.
70769   * @param {Object}   [props.ref]    The component forwards the `ref` property to the `TextareaAutosize` component.
70770   * @return {Element} Plain text component
70771   */
70772  
70773  const PlainText = (0,external_wp_element_namespaceObject.forwardRef)(({
70774    __experimentalVersion,
70775    ...props
70776  }, ref) => {
70777    if (__experimentalVersion === 2) {
70778      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(editable_text, {
70779        ref: ref,
70780        ...props
70781      });
70782    }
70783    const {
70784      className,
70785      onChange,
70786      ...remainingProps
70787    } = props;
70788    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(lib/* default */.A, {
70789      ref: ref,
70790      className: dist_clsx('block-editor-plain-text', className),
70791      onChange: event => onChange(event.target.value),
70792      ...remainingProps
70793    });
70794  });
70795  /* harmony default export */ const plain_text = (PlainText);
70796  
70797  ;// ./node_modules/@wordpress/block-editor/build-module/components/responsive-block-control/label.js
70798  /**
70799   * WordPress dependencies
70800   */
70801  
70802  
70803  
70804  
70805  function ResponsiveBlockControlLabel({
70806    property,
70807    viewport,
70808    desc
70809  }) {
70810    const instanceId = (0,external_wp_compose_namespaceObject.useInstanceId)(ResponsiveBlockControlLabel);
70811    const accessibleLabel = desc || (0,external_wp_i18n_namespaceObject.sprintf)(/* translators: 1: property name. 2: viewport name. */
70812    (0,external_wp_i18n_namespaceObject._x)('Controls the %1$s property for %2$s viewports.', 'Text labelling a interface as controlling a given layout property (eg: margin) for a given screen size.'), property, viewport.label);
70813    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
70814      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("span", {
70815        "aria-describedby": `rbc-desc-$instanceId}`,
70816        children: viewport.label
70817      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.VisuallyHidden, {
70818        as: "span",
70819        id: `rbc-desc-$instanceId}`,
70820        children: accessibleLabel
70821      })]
70822    });
70823  }
70824  
70825  ;// ./node_modules/@wordpress/block-editor/build-module/components/responsive-block-control/index.js
70826  /**
70827   * External dependencies
70828   */
70829  
70830  
70831  /**
70832   * WordPress dependencies
70833   */
70834  
70835  
70836  
70837  
70838  /**
70839   * Internal dependencies
70840   */
70841  
70842  
70843  function ResponsiveBlockControl(props) {
70844    const {
70845      title,
70846      property,
70847      toggleLabel,
70848      onIsResponsiveChange,
70849      renderDefaultControl,
70850      renderResponsiveControls,
70851      isResponsive = false,
70852      defaultLabel = {
70853        id: 'all',
70854        label: (0,external_wp_i18n_namespaceObject._x)('All', 'screen sizes')
70855      },
70856      viewports = [{
70857        id: 'small',
70858        label: (0,external_wp_i18n_namespaceObject.__)('Small screens')
70859      }, {
70860        id: 'medium',
70861        label: (0,external_wp_i18n_namespaceObject.__)('Medium screens')
70862      }, {
70863        id: 'large',
70864        label: (0,external_wp_i18n_namespaceObject.__)('Large screens')
70865      }]
70866    } = props;
70867    if (!title || !property || !renderDefaultControl) {
70868      return null;
70869    }
70870    const toggleControlLabel = toggleLabel || (0,external_wp_i18n_namespaceObject.sprintf)(/* translators: %s: Property value for the control (eg: margin, padding, etc.). */
70871    (0,external_wp_i18n_namespaceObject.__)('Use the same %s on all screen sizes.'), property);
70872    const toggleHelpText = (0,external_wp_i18n_namespaceObject.__)('Choose whether to use the same value for all screen sizes or a unique value for each screen size.');
70873    const defaultControl = renderDefaultControl(/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ResponsiveBlockControlLabel, {
70874      property: property,
70875      viewport: defaultLabel
70876    }), defaultLabel);
70877    const defaultResponsiveControls = () => {
70878      return viewports.map(viewport => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_element_namespaceObject.Fragment, {
70879        children: renderDefaultControl(/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ResponsiveBlockControlLabel, {
70880          property: property,
70881          viewport: viewport
70882        }), viewport)
70883      }, viewport.id));
70884    };
70885    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("fieldset", {
70886      className: "block-editor-responsive-block-control",
70887      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("legend", {
70888        className: "block-editor-responsive-block-control__title",
70889        children: title
70890      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
70891        className: "block-editor-responsive-block-control__inner",
70892        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToggleControl, {
70893          __nextHasNoMarginBottom: true,
70894          className: "block-editor-responsive-block-control__toggle",
70895          label: toggleControlLabel,
70896          checked: !isResponsive,
70897          onChange: onIsResponsiveChange,
70898          help: toggleHelpText
70899        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
70900          className: dist_clsx('block-editor-responsive-block-control__group', {
70901            'is-responsive': isResponsive
70902          }),
70903          children: [!isResponsive && defaultControl, isResponsive && (renderResponsiveControls ? renderResponsiveControls(viewports) : defaultResponsiveControls())]
70904        })]
70905      })]
70906    });
70907  }
70908  /* harmony default export */ const responsive_block_control = (ResponsiveBlockControl);
70909  
70910  ;// ./node_modules/@wordpress/block-editor/build-module/components/rich-text/shortcut.js
70911  /**
70912   * WordPress dependencies
70913   */
70914  
70915  
70916  
70917  /**
70918   * Internal dependencies
70919   */
70920  
70921  function RichTextShortcut({
70922    character,
70923    type,
70924    onUse
70925  }) {
70926    const keyboardShortcuts = (0,external_wp_element_namespaceObject.useContext)(keyboardShortcutContext);
70927    const onUseRef = (0,external_wp_element_namespaceObject.useRef)();
70928    onUseRef.current = onUse;
70929    (0,external_wp_element_namespaceObject.useEffect)(() => {
70930      function callback(event) {
70931        if (external_wp_keycodes_namespaceObject.isKeyboardEvent[type](event, character)) {
70932          onUseRef.current();
70933          event.preventDefault();
70934        }
70935      }
70936      keyboardShortcuts.current.add(callback);
70937      return () => {
70938        keyboardShortcuts.current.delete(callback);
70939      };
70940    }, [character, type]);
70941    return null;
70942  }
70943  
70944  ;// ./node_modules/@wordpress/block-editor/build-module/components/rich-text/toolbar-button.js
70945  /**
70946   * WordPress dependencies
70947   */
70948  
70949  
70950  
70951  function RichTextToolbarButton({
70952    name,
70953    shortcutType,
70954    shortcutCharacter,
70955    ...props
70956  }) {
70957    let shortcut;
70958    let fillName = 'RichText.ToolbarControls';
70959    if (name) {
70960      fillName += `.$name}`;
70961    }
70962    if (shortcutType && shortcutCharacter) {
70963      shortcut = external_wp_keycodes_namespaceObject.displayShortcut[shortcutType](shortcutCharacter);
70964    }
70965    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Fill, {
70966      name: fillName,
70967      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarButton, {
70968        ...props,
70969        shortcut: shortcut
70970      })
70971    });
70972  }
70973  
70974  ;// ./node_modules/@wordpress/block-editor/build-module/components/rich-text/input-event.js
70975  /**
70976   * WordPress dependencies
70977   */
70978  
70979  
70980  /**
70981   * Internal dependencies
70982   */
70983  
70984  function __unstableRichTextInputEvent({
70985    inputType,
70986    onInput
70987  }) {
70988    const callbacks = (0,external_wp_element_namespaceObject.useContext)(inputEventContext);
70989    const onInputRef = (0,external_wp_element_namespaceObject.useRef)();
70990    onInputRef.current = onInput;
70991    (0,external_wp_element_namespaceObject.useEffect)(() => {
70992      function callback(event) {
70993        if (event.inputType === inputType) {
70994          onInputRef.current();
70995          event.preventDefault();
70996        }
70997      }
70998      callbacks.current.add(callback);
70999      return () => {
71000        callbacks.current.delete(callback);
71001      };
71002    }, [inputType]);
71003    return null;
71004  }
71005  
71006  ;// ./node_modules/@wordpress/block-editor/build-module/components/tool-selector/index.js
71007  /**
71008   * WordPress dependencies
71009   */
71010  
71011  
71012  
71013  
71014  
71015  
71016  /**
71017   * Internal dependencies
71018   */
71019  
71020  
71021  const selectIcon = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.SVG, {
71022    xmlns: "http://www.w3.org/2000/svg",
71023    width: "24",
71024    height: "24",
71025    viewBox: "0 0 24 24",
71026    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Path, {
71027      d: "M9.4 20.5L5.2 3.8l14.6 9-2 .3c-.2 0-.4.1-.7.1-.9.2-1.6.3-2.2.5-.8.3-1.4.5-1.8.8-.4.3-.8.8-1.3 1.5-.4.5-.8 1.2-1.2 2l-.3.6-.9 1.9zM7.6 7.1l2.4 9.3c.2-.4.5-.8.7-1.1.6-.8 1.1-1.4 1.6-1.8.5-.4 1.3-.8 2.2-1.1l1.2-.3-8.1-5z"
71028    })
71029  });
71030  function ToolSelector(props, ref) {
71031    const mode = (0,external_wp_data_namespaceObject.useSelect)(select => select(store).__unstableGetEditorMode(), []);
71032    const {
71033      __unstableSetEditorMode
71034    } = (0,external_wp_data_namespaceObject.useDispatch)(store);
71035    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Dropdown, {
71036      renderToggle: ({
71037        isOpen,
71038        onToggle
71039      }) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
71040        size: "compact",
71041        ...props,
71042        ref: ref,
71043        icon: mode === 'navigation' ? edit : selectIcon,
71044        "aria-expanded": isOpen,
71045        "aria-haspopup": "true",
71046        onClick: onToggle
71047        /* translators: button label text should, if possible, be under 16 characters. */,
71048        label: (0,external_wp_i18n_namespaceObject.__)('Tools')
71049      }),
71050      popoverProps: {
71051        placement: 'bottom-start'
71052      },
71053      renderContent: () => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
71054        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.NavigableMenu, {
71055          className: "block-editor-tool-selector__menu",
71056          role: "menu",
71057          "aria-label": (0,external_wp_i18n_namespaceObject.__)('Tools'),
71058          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItemsChoice, {
71059            value: mode === 'navigation' ? 'navigation' : 'edit',
71060            onSelect: newMode => {
71061              __unstableSetEditorMode(newMode);
71062            },
71063            choices: [{
71064              value: 'navigation',
71065              label: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
71066                children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(build_module_icon, {
71067                  icon: edit
71068                }), (0,external_wp_i18n_namespaceObject.__)('Write')]
71069              }),
71070              info: (0,external_wp_i18n_namespaceObject.__)('Focus on content.'),
71071              'aria-label': (0,external_wp_i18n_namespaceObject.__)('Write')
71072            }, {
71073              value: 'edit',
71074              label: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
71075                children: [selectIcon, (0,external_wp_i18n_namespaceObject.__)('Design')]
71076              }),
71077              info: (0,external_wp_i18n_namespaceObject.__)('Edit layout and styles.'),
71078              'aria-label': (0,external_wp_i18n_namespaceObject.__)('Design')
71079            }]
71080          })
71081        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
71082          className: "block-editor-tool-selector__help",
71083          children: (0,external_wp_i18n_namespaceObject.__)('Tools provide different sets of interactions for blocks. Choose between simplified content tools (Write) and advanced visual editing tools (Design).')
71084        })]
71085      })
71086    });
71087  }
71088  /* harmony default export */ const tool_selector = ((0,external_wp_element_namespaceObject.forwardRef)(ToolSelector));
71089  
71090  ;// ./node_modules/@wordpress/block-editor/build-module/components/unit-control/index.js
71091  /**
71092   * WordPress dependencies
71093   */
71094  
71095  
71096  /**
71097   * Internal dependencies
71098   */
71099  
71100  
71101  function UnitControl({
71102    units: unitsProp,
71103    ...props
71104  }) {
71105    const [availableUnits] = use_settings_useSettings('spacing.units');
71106    const units = (0,external_wp_components_namespaceObject.__experimentalUseCustomUnits)({
71107      availableUnits: availableUnits || ['%', 'px', 'em', 'rem', 'vw'],
71108      units: unitsProp
71109    });
71110    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalUnitControl, {
71111      units: units,
71112      ...props
71113    });
71114  }
71115  
71116  ;// ./node_modules/@wordpress/icons/build-module/library/arrow-left.js
71117  /**
71118   * WordPress dependencies
71119   */
71120  
71121  
71122  const arrowLeft = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
71123    xmlns: "http://www.w3.org/2000/svg",
71124    viewBox: "0 0 24 24",
71125    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
71126      d: "M20 11.2H6.8l3.7-3.7-1-1L3.9 12l5.6 5.5 1-1-3.7-3.7H20z"
71127    })
71128  });
71129  /* harmony default export */ const arrow_left = (arrowLeft);
71130  
71131  ;// ./node_modules/@wordpress/block-editor/build-module/components/url-input/button.js
71132  /**
71133   * WordPress dependencies
71134   */
71135  
71136  
71137  
71138  
71139  
71140  /**
71141   * Internal dependencies
71142   */
71143  
71144  
71145  class URLInputButton extends external_wp_element_namespaceObject.Component {
71146    constructor() {
71147      super(...arguments);
71148      this.toggle = this.toggle.bind(this);
71149      this.submitLink = this.submitLink.bind(this);
71150      this.state = {
71151        expanded: false
71152      };
71153    }
71154    toggle() {
71155      this.setState({
71156        expanded: !this.state.expanded
71157      });
71158    }
71159    submitLink(event) {
71160      event.preventDefault();
71161      this.toggle();
71162    }
71163    render() {
71164      const {
71165        url,
71166        onChange
71167      } = this.props;
71168      const {
71169        expanded
71170      } = this.state;
71171      const buttonLabel = url ? (0,external_wp_i18n_namespaceObject.__)('Edit link') : (0,external_wp_i18n_namespaceObject.__)('Insert link');
71172      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
71173        className: "block-editor-url-input__button",
71174        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
71175          size: "compact",
71176          icon: library_link,
71177          label: buttonLabel,
71178          onClick: this.toggle,
71179          className: "components-toolbar__control",
71180          isPressed: !!url
71181        }), expanded && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("form", {
71182          className: "block-editor-url-input__button-modal",
71183          onSubmit: this.submitLink,
71184          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
71185            className: "block-editor-url-input__button-modal-line",
71186            children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
71187              __next40pxDefaultSize: true,
71188              className: "block-editor-url-input__back",
71189              icon: arrow_left,
71190              label: (0,external_wp_i18n_namespaceObject.__)('Close'),
71191              onClick: this.toggle
71192            }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(url_input, {
71193              value: url || '',
71194              onChange: onChange,
71195              suffix: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalInputControlSuffixWrapper, {
71196                variant: "control",
71197                children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
71198                  size: "small",
71199                  icon: keyboard_return,
71200                  label: (0,external_wp_i18n_namespaceObject.__)('Submit'),
71201                  type: "submit"
71202                })
71203              })
71204            })]
71205          })
71206        })]
71207      });
71208    }
71209  }
71210  
71211  /**
71212   * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/url-input/README.md
71213   */
71214  /* harmony default export */ const url_input_button = (URLInputButton);
71215  
71216  ;// ./node_modules/@wordpress/icons/build-module/library/image.js
71217  /**
71218   * WordPress dependencies
71219   */
71220  
71221  
71222  const image_image = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
71223    viewBox: "0 0 24 24",
71224    xmlns: "http://www.w3.org/2000/svg",
71225    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
71226      d: "M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM5 4.5h14c.3 0 .5.2.5.5v8.4l-3-2.9c-.3-.3-.8-.3-1 0L11.9 14 9 12c-.3-.2-.6-.2-.8 0l-3.6 2.6V5c-.1-.3.1-.5.4-.5zm14 15H5c-.3 0-.5-.2-.5-.5v-2.4l4.1-3 3 1.9c.3.2.7.2.9-.1L16 12l3.5 3.4V19c0 .3-.2.5-.5.5z"
71227    })
71228  });
71229  /* harmony default export */ const library_image = (image_image);
71230  
71231  ;// ./node_modules/@wordpress/block-editor/build-module/components/url-popover/image-url-input-ui.js
71232  /**
71233   * WordPress dependencies
71234   */
71235  
71236  
71237  
71238  
71239  
71240  
71241  /**
71242   * Internal dependencies
71243   */
71244  
71245  
71246  const LINK_DESTINATION_NONE = 'none';
71247  const LINK_DESTINATION_CUSTOM = 'custom';
71248  const LINK_DESTINATION_MEDIA = 'media';
71249  const LINK_DESTINATION_ATTACHMENT = 'attachment';
71250  const NEW_TAB_REL = ['noreferrer', 'noopener'];
71251  const ImageURLInputUI = ({
71252    linkDestination,
71253    onChangeUrl,
71254    url,
71255    mediaType = 'image',
71256    mediaUrl,
71257    mediaLink,
71258    linkTarget,
71259    linkClass,
71260    rel,
71261    showLightboxSetting,
71262    lightboxEnabled,
71263    onSetLightbox,
71264    resetLightbox
71265  }) => {
71266    const [isOpen, setIsOpen] = (0,external_wp_element_namespaceObject.useState)(false);
71267    // Use internal state instead of a ref to make sure that the component
71268    // re-renders when the popover's anchor updates.
71269    const [popoverAnchor, setPopoverAnchor] = (0,external_wp_element_namespaceObject.useState)(null);
71270    const openLinkUI = () => {
71271      setIsOpen(true);
71272    };
71273    const [isEditingLink, setIsEditingLink] = (0,external_wp_element_namespaceObject.useState)(false);
71274    const [urlInput, setUrlInput] = (0,external_wp_element_namespaceObject.useState)(null);
71275    const autocompleteRef = (0,external_wp_element_namespaceObject.useRef)(null);
71276    const wrapperRef = (0,external_wp_element_namespaceObject.useRef)();
71277    (0,external_wp_element_namespaceObject.useEffect)(() => {
71278      if (!wrapperRef.current) {
71279        return;
71280      }
71281      const nextFocusTarget = external_wp_dom_namespaceObject.focus.focusable.find(wrapperRef.current)[0] || wrapperRef.current;
71282      nextFocusTarget.focus();
71283    }, [isEditingLink, url, lightboxEnabled]);
71284    const startEditLink = () => {
71285      if (linkDestination === LINK_DESTINATION_MEDIA || linkDestination === LINK_DESTINATION_ATTACHMENT) {
71286        setUrlInput('');
71287      }
71288      setIsEditingLink(true);
71289    };
71290    const stopEditLink = () => {
71291      setIsEditingLink(false);
71292    };
71293    const closeLinkUI = () => {
71294      setUrlInput(null);
71295      stopEditLink();
71296      setIsOpen(false);
71297    };
71298    const getUpdatedLinkTargetSettings = value => {
71299      const newLinkTarget = value ? '_blank' : undefined;
71300      let updatedRel;
71301      if (newLinkTarget) {
71302        const rels = (rel !== null && rel !== void 0 ? rel : '').split(' ');
71303        NEW_TAB_REL.forEach(relVal => {
71304          if (!rels.includes(relVal)) {
71305            rels.push(relVal);
71306          }
71307        });
71308        updatedRel = rels.join(' ');
71309      } else {
71310        const rels = (rel !== null && rel !== void 0 ? rel : '').split(' ').filter(relVal => NEW_TAB_REL.includes(relVal) === false);
71311        updatedRel = rels.length ? rels.join(' ') : undefined;
71312      }
71313      return {
71314        linkTarget: newLinkTarget,
71315        rel: updatedRel
71316      };
71317    };
71318    const onFocusOutside = () => {
71319      return event => {
71320        // The autocomplete suggestions list renders in a separate popover (in a portal),
71321        // so onFocusOutside fails to detect that a click on a suggestion occurred in the
71322        // LinkContainer. Detect clicks on autocomplete suggestions using a ref here, and
71323        // return to avoid the popover being closed.
71324        const autocompleteElement = autocompleteRef.current;
71325        if (autocompleteElement && autocompleteElement.contains(event.target)) {
71326          return;
71327        }
71328        setIsOpen(false);
71329        setUrlInput(null);
71330        stopEditLink();
71331      };
71332    };
71333    const onSubmitLinkChange = () => {
71334      return event => {
71335        if (urlInput) {
71336          // It is possible the entered URL actually matches a named link destination.
71337          // This check will ensure our link destination is correct.
71338          const selectedDestination = getLinkDestinations().find(destination => destination.url === urlInput)?.linkDestination || LINK_DESTINATION_CUSTOM;
71339          onChangeUrl({
71340            href: urlInput,
71341            linkDestination: selectedDestination,
71342            lightbox: {
71343              enabled: false
71344            }
71345          });
71346        }
71347        stopEditLink();
71348        setUrlInput(null);
71349        event.preventDefault();
71350      };
71351    };
71352    const onLinkRemove = () => {
71353      onChangeUrl({
71354        linkDestination: LINK_DESTINATION_NONE,
71355        href: ''
71356      });
71357    };
71358    const getLinkDestinations = () => {
71359      const linkDestinations = [{
71360        linkDestination: LINK_DESTINATION_MEDIA,
71361        title: (0,external_wp_i18n_namespaceObject.__)('Link to image file'),
71362        url: mediaType === 'image' ? mediaUrl : undefined,
71363        icon: library_image
71364      }];
71365      if (mediaType === 'image' && mediaLink) {
71366        linkDestinations.push({
71367          linkDestination: LINK_DESTINATION_ATTACHMENT,
71368          title: (0,external_wp_i18n_namespaceObject.__)('Link to attachment page'),
71369          url: mediaType === 'image' ? mediaLink : undefined,
71370          icon: library_page
71371        });
71372      }
71373      return linkDestinations;
71374    };
71375    const onSetHref = value => {
71376      const linkDestinations = getLinkDestinations();
71377      let linkDestinationInput;
71378      if (!value) {
71379        linkDestinationInput = LINK_DESTINATION_NONE;
71380      } else {
71381        linkDestinationInput = (linkDestinations.find(destination => {
71382          return destination.url === value;
71383        }) || {
71384          linkDestination: LINK_DESTINATION_CUSTOM
71385        }).linkDestination;
71386      }
71387      onChangeUrl({
71388        linkDestination: linkDestinationInput,
71389        href: value
71390      });
71391    };
71392    const onSetNewTab = value => {
71393      const updatedLinkTarget = getUpdatedLinkTargetSettings(value);
71394      onChangeUrl(updatedLinkTarget);
71395    };
71396    const onSetLinkRel = value => {
71397      onChangeUrl({
71398        rel: value
71399      });
71400    };
71401    const onSetLinkClass = value => {
71402      onChangeUrl({
71403        linkClass: value
71404      });
71405    };
71406    const advancedOptions = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalVStack, {
71407      spacing: "3",
71408      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToggleControl, {
71409        __nextHasNoMarginBottom: true,
71410        label: (0,external_wp_i18n_namespaceObject.__)('Open in new tab'),
71411        onChange: onSetNewTab,
71412        checked: linkTarget === '_blank'
71413      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.TextControl, {
71414        __next40pxDefaultSize: true,
71415        __nextHasNoMarginBottom: true,
71416        label: (0,external_wp_i18n_namespaceObject.__)('Link rel'),
71417        value: rel !== null && rel !== void 0 ? rel : '',
71418        onChange: onSetLinkRel
71419      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.TextControl, {
71420        __next40pxDefaultSize: true,
71421        __nextHasNoMarginBottom: true,
71422        label: (0,external_wp_i18n_namespaceObject.__)('Link CSS class'),
71423        value: linkClass || '',
71424        onChange: onSetLinkClass
71425      })]
71426    });
71427    const linkEditorValue = urlInput !== null ? urlInput : url;
71428    const hideLightboxPanel = !lightboxEnabled || lightboxEnabled && !showLightboxSetting;
71429    const showLinkEditor = !linkEditorValue && hideLightboxPanel;
71430    const urlLabel = (getLinkDestinations().find(destination => destination.linkDestination === linkDestination) || {}).title;
71431    const PopoverChildren = () => {
71432      if (lightboxEnabled && showLightboxSetting && !url && !isEditingLink) {
71433        return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
71434          className: "block-editor-url-popover__expand-on-click",
71435          children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(build_module_icon, {
71436            icon: library_fullscreen
71437          }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
71438            className: "text",
71439            children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("p", {
71440              children: (0,external_wp_i18n_namespaceObject.__)('Enlarge on click')
71441            }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("p", {
71442              className: "description",
71443              children: (0,external_wp_i18n_namespaceObject.__)('Scales the image with a lightbox effect')
71444            })]
71445          }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
71446            icon: link_off,
71447            label: (0,external_wp_i18n_namespaceObject.__)('Disable enlarge on click'),
71448            onClick: () => {
71449              onSetLightbox?.(false);
71450            },
71451            size: "compact"
71452          })]
71453        });
71454      } else if (!url || isEditingLink) {
71455        return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(url_popover.LinkEditor, {
71456          className: "block-editor-format-toolbar__link-container-content",
71457          value: linkEditorValue,
71458          onChangeInputValue: setUrlInput,
71459          onSubmit: onSubmitLinkChange(),
71460          autocompleteRef: autocompleteRef
71461        });
71462      } else if (url && !isEditingLink) {
71463        return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
71464          children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(url_popover.LinkViewer, {
71465            className: "block-editor-format-toolbar__link-container-content",
71466            url: url,
71467            onEditLinkClick: startEditLink,
71468            urlLabel: urlLabel
71469          }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
71470            icon: link_off,
71471            label: (0,external_wp_i18n_namespaceObject.__)('Remove link'),
71472            onClick: () => {
71473              onLinkRemove();
71474              resetLightbox?.();
71475            },
71476            size: "compact"
71477          })]
71478        });
71479      }
71480    };
71481    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
71482      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarButton, {
71483        icon: library_link,
71484        className: "components-toolbar__control",
71485        label: (0,external_wp_i18n_namespaceObject.__)('Link'),
71486        "aria-expanded": isOpen,
71487        onClick: openLinkUI,
71488        ref: setPopoverAnchor,
71489        isActive: !!url || lightboxEnabled && showLightboxSetting
71490      }), isOpen && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(url_popover, {
71491        ref: wrapperRef,
71492        anchor: popoverAnchor,
71493        onFocusOutside: onFocusOutside(),
71494        onClose: closeLinkUI,
71495        renderSettings: hideLightboxPanel ? () => advancedOptions : null,
71496        additionalControls: showLinkEditor && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.NavigableMenu, {
71497          children: [getLinkDestinations().map(link => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, {
71498            icon: link.icon,
71499            iconPosition: "left",
71500            onClick: () => {
71501              setUrlInput(null);
71502              onSetHref(link.url);
71503              stopEditLink();
71504            },
71505            children: link.title
71506          }, link.linkDestination)), showLightboxSetting && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, {
71507            className: "block-editor-url-popover__expand-on-click",
71508            icon: library_fullscreen,
71509            info: (0,external_wp_i18n_namespaceObject.__)('Scale the image with a lightbox effect.'),
71510            iconPosition: "left",
71511            onClick: () => {
71512              setUrlInput(null);
71513              onChangeUrl({
71514                linkDestination: LINK_DESTINATION_NONE,
71515                href: ''
71516              });
71517              onSetLightbox?.(true);
71518              stopEditLink();
71519            },
71520            children: (0,external_wp_i18n_namespaceObject.__)('Enlarge on click')
71521          }, "expand-on-click")]
71522        }),
71523        offset: 13,
71524        children: PopoverChildren()
71525      })]
71526    });
71527  };
71528  
71529  
71530  ;// ./node_modules/@wordpress/block-editor/build-module/components/preview-options/index.js
71531  /**
71532   * WordPress dependencies
71533   */
71534  
71535  function PreviewOptions() {
71536    external_wp_deprecated_default()('wp.blockEditor.PreviewOptions', {
71537      version: '6.5'
71538    });
71539    return null;
71540  }
71541  
71542  ;// ./node_modules/@wordpress/block-editor/build-module/components/use-resize-canvas/index.js
71543  /**
71544   * WordPress dependencies
71545   */
71546  
71547  
71548  /**
71549   * Function to resize the editor window.
71550   *
71551   * @param {string} deviceType Used for determining the size of the container (e.g. Desktop, Tablet, Mobile)
71552   *
71553   * @return {Object} Inline styles to be added to resizable container.
71554   */
71555  function useResizeCanvas(deviceType) {
71556    const [actualWidth, updateActualWidth] = (0,external_wp_element_namespaceObject.useState)(window.innerWidth);
71557    (0,external_wp_element_namespaceObject.useEffect)(() => {
71558      if (deviceType === 'Desktop') {
71559        return;
71560      }
71561      const resizeListener = () => updateActualWidth(window.innerWidth);
71562      window.addEventListener('resize', resizeListener);
71563      return () => {
71564        window.removeEventListener('resize', resizeListener);
71565      };
71566    }, [deviceType]);
71567    const getCanvasWidth = device => {
71568      let deviceWidth;
71569      switch (device) {
71570        case 'Tablet':
71571          deviceWidth = 780;
71572          break;
71573        case 'Mobile':
71574          deviceWidth = 360;
71575          break;
71576        default:
71577          return null;
71578      }
71579      return deviceWidth < actualWidth ? deviceWidth : actualWidth;
71580    };
71581    const contentInlineStyles = device => {
71582      const height = device === 'Mobile' ? '768px' : '1024px';
71583      const marginVertical = '40px';
71584      const marginHorizontal = 'auto';
71585      switch (device) {
71586        case 'Tablet':
71587        case 'Mobile':
71588          return {
71589            width: getCanvasWidth(device),
71590            // Keeping margin styles separate to avoid warnings
71591            // when those props get overridden in the iframe component
71592            marginTop: marginVertical,
71593            marginBottom: marginVertical,
71594            marginLeft: marginHorizontal,
71595            marginRight: marginHorizontal,
71596            height,
71597            maxWidth: '100%'
71598          };
71599        default:
71600          return {
71601            marginLeft: marginHorizontal,
71602            marginRight: marginHorizontal
71603          };
71604      }
71605    };
71606    return contentInlineStyles(deviceType);
71607  }
71608  
71609  ;// ./node_modules/@wordpress/block-editor/build-module/components/skip-to-selected-block/index.js
71610  /**
71611   * WordPress dependencies
71612   */
71613  
71614  
71615  
71616  
71617  
71618  /**
71619   * Internal dependencies
71620   */
71621  
71622  
71623  
71624  /**
71625   * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/skip-to-selected-block/README.md
71626   */
71627  
71628  function SkipToSelectedBlock() {
71629    const selectedBlockClientId = (0,external_wp_data_namespaceObject.useSelect)(select => select(store).getBlockSelectionStart(), []);
71630    const ref = (0,external_wp_element_namespaceObject.useRef)();
71631    useBlockElementRef(selectedBlockClientId, ref);
71632    const onClick = () => {
71633      ref.current?.focus();
71634    };
71635    return selectedBlockClientId ? /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
71636      __next40pxDefaultSize: true,
71637      variant: "secondary",
71638      className: "block-editor-skip-to-selected-block",
71639      onClick: onClick,
71640      children: (0,external_wp_i18n_namespaceObject.__)('Skip to the selected block')
71641    }) : null;
71642  }
71643  
71644  ;// ./node_modules/@wordpress/block-editor/build-module/components/multi-selection-inspector/index.js
71645  /**
71646   * WordPress dependencies
71647   */
71648  
71649  
71650  
71651  
71652  
71653  /**
71654   * Internal dependencies
71655   */
71656  
71657  
71658  
71659  function MultiSelectionInspector() {
71660    const selectedBlockCount = (0,external_wp_data_namespaceObject.useSelect)(select => select(store).getSelectedBlockCount(), []);
71661    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalHStack, {
71662      justify: "flex-start",
71663      spacing: 2,
71664      className: "block-editor-multi-selection-inspector__card",
71665      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_icon, {
71666        icon: library_copy,
71667        showColors: true
71668      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
71669        className: "block-editor-multi-selection-inspector__card-title",
71670        children: (0,external_wp_i18n_namespaceObject.sprintf)(/* translators: %d: number of blocks */
71671        (0,external_wp_i18n_namespaceObject._n)('%d Block', '%d Blocks', selectedBlockCount), selectedBlockCount)
71672      })]
71673    });
71674  }
71675  
71676  ;// ./node_modules/@wordpress/icons/build-module/library/cog.js
71677  /**
71678   * WordPress dependencies
71679   */
71680  
71681  
71682  const cog = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
71683    xmlns: "http://www.w3.org/2000/svg",
71684    viewBox: "0 0 24 24",
71685    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
71686      fillRule: "evenodd",
71687      d: "M10.289 4.836A1 1 0 0111.275 4h1.306a1 1 0 01.987.836l.244 1.466c.787.26 1.503.679 2.108 1.218l1.393-.522a1 1 0 011.216.437l.653 1.13a1 1 0 01-.23 1.273l-1.148.944a6.025 6.025 0 010 2.435l1.149.946a1 1 0 01.23 1.272l-.653 1.13a1 1 0 01-1.216.437l-1.394-.522c-.605.54-1.32.958-2.108 1.218l-.244 1.466a1 1 0 01-.987.836h-1.306a1 1 0 01-.986-.836l-.244-1.466a5.995 5.995 0 01-2.108-1.218l-1.394.522a1 1 0 01-1.217-.436l-.653-1.131a1 1 0 01.23-1.272l1.149-.946a6.026 6.026 0 010-2.435l-1.148-.944a1 1 0 01-.23-1.272l.653-1.131a1 1 0 011.217-.437l1.393.522a5.994 5.994 0 012.108-1.218l.244-1.466zM14.929 12a3 3 0 11-6 0 3 3 0 016 0z",
71688      clipRule: "evenodd"
71689    })
71690  });
71691  /* harmony default export */ const library_cog = (cog);
71692  
71693  ;// ./node_modules/@wordpress/icons/build-module/library/styles.js
71694  /**
71695   * WordPress dependencies
71696   */
71697  
71698  
71699  const styles = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
71700    viewBox: "0 0 24 24",
71701    xmlns: "http://www.w3.org/2000/svg",
71702    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
71703      fillRule: "evenodd",
71704      clipRule: "evenodd",
71705      d: "M20 12a8 8 0 1 1-16 0 8 8 0 0 1 16 0Zm-1.5 0a6.5 6.5 0 0 1-6.5 6.5v-13a6.5 6.5 0 0 1 6.5 6.5Z"
71706    })
71707  });
71708  /* harmony default export */ const library_styles = (styles);
71709  
71710  ;// ./node_modules/@wordpress/block-editor/build-module/components/inspector-controls-tabs/utils.js
71711  /**
71712   * WordPress dependencies
71713   */
71714  
71715  
71716  const TAB_SETTINGS = {
71717    name: 'settings',
71718    title: (0,external_wp_i18n_namespaceObject.__)('Settings'),
71719    value: 'settings',
71720    icon: library_cog
71721  };
71722  const TAB_STYLES = {
71723    name: 'styles',
71724    title: (0,external_wp_i18n_namespaceObject.__)('Styles'),
71725    value: 'styles',
71726    icon: library_styles
71727  };
71728  const TAB_LIST_VIEW = {
71729    name: 'list',
71730    title: (0,external_wp_i18n_namespaceObject.__)('List View'),
71731    value: 'list-view',
71732    icon: list_view
71733  };
71734  
71735  ;// ./node_modules/@wordpress/block-editor/build-module/components/inspector-controls-tabs/advanced-controls-panel.js
71736  /**
71737   * WordPress dependencies
71738   */
71739  
71740  
71741  
71742  /**
71743   * Internal dependencies
71744   */
71745  
71746  
71747  const AdvancedControls = () => {
71748    const fills = (0,external_wp_components_namespaceObject.__experimentalUseSlotFills)(InspectorAdvancedControls.slotName);
71749    const hasFills = Boolean(fills && fills.length);
71750    if (!hasFills) {
71751      return null;
71752    }
71753    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.PanelBody, {
71754      className: "block-editor-block-inspector__advanced",
71755      title: (0,external_wp_i18n_namespaceObject.__)('Advanced'),
71756      initialOpen: false,
71757      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls.Slot, {
71758        group: "advanced"
71759      })
71760    });
71761  };
71762  /* harmony default export */ const advanced_controls_panel = (AdvancedControls);
71763  
71764  ;// ./node_modules/@wordpress/block-editor/build-module/components/inspector-controls-tabs/position-controls-panel.js
71765  /**
71766   * WordPress dependencies
71767   */
71768  
71769  
71770  
71771  
71772  /**
71773   * Internal dependencies
71774   */
71775  
71776  
71777  
71778  
71779  
71780  
71781  const PositionControlsPanel = () => {
71782    const {
71783      selectedClientIds,
71784      selectedBlocks,
71785      hasPositionAttribute
71786    } = (0,external_wp_data_namespaceObject.useSelect)(select => {
71787      const {
71788        getBlocksByClientId,
71789        getSelectedBlockClientIds
71790      } = select(store);
71791      const selectedBlockClientIds = getSelectedBlockClientIds();
71792      const _selectedBlocks = getBlocksByClientId(selectedBlockClientIds);
71793      return {
71794        selectedClientIds: selectedBlockClientIds,
71795        selectedBlocks: _selectedBlocks,
71796        hasPositionAttribute: _selectedBlocks?.some(({
71797          attributes
71798        }) => !!attributes?.style?.position?.type)
71799      };
71800    }, []);
71801    const {
71802      updateBlockAttributes
71803    } = (0,external_wp_data_namespaceObject.useDispatch)(store);
71804    const dropdownMenuProps = useToolsPanelDropdownMenuProps();
71805    function resetPosition() {
71806      if (!selectedClientIds?.length || !selectedBlocks?.length) {
71807        return;
71808      }
71809      const attributesByClientId = Object.fromEntries(selectedBlocks?.map(({
71810        clientId,
71811        attributes
71812      }) => [clientId, {
71813        style: utils_cleanEmptyObject({
71814          ...attributes?.style,
71815          position: {
71816            ...attributes?.style?.position,
71817            type: undefined,
71818            top: undefined,
71819            right: undefined,
71820            bottom: undefined,
71821            left: undefined
71822          }
71823        })
71824      }]));
71825      updateBlockAttributes(selectedClientIds, attributesByClientId, true);
71826    }
71827    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanel, {
71828      className: "block-editor-block-inspector__position",
71829      label: (0,external_wp_i18n_namespaceObject.__)('Position'),
71830      resetAll: resetPosition,
71831      dropdownMenuProps: dropdownMenuProps,
71832      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanelItem, {
71833        isShownByDefault: hasPositionAttribute,
71834        label: (0,external_wp_i18n_namespaceObject.__)('Position'),
71835        hasValue: () => hasPositionAttribute,
71836        onDeselect: resetPosition,
71837        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls.Slot, {
71838          group: "position"
71839        })
71840      })
71841    });
71842  };
71843  const PositionControls = () => {
71844    const fills = (0,external_wp_components_namespaceObject.__experimentalUseSlotFills)(inspector_controls_groups.position.name);
71845    const hasFills = Boolean(fills && fills.length);
71846    if (!hasFills) {
71847      return null;
71848    }
71849    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PositionControlsPanel, {});
71850  };
71851  /* harmony default export */ const position_controls_panel = (PositionControls);
71852  
71853  ;// ./node_modules/@wordpress/block-editor/build-module/components/inspector-controls-tabs/settings-tab.js
71854  /**
71855   * Internal dependencies
71856   */
71857  
71858  
71859  
71860  
71861  const SettingsTab = ({
71862    showAdvancedControls = false
71863  }) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
71864    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls.Slot, {}), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(position_controls_panel, {}), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls.Slot, {
71865      group: "bindings"
71866    }), showAdvancedControls && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
71867      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(advanced_controls_panel, {})
71868    })]
71869  });
71870  /* harmony default export */ const settings_tab = (SettingsTab);
71871  
71872  ;// ./node_modules/@wordpress/block-editor/build-module/components/inspector-controls-tabs/styles-tab.js
71873  /**
71874   * WordPress dependencies
71875   */
71876  
71877  
71878  
71879  /**
71880   * Internal dependencies
71881   */
71882  
71883  
71884  
71885  
71886  const StylesTab = ({
71887    blockName,
71888    clientId,
71889    hasBlockStyles
71890  }) => {
71891    const borderPanelLabel = useBorderPanelLabel({
71892      blockName
71893    });
71894    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
71895      children: [hasBlockStyles && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
71896        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.PanelBody, {
71897          title: (0,external_wp_i18n_namespaceObject.__)('Styles'),
71898          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_styles, {
71899            clientId: clientId
71900          })
71901        })
71902      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls.Slot, {
71903        group: "color",
71904        label: (0,external_wp_i18n_namespaceObject.__)('Color'),
71905        className: "color-block-support-panel__inner-wrapper"
71906      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls.Slot, {
71907        group: "background",
71908        label: (0,external_wp_i18n_namespaceObject.__)('Background image')
71909      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls.Slot, {
71910        group: "filter"
71911      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls.Slot, {
71912        group: "typography",
71913        label: (0,external_wp_i18n_namespaceObject.__)('Typography')
71914      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls.Slot, {
71915        group: "dimensions",
71916        label: (0,external_wp_i18n_namespaceObject.__)('Dimensions')
71917      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls.Slot, {
71918        group: "border",
71919        label: borderPanelLabel
71920      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls.Slot, {
71921        group: "styles"
71922      })]
71923    });
71924  };
71925  /* harmony default export */ const styles_tab = (StylesTab);
71926  
71927  ;// ./node_modules/@wordpress/block-editor/build-module/components/inspector-controls-tabs/use-is-list-view-tab-disabled.js
71928  // List view tab restricts the blocks that may render to it via the
71929  // allowlist below.
71930  const allowlist = ['core/navigation'];
71931  const useIsListViewTabDisabled = blockName => {
71932    return !allowlist.includes(blockName);
71933  };
71934  /* harmony default export */ const use_is_list_view_tab_disabled = (useIsListViewTabDisabled);
71935  
71936  ;// ./node_modules/@wordpress/block-editor/build-module/components/inspector-controls-tabs/index.js
71937  /**
71938   * WordPress dependencies
71939   */
71940  
71941  
71942  
71943  
71944  /**
71945   * Internal dependencies
71946   */
71947  
71948  
71949  
71950  
71951  
71952  
71953  
71954  const {
71955    Tabs: inspector_controls_tabs_Tabs
71956  } = unlock(external_wp_components_namespaceObject.privateApis);
71957  function InspectorControlsTabs({
71958    blockName,
71959    clientId,
71960    hasBlockStyles,
71961    tabs
71962  }) {
71963    const showIconLabels = (0,external_wp_data_namespaceObject.useSelect)(select => {
71964      return select(external_wp_preferences_namespaceObject.store).get('core', 'showIconLabels');
71965    }, []);
71966  
71967    // The tabs panel will mount before fills are rendered to the list view
71968    // slot. This means the list view tab isn't initially included in the
71969    // available tabs so the panel defaults selection to the settings tab
71970    // which at the time is the first tab. This check allows blocks known to
71971    // include the list view tab to set it as the tab selected by default.
71972    const initialTabName = !use_is_list_view_tab_disabled(blockName) ? TAB_LIST_VIEW.name : undefined;
71973    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
71974      className: "block-editor-block-inspector__tabs",
71975      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(inspector_controls_tabs_Tabs, {
71976        defaultTabId: initialTabName,
71977        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls_tabs_Tabs.TabList, {
71978          children: tabs.map(tab => showIconLabels ? /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls_tabs_Tabs.Tab, {
71979            tabId: tab.name,
71980            children: tab.title
71981          }, tab.name) : /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Tooltip, {
71982            text: tab.title,
71983            children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls_tabs_Tabs.Tab, {
71984              tabId: tab.name,
71985              "aria-label": tab.title,
71986              children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Icon, {
71987                icon: tab.icon
71988              })
71989            })
71990          }, tab.name))
71991        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls_tabs_Tabs.TabPanel, {
71992          tabId: TAB_SETTINGS.name,
71993          focusable: false,
71994          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(settings_tab, {
71995            showAdvancedControls: !!blockName
71996          })
71997        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls_tabs_Tabs.TabPanel, {
71998          tabId: TAB_STYLES.name,
71999          focusable: false,
72000          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(styles_tab, {
72001            blockName: blockName,
72002            clientId: clientId,
72003            hasBlockStyles: hasBlockStyles
72004          })
72005        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls_tabs_Tabs.TabPanel, {
72006          tabId: TAB_LIST_VIEW.name,
72007          focusable: false,
72008          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls.Slot, {
72009            group: "list"
72010          })
72011        })]
72012      }, clientId)
72013    });
72014  }
72015  
72016  ;// ./node_modules/@wordpress/block-editor/build-module/components/inspector-controls-tabs/use-inspector-controls-tabs.js
72017  /**
72018   * WordPress dependencies
72019   */
72020  
72021  
72022  
72023  /**
72024   * Internal dependencies
72025   */
72026  
72027  
72028  
72029  
72030  
72031  const use_inspector_controls_tabs_EMPTY_ARRAY = [];
72032  function getShowTabs(blockName, tabSettings = {}) {
72033    // Block specific setting takes precedence over generic default.
72034    if (tabSettings[blockName] !== undefined) {
72035      return tabSettings[blockName];
72036    }
72037  
72038    // Use generic default if set over the Gutenberg experiment option.
72039    if (tabSettings.default !== undefined) {
72040      return tabSettings.default;
72041    }
72042    return true;
72043  }
72044  function useInspectorControlsTabs(blockName) {
72045    const tabs = [];
72046    const {
72047      bindings: bindingsGroup,
72048      border: borderGroup,
72049      color: colorGroup,
72050      default: defaultGroup,
72051      dimensions: dimensionsGroup,
72052      list: listGroup,
72053      position: positionGroup,
72054      styles: stylesGroup,
72055      typography: typographyGroup,
72056      effects: effectsGroup
72057    } = inspector_controls_groups;
72058  
72059    // List View Tab: If there are any fills for the list group add that tab.
72060    const listViewDisabled = use_is_list_view_tab_disabled(blockName);
72061    const listFills = (0,external_wp_components_namespaceObject.__experimentalUseSlotFills)(listGroup.name);
72062    const hasListFills = !listViewDisabled && !!listFills && listFills.length;
72063  
72064    // Styles Tab: Add this tab if there are any fills for block supports
72065    // e.g. border, color, spacing, typography, etc.
72066    const styleFills = [...((0,external_wp_components_namespaceObject.__experimentalUseSlotFills)(borderGroup.name) || []), ...((0,external_wp_components_namespaceObject.__experimentalUseSlotFills)(colorGroup.name) || []), ...((0,external_wp_components_namespaceObject.__experimentalUseSlotFills)(dimensionsGroup.name) || []), ...((0,external_wp_components_namespaceObject.__experimentalUseSlotFills)(stylesGroup.name) || []), ...((0,external_wp_components_namespaceObject.__experimentalUseSlotFills)(typographyGroup.name) || []), ...((0,external_wp_components_namespaceObject.__experimentalUseSlotFills)(effectsGroup.name) || [])];
72067    const hasStyleFills = styleFills.length;
72068  
72069    // Settings Tab: If we don't have multiple tabs to display
72070    // (i.e. both list view and styles), check only the default and position
72071    // InspectorControls slots. If we have multiple tabs, we'll need to check
72072    // the advanced controls slot as well to ensure they are rendered.
72073    const advancedFills = [...((0,external_wp_components_namespaceObject.__experimentalUseSlotFills)(InspectorAdvancedControls.slotName) || []), ...((0,external_wp_components_namespaceObject.__experimentalUseSlotFills)(bindingsGroup.name) || [])];
72074    const settingsFills = [...((0,external_wp_components_namespaceObject.__experimentalUseSlotFills)(defaultGroup.name) || []), ...((0,external_wp_components_namespaceObject.__experimentalUseSlotFills)(positionGroup.name) || []), ...(hasListFills && hasStyleFills > 1 ? advancedFills : [])];
72075  
72076    // Add the tabs in the order that they will default to if available.
72077    // List View > Settings > Styles.
72078    if (hasListFills) {
72079      tabs.push(TAB_LIST_VIEW);
72080    }
72081    if (settingsFills.length) {
72082      tabs.push(TAB_SETTINGS);
72083    }
72084    if (hasStyleFills) {
72085      tabs.push(TAB_STYLES);
72086    }
72087    const tabSettings = (0,external_wp_data_namespaceObject.useSelect)(select => {
72088      return select(store).getSettings().blockInspectorTabs;
72089    }, []);
72090    const showTabs = getShowTabs(blockName, tabSettings);
72091    return showTabs ? tabs : use_inspector_controls_tabs_EMPTY_ARRAY;
72092  }
72093  
72094  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-inspector/useBlockInspectorAnimationSettings.js
72095  /**
72096   * WordPress dependencies
72097   */
72098  
72099  
72100  /**
72101   * Internal dependencies
72102   */
72103  
72104  function useBlockInspectorAnimationSettings(blockType) {
72105    return (0,external_wp_data_namespaceObject.useSelect)(select => {
72106      if (blockType) {
72107        const globalBlockInspectorAnimationSettings = select(store).getSettings().blockInspectorAnimation;
72108  
72109        // Get the name of the block that will allow it's children to be animated.
72110        const animationParent = globalBlockInspectorAnimationSettings?.animationParent;
72111  
72112        // Determine whether the animationParent block is a parent of the selected block.
72113        const {
72114          getSelectedBlockClientId,
72115          getBlockParentsByBlockName
72116        } = select(store);
72117        const _selectedBlockClientId = getSelectedBlockClientId();
72118        const animationParentBlockClientId = getBlockParentsByBlockName(_selectedBlockClientId, animationParent, true)[0];
72119  
72120        // If the selected block is not a child of the animationParent block,
72121        // and not an animationParent block itself, don't animate.
72122        if (!animationParentBlockClientId && blockType.name !== animationParent) {
72123          return null;
72124        }
72125        return globalBlockInspectorAnimationSettings?.[blockType.name];
72126      }
72127      return null;
72128    }, [blockType]);
72129  }
72130  
72131  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-quick-navigation/index.js
72132  /**
72133   * WordPress dependencies
72134   */
72135  
72136  
72137  
72138  /**
72139   * Internal dependencies
72140   */
72141  
72142  
72143  
72144  
72145  
72146  function BlockQuickNavigation({
72147    clientIds,
72148    onSelect
72149  }) {
72150    if (!clientIds.length) {
72151      return null;
72152    }
72153    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalVStack, {
72154      spacing: 1,
72155      children: clientIds.map(clientId => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockQuickNavigationItem, {
72156        onSelect: onSelect,
72157        clientId: clientId
72158      }, clientId))
72159    });
72160  }
72161  function BlockQuickNavigationItem({
72162    clientId,
72163    onSelect
72164  }) {
72165    const blockInformation = useBlockDisplayInformation(clientId);
72166    const blockTitle = useBlockDisplayTitle({
72167      clientId,
72168      context: 'list-view'
72169    });
72170    const {
72171      isSelected
72172    } = (0,external_wp_data_namespaceObject.useSelect)(select => {
72173      const {
72174        isBlockSelected,
72175        hasSelectedInnerBlock
72176      } = select(store);
72177      return {
72178        isSelected: isBlockSelected(clientId) || hasSelectedInnerBlock(clientId, /* deep: */true)
72179      };
72180    }, [clientId]);
72181    const {
72182      selectBlock
72183    } = (0,external_wp_data_namespaceObject.useDispatch)(store);
72184    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
72185      __next40pxDefaultSize: true,
72186      isPressed: isSelected,
72187      onClick: async () => {
72188        await selectBlock(clientId);
72189        if (onSelect) {
72190          onSelect(clientId);
72191        }
72192      },
72193      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.Flex, {
72194        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FlexItem, {
72195          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_icon, {
72196            icon: blockInformation?.icon
72197          })
72198        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FlexBlock, {
72199          style: {
72200            textAlign: 'left'
72201          },
72202          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalTruncate, {
72203            children: blockTitle
72204          })
72205        })]
72206      })
72207    });
72208  }
72209  
72210  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-inspector/index.js
72211  /**
72212   * WordPress dependencies
72213   */
72214  
72215  
72216  
72217  
72218  
72219  /**
72220   * Internal dependencies
72221   */
72222  
72223  
72224  
72225  
72226  
72227  
72228  
72229  
72230  
72231  
72232  
72233  
72234  
72235  
72236  
72237  
72238  
72239  function BlockStylesPanel({
72240    clientId
72241  }) {
72242    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.PanelBody, {
72243      title: (0,external_wp_i18n_namespaceObject.__)('Styles'),
72244      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_styles, {
72245        clientId: clientId
72246      })
72247    });
72248  }
72249  function BlockInspector() {
72250    const {
72251      count,
72252      selectedBlockName,
72253      selectedBlockClientId,
72254      blockType,
72255      isSectionBlock
72256    } = (0,external_wp_data_namespaceObject.useSelect)(select => {
72257      const {
72258        getSelectedBlockClientId,
72259        getSelectedBlockCount,
72260        getBlockName,
72261        getParentSectionBlock,
72262        isSectionBlock: _isSectionBlock
72263      } = unlock(select(store));
72264      const _selectedBlockClientId = getSelectedBlockClientId();
72265      const renderedBlockClientId = getParentSectionBlock(_selectedBlockClientId) || getSelectedBlockClientId();
72266      const _selectedBlockName = renderedBlockClientId && getBlockName(renderedBlockClientId);
72267      const _blockType = _selectedBlockName && (0,external_wp_blocks_namespaceObject.getBlockType)(_selectedBlockName);
72268      return {
72269        count: getSelectedBlockCount(),
72270        selectedBlockClientId: renderedBlockClientId,
72271        selectedBlockName: _selectedBlockName,
72272        blockType: _blockType,
72273        isSectionBlock: _isSectionBlock(renderedBlockClientId)
72274      };
72275    }, []);
72276    const availableTabs = useInspectorControlsTabs(blockType?.name);
72277    const showTabs = availableTabs?.length > 1;
72278  
72279    // The block inspector animation settings will be completely
72280    // removed in the future to create an API which allows the block
72281    // inspector to transition between what it
72282    // displays based on the relationship between the selected block
72283    // and its parent, and only enable it if the parent is controlling
72284    // its children blocks.
72285    const blockInspectorAnimationSettings = useBlockInspectorAnimationSettings(blockType);
72286    const borderPanelLabel = useBorderPanelLabel({
72287      blockName: selectedBlockName
72288    });
72289    if (count > 1 && !isSectionBlock) {
72290      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
72291        className: "block-editor-block-inspector",
72292        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(MultiSelectionInspector, {}), showTabs ? /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(InspectorControlsTabs, {
72293          tabs: availableTabs
72294        }) : /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
72295          children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls.Slot, {}), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls.Slot, {
72296            group: "color",
72297            label: (0,external_wp_i18n_namespaceObject.__)('Color'),
72298            className: "color-block-support-panel__inner-wrapper"
72299          }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls.Slot, {
72300            group: "background",
72301            label: (0,external_wp_i18n_namespaceObject.__)('Background image')
72302          }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls.Slot, {
72303            group: "typography",
72304            label: (0,external_wp_i18n_namespaceObject.__)('Typography')
72305          }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls.Slot, {
72306            group: "dimensions",
72307            label: (0,external_wp_i18n_namespaceObject.__)('Dimensions')
72308          }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls.Slot, {
72309            group: "border",
72310            label: borderPanelLabel
72311          }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls.Slot, {
72312            group: "styles"
72313          })]
72314        })]
72315      });
72316    }
72317    const isSelectedBlockUnregistered = selectedBlockName === (0,external_wp_blocks_namespaceObject.getUnregisteredTypeHandlerName)();
72318  
72319    /*
72320     * If the selected block is of an unregistered type, avoid showing it as an actual selection
72321     * because we want the user to focus on the unregistered block warning, not block settings.
72322     */
72323    if (!blockType || !selectedBlockClientId || isSelectedBlockUnregistered) {
72324      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("span", {
72325        className: "block-editor-block-inspector__no-blocks",
72326        children: (0,external_wp_i18n_namespaceObject.__)('No block selected.')
72327      });
72328    }
72329    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockInspectorSingleBlockWrapper, {
72330      animate: blockInspectorAnimationSettings,
72331      wrapper: children => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(AnimatedContainer, {
72332        blockInspectorAnimationSettings: blockInspectorAnimationSettings,
72333        selectedBlockClientId: selectedBlockClientId,
72334        children: children
72335      }),
72336      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockInspectorSingleBlock, {
72337        clientId: selectedBlockClientId,
72338        blockName: blockType.name,
72339        isSectionBlock: isSectionBlock
72340      })
72341    });
72342  }
72343  const BlockInspectorSingleBlockWrapper = ({
72344    animate,
72345    wrapper,
72346    children
72347  }) => {
72348    return animate ? wrapper(children) : children;
72349  };
72350  const AnimatedContainer = ({
72351    blockInspectorAnimationSettings,
72352    selectedBlockClientId,
72353    children
72354  }) => {
72355    const animationOrigin = blockInspectorAnimationSettings && blockInspectorAnimationSettings.enterDirection === 'leftToRight' ? -50 : 50;
72356    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__unstableMotion.div, {
72357      animate: {
72358        x: 0,
72359        opacity: 1,
72360        transition: {
72361          ease: 'easeInOut',
72362          duration: 0.14
72363        }
72364      },
72365      initial: {
72366        x: animationOrigin,
72367        opacity: 0
72368      },
72369      children: children
72370    }, selectedBlockClientId);
72371  };
72372  const BlockInspectorSingleBlock = ({
72373    clientId,
72374    blockName,
72375    isSectionBlock
72376  }) => {
72377    const availableTabs = useInspectorControlsTabs(blockName);
72378    const showTabs = !isSectionBlock && availableTabs?.length > 1;
72379    const hasBlockStyles = (0,external_wp_data_namespaceObject.useSelect)(select => {
72380      const {
72381        getBlockStyles
72382      } = select(external_wp_blocks_namespaceObject.store);
72383      const blockStyles = getBlockStyles(blockName);
72384      return blockStyles && blockStyles.length > 0;
72385    }, [blockName]);
72386    const blockInformation = useBlockDisplayInformation(clientId);
72387    const borderPanelLabel = useBorderPanelLabel({
72388      blockName
72389    });
72390    const contentClientIds = (0,external_wp_data_namespaceObject.useSelect)(select => {
72391      // Avoid unnecessary subscription.
72392      if (!isSectionBlock) {
72393        return;
72394      }
72395      const {
72396        getClientIdsOfDescendants,
72397        getBlockName,
72398        getBlockEditingMode
72399      } = select(store);
72400      return getClientIdsOfDescendants(clientId).filter(current => getBlockName(current) !== 'core/list-item' && getBlockEditingMode(current) === 'contentOnly');
72401    }, [isSectionBlock, clientId]);
72402    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
72403      className: "block-editor-block-inspector",
72404      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_card, {
72405        ...blockInformation,
72406        className: blockInformation.isSynced && 'is-synced'
72407      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_variation_transforms, {
72408        blockClientId: clientId
72409      }), showTabs && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(InspectorControlsTabs, {
72410        hasBlockStyles: hasBlockStyles,
72411        clientId: clientId,
72412        blockName: blockName,
72413        tabs: availableTabs
72414      }), !showTabs && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
72415        children: [hasBlockStyles && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockStylesPanel, {
72416          clientId: clientId
72417        }), contentClientIds && contentClientIds?.length > 0 && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.PanelBody, {
72418          title: (0,external_wp_i18n_namespaceObject.__)('Content'),
72419          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockQuickNavigation, {
72420            clientIds: contentClientIds
72421          })
72422        }), !isSectionBlock && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
72423          children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls.Slot, {}), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls.Slot, {
72424            group: "list"
72425          }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls.Slot, {
72426            group: "color",
72427            label: (0,external_wp_i18n_namespaceObject.__)('Color'),
72428            className: "color-block-support-panel__inner-wrapper"
72429          }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls.Slot, {
72430            group: "background",
72431            label: (0,external_wp_i18n_namespaceObject.__)('Background image')
72432          }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls.Slot, {
72433            group: "typography",
72434            label: (0,external_wp_i18n_namespaceObject.__)('Typography')
72435          }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls.Slot, {
72436            group: "dimensions",
72437            label: (0,external_wp_i18n_namespaceObject.__)('Dimensions')
72438          }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls.Slot, {
72439            group: "border",
72440            label: borderPanelLabel
72441          }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls.Slot, {
72442            group: "styles"
72443          }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(position_controls_panel, {}), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls.Slot, {
72444            group: "bindings"
72445          }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
72446            children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(advanced_controls_panel, {})
72447          })]
72448        })]
72449      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(SkipToSelectedBlock, {}, "back")]
72450    });
72451  };
72452  
72453  /**
72454   * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/block-inspector/README.md
72455   */
72456  /* harmony default export */ const block_inspector = (BlockInspector);
72457  
72458  ;// ./node_modules/@wordpress/block-editor/build-module/components/copy-handler/index.js
72459  /**
72460   * WordPress dependencies
72461   */
72462  
72463  
72464  /**
72465   * Internal dependencies
72466   */
72467  
72468  
72469  /**
72470   * @deprecated
72471   */
72472  
72473  const __unstableUseClipboardHandler = () => {
72474    external_wp_deprecated_default()('__unstableUseClipboardHandler', {
72475      alternative: 'BlockCanvas or WritingFlow',
72476      since: '6.4',
72477      version: '6.7'
72478    });
72479    return useClipboardHandler();
72480  };
72481  
72482  /**
72483   * @deprecated
72484   * @param {Object} props
72485   */
72486  function CopyHandler(props) {
72487    external_wp_deprecated_default()('CopyHandler', {
72488      alternative: 'BlockCanvas or WritingFlow',
72489      since: '6.4',
72490      version: '6.7'
72491    });
72492    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
72493      ...props,
72494      ref: useClipboardHandler()
72495    });
72496  }
72497  
72498  ;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/library.js
72499  /**
72500   * WordPress dependencies
72501   */
72502  
72503  
72504  
72505  /**
72506   * Internal dependencies
72507   */
72508  
72509  
72510  
72511  const library_noop = () => {};
72512  function InserterLibrary({
72513    rootClientId,
72514    clientId,
72515    isAppender,
72516    showInserterHelpPanel,
72517    showMostUsedBlocks = false,
72518    __experimentalInsertionIndex,
72519    __experimentalInitialTab,
72520    __experimentalInitialCategory,
72521    __experimentalFilterValue,
72522    onPatternCategorySelection,
72523    onSelect = library_noop,
72524    shouldFocusBlock = false,
72525    onClose
72526  }, ref) {
72527    const {
72528      destinationRootClientId
72529    } = (0,external_wp_data_namespaceObject.useSelect)(select => {
72530      const {
72531        getBlockRootClientId
72532      } = select(store);
72533      const _rootClientId = rootClientId || getBlockRootClientId(clientId) || undefined;
72534      return {
72535        destinationRootClientId: _rootClientId
72536      };
72537    }, [clientId, rootClientId]);
72538    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PrivateInserterMenu, {
72539      onSelect: onSelect,
72540      rootClientId: destinationRootClientId,
72541      clientId: clientId,
72542      isAppender: isAppender,
72543      showInserterHelpPanel: showInserterHelpPanel,
72544      showMostUsedBlocks: showMostUsedBlocks,
72545      __experimentalInsertionIndex: __experimentalInsertionIndex,
72546      __experimentalFilterValue: __experimentalFilterValue,
72547      onPatternCategorySelection: onPatternCategorySelection,
72548      __experimentalInitialTab: __experimentalInitialTab,
72549      __experimentalInitialCategory: __experimentalInitialCategory,
72550      shouldFocusBlock: shouldFocusBlock,
72551      ref: ref,
72552      onClose: onClose
72553    });
72554  }
72555  const PrivateInserterLibrary = (0,external_wp_element_namespaceObject.forwardRef)(InserterLibrary);
72556  function PublicInserterLibrary(props, ref) {
72557    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PrivateInserterLibrary, {
72558      ...props,
72559      onPatternCategorySelection: undefined,
72560      ref: ref
72561    });
72562  }
72563  /* harmony default export */ const library = ((0,external_wp_element_namespaceObject.forwardRef)(PublicInserterLibrary));
72564  
72565  ;// ./node_modules/@wordpress/block-editor/build-module/components/selection-scroll-into-view/index.js
72566  /**
72567   * WordPress dependencies
72568   */
72569  
72570  
72571  /**
72572   * Scrolls the multi block selection end into view if not in view already. This
72573   * is important to do after selection by keyboard.
72574   *
72575   * @deprecated
72576   */
72577  function MultiSelectScrollIntoView() {
72578    external_wp_deprecated_default()('wp.blockEditor.MultiSelectScrollIntoView', {
72579      hint: 'This behaviour is now built-in.',
72580      since: '5.8'
72581    });
72582    return null;
72583  }
72584  
72585  ;// ./node_modules/@wordpress/block-editor/build-module/components/typewriter/index.js
72586  /**
72587   * WordPress dependencies
72588   */
72589  
72590  
72591  
72592  
72593  
72594  /**
72595   * Internal dependencies
72596   */
72597  
72598  
72599  const isIE = window.navigator.userAgent.indexOf('Trident') !== -1;
72600  const arrowKeyCodes = new Set([external_wp_keycodes_namespaceObject.UP, external_wp_keycodes_namespaceObject.DOWN, external_wp_keycodes_namespaceObject.LEFT, external_wp_keycodes_namespaceObject.RIGHT]);
72601  const initialTriggerPercentage = 0.75;
72602  function useTypewriter() {
72603    const hasSelectedBlock = (0,external_wp_data_namespaceObject.useSelect)(select => select(store).hasSelectedBlock(), []);
72604    return (0,external_wp_compose_namespaceObject.useRefEffect)(node => {
72605      if (!hasSelectedBlock) {
72606        return;
72607      }
72608      const {
72609        ownerDocument
72610      } = node;
72611      const {
72612        defaultView
72613      } = ownerDocument;
72614      let scrollResizeRafId;
72615      let onKeyDownRafId;
72616      let caretRect;
72617      function onScrollResize() {
72618        if (scrollResizeRafId) {
72619          return;
72620        }
72621        scrollResizeRafId = defaultView.requestAnimationFrame(() => {
72622          computeCaretRectangle();
72623          scrollResizeRafId = null;
72624        });
72625      }
72626      function onKeyDown(event) {
72627        // Ensure the any remaining request is cancelled.
72628        if (onKeyDownRafId) {
72629          defaultView.cancelAnimationFrame(onKeyDownRafId);
72630        }
72631  
72632        // Use an animation frame for a smooth result.
72633        onKeyDownRafId = defaultView.requestAnimationFrame(() => {
72634          maintainCaretPosition(event);
72635          onKeyDownRafId = null;
72636        });
72637      }
72638  
72639      /**
72640       * Maintains the scroll position after a selection change caused by a
72641       * keyboard event.
72642       *
72643       * @param {KeyboardEvent} event Keyboard event.
72644       */
72645      function maintainCaretPosition({
72646        keyCode
72647      }) {
72648        if (!isSelectionEligibleForScroll()) {
72649          return;
72650        }
72651        const currentCaretRect = (0,external_wp_dom_namespaceObject.computeCaretRect)(defaultView);
72652        if (!currentCaretRect) {
72653          return;
72654        }
72655  
72656        // If for some reason there is no position set to be scrolled to, let
72657        // this be the position to be scrolled to in the future.
72658        if (!caretRect) {
72659          caretRect = currentCaretRect;
72660          return;
72661        }
72662  
72663        // Even though enabling the typewriter effect for arrow keys results in
72664        // a pleasant experience, it may not be the case for everyone, so, for
72665        // now, let's disable it.
72666        if (arrowKeyCodes.has(keyCode)) {
72667          // Reset the caret position to maintain.
72668          caretRect = currentCaretRect;
72669          return;
72670        }
72671        const diff = currentCaretRect.top - caretRect.top;
72672        if (diff === 0) {
72673          return;
72674        }
72675        const scrollContainer = (0,external_wp_dom_namespaceObject.getScrollContainer)(node);
72676  
72677        // The page must be scrollable.
72678        if (!scrollContainer) {
72679          return;
72680        }
72681        const windowScroll = scrollContainer === ownerDocument.body || scrollContainer === ownerDocument.documentElement;
72682        const scrollY = windowScroll ? defaultView.scrollY : scrollContainer.scrollTop;
72683        const scrollContainerY = windowScroll ? 0 : scrollContainer.getBoundingClientRect().top;
72684        const relativeScrollPosition = windowScroll ? caretRect.top / defaultView.innerHeight : (caretRect.top - scrollContainerY) / (defaultView.innerHeight - scrollContainerY);
72685  
72686        // If the scroll position is at the start, the active editable element
72687        // is the last one, and the caret is positioned within the initial
72688        // trigger percentage of the page, do not scroll the page.
72689        // The typewriter effect should not kick in until an empty page has been
72690        // filled with the initial trigger percentage or the user scrolls
72691        // intentionally down.
72692        if (scrollY === 0 && relativeScrollPosition < initialTriggerPercentage && isLastEditableNode()) {
72693          // Reset the caret position to maintain.
72694          caretRect = currentCaretRect;
72695          return;
72696        }
72697        const scrollContainerHeight = windowScroll ? defaultView.innerHeight : scrollContainer.clientHeight;
72698  
72699        // Abort if the target scroll position would scroll the caret out of
72700        // view.
72701        if (
72702        // The caret is under the lower fold.
72703        caretRect.top + caretRect.height > scrollContainerY + scrollContainerHeight ||
72704        // The caret is above the upper fold.
72705        caretRect.top < scrollContainerY) {
72706          // Reset the caret position to maintain.
72707          caretRect = currentCaretRect;
72708          return;
72709        }
72710        if (windowScroll) {
72711          defaultView.scrollBy(0, diff);
72712        } else {
72713          scrollContainer.scrollTop += diff;
72714        }
72715      }
72716  
72717      /**
72718       * Adds a `selectionchange` listener to reset the scroll position to be
72719       * maintained.
72720       */
72721      function addSelectionChangeListener() {
72722        ownerDocument.addEventListener('selectionchange', computeCaretRectOnSelectionChange);
72723      }
72724  
72725      /**
72726       * Resets the scroll position to be maintained during a `selectionchange`
72727       * event. Also removes the listener, so it acts as a one-time listener.
72728       */
72729      function computeCaretRectOnSelectionChange() {
72730        ownerDocument.removeEventListener('selectionchange', computeCaretRectOnSelectionChange);
72731        computeCaretRectangle();
72732      }
72733  
72734      /**
72735       * Resets the scroll position to be maintained.
72736       */
72737      function computeCaretRectangle() {
72738        if (isSelectionEligibleForScroll()) {
72739          caretRect = (0,external_wp_dom_namespaceObject.computeCaretRect)(defaultView);
72740        }
72741      }
72742  
72743      /**
72744       * Checks if the current situation is eligible for scroll:
72745       * - There should be one and only one block selected.
72746       * - The component must contain the selection.
72747       * - The active element must be contenteditable.
72748       */
72749      function isSelectionEligibleForScroll() {
72750        return node.contains(ownerDocument.activeElement) && ownerDocument.activeElement.isContentEditable;
72751      }
72752      function isLastEditableNode() {
72753        const editableNodes = node.querySelectorAll('[contenteditable="true"]');
72754        const lastEditableNode = editableNodes[editableNodes.length - 1];
72755        return lastEditableNode === ownerDocument.activeElement;
72756      }
72757  
72758      // When the user scrolls or resizes, the scroll position should be
72759      // reset.
72760      defaultView.addEventListener('scroll', onScrollResize, true);
72761      defaultView.addEventListener('resize', onScrollResize, true);
72762      node.addEventListener('keydown', onKeyDown);
72763      node.addEventListener('keyup', maintainCaretPosition);
72764      node.addEventListener('mousedown', addSelectionChangeListener);
72765      node.addEventListener('touchstart', addSelectionChangeListener);
72766      return () => {
72767        defaultView.removeEventListener('scroll', onScrollResize, true);
72768        defaultView.removeEventListener('resize', onScrollResize, true);
72769        node.removeEventListener('keydown', onKeyDown);
72770        node.removeEventListener('keyup', maintainCaretPosition);
72771        node.removeEventListener('mousedown', addSelectionChangeListener);
72772        node.removeEventListener('touchstart', addSelectionChangeListener);
72773        ownerDocument.removeEventListener('selectionchange', computeCaretRectOnSelectionChange);
72774        defaultView.cancelAnimationFrame(scrollResizeRafId);
72775        defaultView.cancelAnimationFrame(onKeyDownRafId);
72776      };
72777    }, [hasSelectedBlock]);
72778  }
72779  function Typewriter({
72780    children
72781  }) {
72782    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
72783      ref: useTypewriter(),
72784      className: "block-editor__typewriter",
72785      children: children
72786    });
72787  }
72788  
72789  /**
72790   * The exported component. The implementation of Typewriter faced technical
72791   * challenges in Internet Explorer, and is simply skipped, rendering the given
72792   * props children instead.
72793   *
72794   * @type {Component}
72795   */
72796  const TypewriterOrIEBypass = isIE ? props => props.children : Typewriter;
72797  
72798  /**
72799   * Ensures that the text selection keeps the same vertical distance from the
72800   * viewport during keyboard events within this component. The vertical distance
72801   * can vary. It is the last clicked or scrolled to position.
72802   */
72803  /* harmony default export */ const typewriter = (TypewriterOrIEBypass);
72804  
72805  ;// ./node_modules/@wordpress/block-editor/build-module/components/recursion-provider/index.js
72806  /**
72807   * WordPress dependencies
72808   */
72809  
72810  
72811  
72812  /**
72813   * Internal dependencies
72814   */
72815  
72816  
72817  const RenderedRefsContext = (0,external_wp_element_namespaceObject.createContext)({});
72818  
72819  /**
72820   * Immutably adds an unique identifier to a set scoped for a given block type.
72821   *
72822   * @param {Object} renderedBlocks Rendered blocks grouped by block name
72823   * @param {string} blockName      Name of the block.
72824   * @param {*}      uniqueId       Any value that acts as a unique identifier for a block instance.
72825   *
72826   * @return {Object} The list of rendered blocks grouped by block name.
72827   */
72828  function addToBlockType(renderedBlocks, blockName, uniqueId) {
72829    const result = {
72830      ...renderedBlocks,
72831      [blockName]: renderedBlocks[blockName] ? new Set(renderedBlocks[blockName]) : new Set()
72832    };
72833    result[blockName].add(uniqueId);
72834    return result;
72835  }
72836  
72837  /**
72838   * A React context provider for use with the `useHasRecursion` hook to prevent recursive
72839   * renders.
72840   *
72841   * Wrap block content with this provider and provide the same `uniqueId` prop as used
72842   * with `useHasRecursion`.
72843   *
72844   * @param {Object}      props
72845   * @param {*}           props.uniqueId  Any value that acts as a unique identifier for a block instance.
72846   * @param {string}      props.blockName Optional block name.
72847   * @param {JSX.Element} props.children  React children.
72848   *
72849   * @return {JSX.Element} A React element.
72850   */
72851  function RecursionProvider({
72852    children,
72853    uniqueId,
72854    blockName = ''
72855  }) {
72856    const previouslyRenderedBlocks = (0,external_wp_element_namespaceObject.useContext)(RenderedRefsContext);
72857    const {
72858      name
72859    } = useBlockEditContext();
72860    blockName = blockName || name;
72861    const newRenderedBlocks = (0,external_wp_element_namespaceObject.useMemo)(() => addToBlockType(previouslyRenderedBlocks, blockName, uniqueId), [previouslyRenderedBlocks, blockName, uniqueId]);
72862    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(RenderedRefsContext.Provider, {
72863      value: newRenderedBlocks,
72864      children: children
72865    });
72866  }
72867  
72868  /**
72869   * A React hook for keeping track of blocks previously rendered up in the block
72870   * tree. Blocks susceptible to recursion can use this hook in their `Edit`
72871   * function to prevent said recursion.
72872   *
72873   * Use this with the `RecursionProvider` component, using the same `uniqueId` value
72874   * for both the hook and the provider.
72875   *
72876   * @param {*}      uniqueId  Any value that acts as a unique identifier for a block instance.
72877   * @param {string} blockName Optional block name.
72878   *
72879   * @return {boolean} A boolean describing whether the provided id has already been rendered.
72880   */
72881  function useHasRecursion(uniqueId, blockName = '') {
72882    const previouslyRenderedBlocks = (0,external_wp_element_namespaceObject.useContext)(RenderedRefsContext);
72883    const {
72884      name
72885    } = useBlockEditContext();
72886    blockName = blockName || name;
72887    return Boolean(previouslyRenderedBlocks[blockName]?.has(uniqueId));
72888  }
72889  const DeprecatedExperimentalRecursionProvider = props => {
72890    external_wp_deprecated_default()('wp.blockEditor.__experimentalRecursionProvider', {
72891      since: '6.5',
72892      alternative: 'wp.blockEditor.RecursionProvider'
72893    });
72894    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(RecursionProvider, {
72895      ...props
72896    });
72897  };
72898  const DeprecatedExperimentalUseHasRecursion = (...args) => {
72899    external_wp_deprecated_default()('wp.blockEditor.__experimentalUseHasRecursion', {
72900      since: '6.5',
72901      alternative: 'wp.blockEditor.useHasRecursion'
72902    });
72903    return useHasRecursion(...args);
72904  };
72905  
72906  ;// ./node_modules/@wordpress/block-editor/build-module/components/inspector-popover-header/index.js
72907  /**
72908   * WordPress dependencies
72909   */
72910  
72911  
72912  
72913  
72914  function InspectorPopoverHeader({
72915    title,
72916    help,
72917    actions = [],
72918    onClose
72919  }) {
72920    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalVStack, {
72921      className: "block-editor-inspector-popover-header",
72922      spacing: 4,
72923      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalHStack, {
72924        alignment: "center",
72925        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalHeading, {
72926          className: "block-editor-inspector-popover-header__heading",
72927          level: 2,
72928          size: 13,
72929          children: title
72930        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalSpacer, {}), actions.map(({
72931          label,
72932          icon,
72933          onClick
72934        }) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
72935          size: "small",
72936          className: "block-editor-inspector-popover-header__action",
72937          label: label,
72938          icon: icon,
72939          variant: !icon && 'tertiary',
72940          onClick: onClick,
72941          children: !icon && label
72942        }, label)), onClose && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
72943          size: "small",
72944          className: "block-editor-inspector-popover-header__action",
72945          label: (0,external_wp_i18n_namespaceObject.__)('Close'),
72946          icon: close_small,
72947          onClick: onClose
72948        })]
72949      }), help && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalText, {
72950        children: help
72951      })]
72952    });
72953  }
72954  
72955  ;// ./node_modules/@wordpress/block-editor/build-module/components/publish-date-time-picker/index.js
72956  /**
72957   * WordPress dependencies
72958   */
72959  
72960  
72961  
72962  
72963  
72964  /**
72965   * Internal dependencies
72966   */
72967  
72968  
72969  function PublishDateTimePicker({
72970    onClose,
72971    onChange,
72972    showPopoverHeaderActions,
72973    isCompact,
72974    currentDate,
72975    ...additionalProps
72976  }, ref) {
72977    const datePickerProps = {
72978      startOfWeek: (0,external_wp_date_namespaceObject.getSettings)().l10n.startOfWeek,
72979      onChange,
72980      currentDate: isCompact ? undefined : currentDate,
72981      currentTime: isCompact ? currentDate : undefined,
72982      ...additionalProps
72983    };
72984    const DatePickerComponent = isCompact ? external_wp_components_namespaceObject.TimePicker : external_wp_components_namespaceObject.DateTimePicker;
72985    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
72986      ref: ref,
72987      className: "block-editor-publish-date-time-picker",
72988      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(InspectorPopoverHeader, {
72989        title: (0,external_wp_i18n_namespaceObject.__)('Publish'),
72990        actions: showPopoverHeaderActions ? [{
72991          label: (0,external_wp_i18n_namespaceObject.__)('Now'),
72992          onClick: () => onChange?.(null)
72993        }] : undefined,
72994        onClose: onClose
72995      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(DatePickerComponent, {
72996        ...datePickerProps
72997      })]
72998    });
72999  }
73000  const PrivatePublishDateTimePicker = (0,external_wp_element_namespaceObject.forwardRef)(PublishDateTimePicker);
73001  function PublicPublishDateTimePicker(props, ref) {
73002    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PrivatePublishDateTimePicker, {
73003      ...props,
73004      showPopoverHeaderActions: true,
73005      isCompact: false,
73006      ref: ref
73007    });
73008  }
73009  /* harmony default export */ const publish_date_time_picker = ((0,external_wp_element_namespaceObject.forwardRef)(PublicPublishDateTimePicker));
73010  
73011  ;// ./node_modules/@wordpress/block-editor/build-module/components/index.js
73012  /*
73013   * Block Creation Components
73014   */
73015  
73016  
73017  
73018  
73019  
73020  
73021  
73022  
73023  
73024  
73025  
73026  
73027  
73028  
73029  
73030  
73031  
73032  
73033  
73034  
73035  
73036  
73037  
73038  
73039  
73040  
73041  
73042  
73043  
73044  
73045  
73046  
73047  
73048  
73049  
73050  
73051  
73052  
73053  
73054  
73055  
73056  
73057  
73058  
73059  
73060  
73061  
73062  
73063  
73064  
73065  
73066  
73067  
73068  
73069  
73070  
73071  
73072  
73073  
73074  
73075  
73076  
73077  
73078  
73079  
73080  
73081  
73082  
73083  
73084  
73085  /*
73086   * Content Related Components
73087   */
73088  
73089  
73090  
73091  
73092  
73093  
73094  
73095  
73096  
73097  
73098  
73099  
73100  
73101  
73102  
73103  
73104  
73105  
73106  
73107  
73108  
73109  
73110  
73111  
73112  
73113  
73114  
73115  
73116  
73117  
73118  
73119  
73120  
73121  
73122  
73123  
73124  
73125  
73126  
73127  
73128  /*
73129   * State Related Components
73130   */
73131  
73132  
73133  
73134  
73135  
73136  ;// ./node_modules/@wordpress/block-editor/build-module/elements/index.js
73137  const elements_ELEMENT_CLASS_NAMES = {
73138    button: 'wp-element-button',
73139    caption: 'wp-element-caption'
73140  };
73141  const __experimentalGetElementClassName = element => {
73142    return elements_ELEMENT_CLASS_NAMES[element] ? elements_ELEMENT_CLASS_NAMES[element] : '';
73143  };
73144  
73145  ;// ./node_modules/@wordpress/block-editor/build-module/utils/get-px-from-css-unit.js
73146  /**
73147   * This function was accidentally exposed for mobile/native usage.
73148   *
73149   * @deprecated
73150   *
73151   * @return {string} Empty string.
73152   */
73153  /* harmony default export */ const get_px_from_css_unit = (() => '');
73154  
73155  ;// ./node_modules/@wordpress/block-editor/build-module/utils/index.js
73156  
73157  
73158  
73159  
73160  ;// ./node_modules/@wordpress/block-editor/build-module/components/global-styles/image-settings-panel.js
73161  /**
73162   * WordPress dependencies
73163   */
73164  
73165  
73166  
73167  /**
73168   * Internal dependencies
73169   */
73170  
73171  
73172  function useHasImageSettingsPanel(name, value, inheritedValue) {
73173    // Note: If lightbox `value` exists, that means it was
73174    // defined via the the Global Styles UI and will NOT
73175    // be a boolean value or contain the `allowEditing` property,
73176    // so we should show the settings panel in those cases.
73177    return name === 'core/image' && inheritedValue?.lightbox?.allowEditing || !!value?.lightbox;
73178  }
73179  function ImageSettingsPanel({
73180    onChange,
73181    value,
73182    inheritedValue,
73183    panelId
73184  }) {
73185    const dropdownMenuProps = useToolsPanelDropdownMenuProps();
73186    const resetLightbox = () => {
73187      onChange(undefined);
73188    };
73189    const onChangeLightbox = newSetting => {
73190      onChange({
73191        enabled: newSetting
73192      });
73193    };
73194    let lightboxChecked = false;
73195    if (inheritedValue?.lightbox?.enabled) {
73196      lightboxChecked = inheritedValue.lightbox.enabled;
73197    }
73198    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_ReactJSXRuntime_namespaceObject.Fragment, {
73199      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanel, {
73200        label: (0,external_wp_i18n_namespaceObject._x)('Settings', 'Image settings'),
73201        resetAll: resetLightbox,
73202        panelId: panelId,
73203        dropdownMenuProps: dropdownMenuProps,
73204        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanelItem
73205        // We use the `userSettings` prop instead of `settings`, because `settings`
73206        // contains the core/theme values for the lightbox and we want to show the
73207        // "RESET" button ONLY when the user has explicitly set a value in the
73208        // Global Styles.
73209        , {
73210          hasValue: () => !!value?.lightbox,
73211          label: (0,external_wp_i18n_namespaceObject.__)('Enlarge on click'),
73212          onDeselect: resetLightbox,
73213          isShownByDefault: true,
73214          panelId: panelId,
73215          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToggleControl, {
73216            __nextHasNoMarginBottom: true,
73217            label: (0,external_wp_i18n_namespaceObject.__)('Enlarge on click'),
73218            checked: lightboxChecked,
73219            onChange: onChangeLightbox
73220          })
73221        })
73222      })
73223    });
73224  }
73225  
73226  ;// ./node_modules/@wordpress/block-editor/build-module/components/global-styles/advanced-panel.js
73227  /**
73228   * WordPress dependencies
73229   */
73230  
73231  
73232  
73233  
73234  /**
73235   * Internal dependencies
73236   */
73237  
73238  
73239  function AdvancedPanel({
73240    value,
73241    onChange,
73242    inheritedValue = value
73243  }) {
73244    // Custom CSS
73245    const [cssError, setCSSError] = (0,external_wp_element_namespaceObject.useState)(null);
73246    const customCSS = inheritedValue?.css;
73247    function handleOnChange(newValue) {
73248      onChange({
73249        ...value,
73250        css: newValue
73251      });
73252      if (cssError) {
73253        // Check if the new value is valid CSS, and pass a wrapping selector
73254        // to ensure that `transformStyles` validates the CSS. Note that the
73255        // wrapping selector here is not used in the actual output of any styles.
73256        const [transformed] = transform_styles([{
73257          css: newValue
73258        }], '.for-validation-only');
73259        if (transformed) {
73260          setCSSError(null);
73261        }
73262      }
73263    }
73264    function handleOnBlur(event) {
73265      if (!event?.target?.value) {
73266        setCSSError(null);
73267        return;
73268      }
73269  
73270      // Check if the new value is valid CSS, and pass a wrapping selector
73271      // to ensure that `transformStyles` validates the CSS. Note that the
73272      // wrapping selector here is not used in the actual output of any styles.
73273      const [transformed] = transform_styles([{
73274        css: event.target.value
73275      }], '.for-validation-only');
73276      setCSSError(transformed === null ? (0,external_wp_i18n_namespaceObject.__)('There is an error with your CSS structure.') : null);
73277    }
73278    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalVStack, {
73279      spacing: 3,
73280      children: [cssError && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Notice, {
73281        status: "error",
73282        onRemove: () => setCSSError(null),
73283        children: cssError
73284      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.TextareaControl, {
73285        label: (0,external_wp_i18n_namespaceObject.__)('Additional CSS'),
73286        __nextHasNoMarginBottom: true,
73287        value: customCSS,
73288        onChange: newValue => handleOnChange(newValue),
73289        onBlur: handleOnBlur,
73290        className: "block-editor-global-styles-advanced-panel__custom-css-input",
73291        spellCheck: false
73292      })]
73293    });
73294  }
73295  
73296  ;// ./node_modules/memize/dist/index.js
73297  /**
73298   * Memize options object.
73299   *
73300   * @typedef MemizeOptions
73301   *
73302   * @property {number} [maxSize] Maximum size of the cache.
73303   */
73304  
73305  /**
73306   * Internal cache entry.
73307   *
73308   * @typedef MemizeCacheNode
73309   *
73310   * @property {?MemizeCacheNode|undefined} [prev] Previous node.
73311   * @property {?MemizeCacheNode|undefined} [next] Next node.
73312   * @property {Array<*>}                   args   Function arguments for cache
73313   *                                               entry.
73314   * @property {*}                          val    Function result.
73315   */
73316  
73317  /**
73318   * Properties of the enhanced function for controlling cache.
73319   *
73320   * @typedef MemizeMemoizedFunction
73321   *
73322   * @property {()=>void} clear Clear the cache.
73323   */
73324  
73325  /**
73326   * Accepts a function to be memoized, and returns a new memoized function, with
73327   * optional options.
73328   *
73329   * @template {(...args: any[]) => any} F
73330   *
73331   * @param {F}             fn        Function to memoize.
73332   * @param {MemizeOptions} [options] Options object.
73333   *
73334   * @return {((...args: Parameters<F>) => ReturnType<F>) & MemizeMemoizedFunction} Memoized function.
73335   */
73336  function memize(fn, options) {
73337      var size = 0;
73338  
73339      /** @type {?MemizeCacheNode|undefined} */
73340      var head;
73341  
73342      /** @type {?MemizeCacheNode|undefined} */
73343      var tail;
73344  
73345      options = options || {};
73346  
73347  	function memoized(/* ...args */) {
73348          var node = head,
73349              len = arguments.length,
73350              args,
73351              i;
73352  
73353          searchCache: while (node) {
73354              // Perform a shallow equality test to confirm that whether the node
73355              // under test is a candidate for the arguments passed. Two arrays
73356              // are shallowly equal if their length matches and each entry is
73357              // strictly equal between the two sets. Avoid abstracting to a
73358              // function which could incur an arguments leaking deoptimization.
73359  
73360              // Check whether node arguments match arguments length
73361              if (node.args.length !== arguments.length) {
73362                  node = node.next;
73363                  continue;
73364              }
73365  
73366              // Check whether node arguments match arguments values
73367              for (i = 0; i < len; i++) {
73368                  if (node.args[i] !== arguments[i]) {
73369                      node = node.next;
73370                      continue searchCache;
73371                  }
73372              }
73373  
73374              // At this point we can assume we've found a match
73375  
73376              // Surface matched node to head if not already
73377              if (node !== head) {
73378                  // As tail, shift to previous. Must only shift if not also
73379                  // head, since if both head and tail, there is no previous.
73380                  if (node === tail) {
73381                      tail = node.prev;
73382                  }
73383  
73384                  // Adjust siblings to point to each other. If node was tail,
73385                  // this also handles new tail's empty `next` assignment.
73386                  /** @type {MemizeCacheNode} */ (node.prev).next = node.next;
73387                  if (node.next) {
73388                      node.next.prev = node.prev;
73389                  }
73390  
73391                  node.next = head;
73392                  node.prev = null;
73393                  /** @type {MemizeCacheNode} */ (head).prev = node;
73394                  head = node;
73395              }
73396  
73397              // Return immediately
73398              return node.val;
73399          }
73400  
73401          // No cached value found. Continue to insertion phase:
73402  
73403          // Create a copy of arguments (avoid leaking deoptimization)
73404          args = new Array(len);
73405          for (i = 0; i < len; i++) {
73406              args[i] = arguments[i];
73407          }
73408  
73409          node = {
73410              args: args,
73411  
73412              // Generate the result from original function
73413              val: fn.apply(null, args),
73414          };
73415  
73416          // Don't need to check whether node is already head, since it would
73417          // have been returned above already if it was
73418  
73419          // Shift existing head down list
73420          if (head) {
73421              head.prev = node;
73422              node.next = head;
73423          } else {
73424              // If no head, follows that there's no tail (at initial or reset)
73425              tail = node;
73426          }
73427  
73428          // Trim tail if we're reached max size and are pending cache insertion
73429          if (size === /** @type {MemizeOptions} */ (options).maxSize) {
73430              tail = /** @type {MemizeCacheNode} */ (tail).prev;
73431              /** @type {MemizeCacheNode} */ (tail).next = null;
73432          } else {
73433              size++;
73434          }
73435  
73436          head = node;
73437  
73438          return node.val;
73439      }
73440  
73441      memoized.clear = function () {
73442          head = null;
73443          tail = null;
73444          size = 0;
73445      };
73446  
73447      // Ignore reason: There's not a clear solution to create an intersection of
73448      // the function with additional properties, where the goal is to retain the
73449      // function signature of the incoming argument and add control properties
73450      // on the return value.
73451  
73452      // @ts-ignore
73453      return memoized;
73454  }
73455  
73456  
73457  
73458  ;// ./node_modules/@wordpress/block-editor/build-module/components/global-styles/get-global-styles-changes.js
73459  /**
73460   * External dependencies
73461   */
73462  
73463  
73464  /**
73465   * WordPress dependencies
73466   */
73467  
73468  
73469  const globalStylesChangesCache = new Map();
73470  const get_global_styles_changes_EMPTY_ARRAY = [];
73471  const translationMap = {
73472    caption: (0,external_wp_i18n_namespaceObject.__)('Caption'),
73473    link: (0,external_wp_i18n_namespaceObject.__)('Link'),
73474    button: (0,external_wp_i18n_namespaceObject.__)('Button'),
73475    heading: (0,external_wp_i18n_namespaceObject.__)('Heading'),
73476    h1: (0,external_wp_i18n_namespaceObject.__)('H1'),
73477    h2: (0,external_wp_i18n_namespaceObject.__)('H2'),
73478    h3: (0,external_wp_i18n_namespaceObject.__)('H3'),
73479    h4: (0,external_wp_i18n_namespaceObject.__)('H4'),
73480    h5: (0,external_wp_i18n_namespaceObject.__)('H5'),
73481    h6: (0,external_wp_i18n_namespaceObject.__)('H6'),
73482    'settings.color': (0,external_wp_i18n_namespaceObject.__)('Color'),
73483    'settings.typography': (0,external_wp_i18n_namespaceObject.__)('Typography'),
73484    'styles.color': (0,external_wp_i18n_namespaceObject.__)('Colors'),
73485    'styles.spacing': (0,external_wp_i18n_namespaceObject.__)('Spacing'),
73486    'styles.background': (0,external_wp_i18n_namespaceObject.__)('Background'),
73487    'styles.typography': (0,external_wp_i18n_namespaceObject.__)('Typography')
73488  };
73489  const getBlockNames = memize(() => (0,external_wp_blocks_namespaceObject.getBlockTypes)().reduce((accumulator, {
73490    name,
73491    title
73492  }) => {
73493    accumulator[name] = title;
73494    return accumulator;
73495  }, {}));
73496  const isObject = obj => obj !== null && typeof obj === 'object';
73497  
73498  /**
73499   * Get the translation for a given global styles key.
73500   * @param {string} key A key representing a path to a global style property or setting.
73501   * @return {string|undefined}                A translated key or undefined if no translation exists.
73502   */
73503  function getTranslation(key) {
73504    if (translationMap[key]) {
73505      return translationMap[key];
73506    }
73507    const keyArray = key.split('.');
73508    if (keyArray?.[0] === 'blocks') {
73509      const blockName = getBlockNames()?.[keyArray[1]];
73510      return blockName || keyArray[1];
73511    }
73512    if (keyArray?.[0] === 'elements') {
73513      return translationMap[keyArray[1]] || keyArray[1];
73514    }
73515    return undefined;
73516  }
73517  
73518  /**
73519   * A deep comparison of two objects, optimized for comparing global styles.
73520   * @param {Object} changedObject  The changed object to compare.
73521   * @param {Object} originalObject The original object to compare against.
73522   * @param {string} parentPath     A key/value pair object of block names and their rendered titles.
73523   * @return {string[]}             An array of paths whose values have changed.
73524   */
73525  function deepCompare(changedObject, originalObject, parentPath = '') {
73526    // We have two non-object values to compare.
73527    if (!isObject(changedObject) && !isObject(originalObject)) {
73528      /*
73529       * Only return a path if the value has changed.
73530       * And then only the path name up to 2 levels deep.
73531       */
73532      return changedObject !== originalObject ? parentPath.split('.').slice(0, 2).join('.') : undefined;
73533    }
73534  
73535    // Enable comparison when an object doesn't have a corresponding property to compare.
73536    changedObject = isObject(changedObject) ? changedObject : {};
73537    originalObject = isObject(originalObject) ? originalObject : {};
73538    const allKeys = new Set([...Object.keys(changedObject), ...Object.keys(originalObject)]);
73539    let diffs = [];
73540    for (const key of allKeys) {
73541      const path = parentPath ? parentPath + '.' + key : key;
73542      const changedPath = deepCompare(changedObject[key], originalObject[key], path);
73543      if (changedPath) {
73544        diffs = diffs.concat(changedPath);
73545      }
73546    }
73547    return diffs;
73548  }
73549  
73550  /**
73551   * Returns an array of translated summarized global styles changes.
73552   * Results are cached using a Map() key of `JSON.stringify( { next, previous } )`.
73553   *
73554   * @param {Object} next     The changed object to compare.
73555   * @param {Object} previous The original object to compare against.
73556   * @return {Array[]}        A 2-dimensional array of tuples: [ "group", "translated change" ].
73557   */
73558  function getGlobalStylesChangelist(next, previous) {
73559    const cacheKey = JSON.stringify({
73560      next,
73561      previous
73562    });
73563    if (globalStylesChangesCache.has(cacheKey)) {
73564      return globalStylesChangesCache.get(cacheKey);
73565    }
73566  
73567    /*
73568     * Compare the two changesets with normalized keys.
73569     * The order of these keys determines the order in which
73570     * they'll appear in the results.
73571     */
73572    const changedValueTree = deepCompare({
73573      styles: {
73574        background: next?.styles?.background,
73575        color: next?.styles?.color,
73576        typography: next?.styles?.typography,
73577        spacing: next?.styles?.spacing
73578      },
73579      blocks: next?.styles?.blocks,
73580      elements: next?.styles?.elements,
73581      settings: next?.settings
73582    }, {
73583      styles: {
73584        background: previous?.styles?.background,
73585        color: previous?.styles?.color,
73586        typography: previous?.styles?.typography,
73587        spacing: previous?.styles?.spacing
73588      },
73589      blocks: previous?.styles?.blocks,
73590      elements: previous?.styles?.elements,
73591      settings: previous?.settings
73592    });
73593    if (!changedValueTree.length) {
73594      globalStylesChangesCache.set(cacheKey, get_global_styles_changes_EMPTY_ARRAY);
73595      return get_global_styles_changes_EMPTY_ARRAY;
73596    }
73597  
73598    // Remove duplicate results.
73599    const result = [...new Set(changedValueTree)]
73600    /*
73601     * Translate the keys.
73602     * Remove empty translations.
73603     */.reduce((acc, curr) => {
73604      const translation = getTranslation(curr);
73605      if (translation) {
73606        acc.push([curr.split('.')[0], translation]);
73607      }
73608      return acc;
73609    }, []);
73610    globalStylesChangesCache.set(cacheKey, result);
73611    return result;
73612  }
73613  
73614  /**
73615   * From a getGlobalStylesChangelist() result, returns an array of translated global styles changes, grouped by type.
73616   * The types are 'blocks', 'elements', 'settings', and 'styles'.
73617   *
73618   * @param {Object}              next     The changed object to compare.
73619   * @param {Object}              previous The original object to compare against.
73620   * @param {{maxResults:number}} options  Options. maxResults: results to return before truncating.
73621   * @return {string[]}                    An array of translated changes.
73622   */
73623  function getGlobalStylesChanges(next, previous, options = {}) {
73624    let changeList = getGlobalStylesChangelist(next, previous);
73625    const changesLength = changeList.length;
73626    const {
73627      maxResults
73628    } = options;
73629    if (changesLength) {
73630      // Truncate to `n` results if necessary.
73631      if (!!maxResults && changesLength > maxResults) {
73632        changeList = changeList.slice(0, maxResults);
73633      }
73634      return Object.entries(changeList.reduce((acc, curr) => {
73635        const group = acc[curr[0]] || [];
73636        if (!group.includes(curr[1])) {
73637          acc[curr[0]] = [...group, curr[1]];
73638        }
73639        return acc;
73640      }, {})).map(([key, changeValues]) => {
73641        const changeValuesLength = changeValues.length;
73642        const joinedChangesValue = changeValues.join(/* translators: Used between list items, there is a space after the comma. */
73643        (0,external_wp_i18n_namespaceObject.__)(', ') // eslint-disable-line @wordpress/i18n-no-flanking-whitespace
73644        );
73645        switch (key) {
73646          case 'blocks':
73647            {
73648              return (0,external_wp_i18n_namespaceObject.sprintf)(
73649              // translators: %s: a list of block names separated by a comma.
73650              (0,external_wp_i18n_namespaceObject._n)('%s block.', '%s blocks.', changeValuesLength), joinedChangesValue);
73651            }
73652          case 'elements':
73653            {
73654              return (0,external_wp_i18n_namespaceObject.sprintf)(
73655              // translators: %s: a list of element names separated by a comma.
73656              (0,external_wp_i18n_namespaceObject._n)('%s element.', '%s elements.', changeValuesLength), joinedChangesValue);
73657            }
73658          case 'settings':
73659            {
73660              return (0,external_wp_i18n_namespaceObject.sprintf)(
73661              // translators: %s: a list of theme.json setting labels separated by a comma.
73662              (0,external_wp_i18n_namespaceObject.__)('%s settings.'), joinedChangesValue);
73663            }
73664          case 'styles':
73665            {
73666              return (0,external_wp_i18n_namespaceObject.sprintf)(
73667              // translators: %s: a list of theme.json top-level styles labels separated by a comma.
73668              (0,external_wp_i18n_namespaceObject.__)('%s styles.'), joinedChangesValue);
73669            }
73670          default:
73671            {
73672              return (0,external_wp_i18n_namespaceObject.sprintf)(
73673              // translators: %s: a list of global styles changes separated by a comma.
73674              (0,external_wp_i18n_namespaceObject.__)('%s.'), joinedChangesValue);
73675            }
73676        }
73677      });
73678    }
73679    return get_global_styles_changes_EMPTY_ARRAY;
73680  }
73681  
73682  ;// ./node_modules/@wordpress/block-editor/build-module/components/global-styles/index.js
73683  
73684  
73685  
73686  
73687  
73688  
73689  
73690  
73691  
73692  
73693  
73694  
73695  
73696  
73697  
73698  ;// ./node_modules/@wordpress/block-editor/build-module/components/rich-text/get-rich-text-values.js
73699  /**
73700   * WordPress dependencies
73701   */
73702  
73703  
73704  
73705  
73706  /**
73707   * Internal dependencies
73708   */
73709  
73710  
73711  
73712  /*
73713   * This function is similar to `@wordpress/element`'s `renderToString` function,
73714   * except that it does not render the elements to a string, but instead collects
73715   * the values of all rich text `Content` elements.
73716   */
73717  
73718  function addValuesForElement(element, values, innerBlocks) {
73719    if (null === element || undefined === element || false === element) {
73720      return;
73721    }
73722    if (Array.isArray(element)) {
73723      return addValuesForElements(element, values, innerBlocks);
73724    }
73725    switch (typeof element) {
73726      case 'string':
73727      case 'number':
73728        return;
73729    }
73730    const {
73731      type,
73732      props
73733    } = element;
73734    switch (type) {
73735      case external_wp_element_namespaceObject.StrictMode:
73736      case external_wp_element_namespaceObject.Fragment:
73737        return addValuesForElements(props.children, values, innerBlocks);
73738      case external_wp_element_namespaceObject.RawHTML:
73739        return;
73740      case inner_blocks.Content:
73741        return addValuesForBlocks(values, innerBlocks);
73742      case Content:
73743        values.push(props.value);
73744        return;
73745    }
73746    switch (typeof type) {
73747      case 'string':
73748        if (typeof props.children !== 'undefined') {
73749          return addValuesForElements(props.children, values, innerBlocks);
73750        }
73751        return;
73752      case 'function':
73753        const el = type.prototype && typeof type.prototype.render === 'function' ? new type(props).render() : type(props);
73754        return addValuesForElement(el, values, innerBlocks);
73755    }
73756  }
73757  function addValuesForElements(children, ...args) {
73758    children = Array.isArray(children) ? children : [children];
73759    for (let i = 0; i < children.length; i++) {
73760      addValuesForElement(children[i], ...args);
73761    }
73762  }
73763  function addValuesForBlocks(values, blocks) {
73764    for (let i = 0; i < blocks.length; i++) {
73765      const {
73766        name,
73767        attributes,
73768        innerBlocks
73769      } = blocks[i];
73770      const saveElement = (0,external_wp_blocks_namespaceObject.getSaveElement)(name, attributes,
73771      /*#__PURE__*/
73772      // Instead of letting save elements use `useInnerBlocksProps.save`,
73773      // force them to use InnerBlocks.Content instead so we can intercept
73774      // a single component.
73775      (0,external_ReactJSXRuntime_namespaceObject.jsx)(inner_blocks.Content, {}));
73776      addValuesForElement(saveElement, values, innerBlocks);
73777    }
73778  }
73779  function getRichTextValues(blocks = []) {
73780    external_wp_blocks_namespaceObject.__unstableGetBlockProps.skipFilters = true;
73781    const values = [];
73782    addValuesForBlocks(values, blocks);
73783    external_wp_blocks_namespaceObject.__unstableGetBlockProps.skipFilters = false;
73784    return values.map(value => value instanceof external_wp_richText_namespaceObject.RichTextData ? value : external_wp_richText_namespaceObject.RichTextData.fromHTMLString(value));
73785  }
73786  
73787  ;// ./node_modules/@wordpress/block-editor/build-module/components/resizable-box-popover/index.js
73788  /**
73789   * WordPress dependencies
73790   */
73791  
73792  
73793  /**
73794   * Internal dependencies
73795   */
73796  
73797  
73798  function ResizableBoxPopover({
73799    clientId,
73800    resizableBoxProps,
73801    ...props
73802  }) {
73803    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(cover, {
73804      clientId: clientId,
73805      __unstablePopoverSlot: "block-toolbar",
73806      ...props,
73807      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ResizableBox, {
73808        ...resizableBoxProps
73809      })
73810    });
73811  }
73812  
73813  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-manager/checklist.js
73814  /**
73815   * WordPress dependencies
73816   */
73817  
73818  
73819  /**
73820   * Internal dependencies
73821   */
73822  
73823  
73824  function BlockTypesChecklist({
73825    blockTypes,
73826    value,
73827    onItemChange
73828  }) {
73829    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("ul", {
73830      className: "block-editor-block-manager__checklist",
73831      children: blockTypes.map(blockType => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("li", {
73832        className: "block-editor-block-manager__checklist-item",
73833        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.CheckboxControl, {
73834          __nextHasNoMarginBottom: true,
73835          label: blockType.title,
73836          checked: value.includes(blockType.name),
73837          onChange: (...args) => onItemChange(blockType, ...args)
73838        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_icon, {
73839          icon: blockType.icon
73840        })]
73841      }, blockType.name))
73842    });
73843  }
73844  /* harmony default export */ const checklist = (BlockTypesChecklist);
73845  
73846  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-manager/category.js
73847  /**
73848   * WordPress dependencies
73849   */
73850  
73851  
73852  
73853  
73854  /**
73855   * Internal dependencies
73856   */
73857  
73858  
73859  function BlockManagerCategory({
73860    title,
73861    blockTypes,
73862    selectedBlockTypes,
73863    onChange
73864  }) {
73865    const instanceId = (0,external_wp_compose_namespaceObject.useInstanceId)(BlockManagerCategory);
73866    const toggleVisible = (0,external_wp_element_namespaceObject.useCallback)((blockType, nextIsChecked) => {
73867      if (nextIsChecked) {
73868        onChange([...selectedBlockTypes, blockType]);
73869      } else {
73870        onChange(selectedBlockTypes.filter(({
73871          name
73872        }) => name !== blockType.name));
73873      }
73874    }, [selectedBlockTypes, onChange]);
73875    const toggleAllVisible = (0,external_wp_element_namespaceObject.useCallback)(nextIsChecked => {
73876      if (nextIsChecked) {
73877        onChange([...selectedBlockTypes, ...blockTypes.filter(blockType => !selectedBlockTypes.find(({
73878          name
73879        }) => name === blockType.name))]);
73880      } else {
73881        onChange(selectedBlockTypes.filter(selectedBlockType => !blockTypes.find(({
73882          name
73883        }) => name === selectedBlockType.name)));
73884      }
73885    }, [blockTypes, selectedBlockTypes, onChange]);
73886    if (!blockTypes.length) {
73887      return null;
73888    }
73889    const checkedBlockNames = blockTypes.map(({
73890      name
73891    }) => name).filter(type => (selectedBlockTypes !== null && selectedBlockTypes !== void 0 ? selectedBlockTypes : []).some(selectedBlockType => selectedBlockType.name === type));
73892    const titleId = 'block-editor-block-manager__category-title-' + instanceId;
73893    const isAllChecked = checkedBlockNames.length === blockTypes.length;
73894    const isIndeterminate = !isAllChecked && checkedBlockNames.length > 0;
73895    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
73896      role: "group",
73897      "aria-labelledby": titleId,
73898      className: "block-editor-block-manager__category",
73899      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.CheckboxControl, {
73900        __nextHasNoMarginBottom: true,
73901        checked: isAllChecked,
73902        onChange: toggleAllVisible,
73903        className: "block-editor-block-manager__category-title",
73904        indeterminate: isIndeterminate,
73905        label: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("span", {
73906          id: titleId,
73907          children: title
73908        })
73909      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(checklist, {
73910        blockTypes: blockTypes,
73911        value: checkedBlockNames,
73912        onItemChange: toggleVisible
73913      })]
73914    });
73915  }
73916  /* harmony default export */ const block_manager_category = (BlockManagerCategory);
73917  
73918  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-manager/index.js
73919  /**
73920   * WordPress dependencies
73921   */
73922  
73923  
73924  
73925  
73926  
73927  
73928  
73929  
73930  /**
73931   * Internal dependencies
73932   */
73933  
73934  
73935  /**
73936   * Provides a list of blocks with checkboxes.
73937   *
73938   * @param {Object}   props                    Props.
73939   * @param {Array}    props.blockTypes         An array of blocks.
73940   * @param {Array}    props.selectedBlockTypes An array of selected blocks.
73941   * @param {Function} props.onChange           Function to be called when the selected blocks change.
73942   */
73943  
73944  function BlockManager({
73945    blockTypes,
73946    selectedBlockTypes,
73947    onChange
73948  }) {
73949    const debouncedSpeak = (0,external_wp_compose_namespaceObject.useDebounce)(external_wp_a11y_namespaceObject.speak, 500);
73950    const [search, setSearch] = (0,external_wp_element_namespaceObject.useState)('');
73951    const {
73952      categories,
73953      isMatchingSearchTerm
73954    } = (0,external_wp_data_namespaceObject.useSelect)(select => {
73955      return {
73956        categories: select(external_wp_blocks_namespaceObject.store).getCategories(),
73957        isMatchingSearchTerm: select(external_wp_blocks_namespaceObject.store).isMatchingSearchTerm
73958      };
73959    }, []);
73960    function enableAllBlockTypes() {
73961      onChange(blockTypes);
73962    }
73963    const filteredBlockTypes = blockTypes.filter(blockType => {
73964      return !search || isMatchingSearchTerm(blockType, search);
73965    });
73966    const numberOfHiddenBlocks = blockTypes.length - selectedBlockTypes.length;
73967  
73968    // Announce search results on change
73969    (0,external_wp_element_namespaceObject.useEffect)(() => {
73970      if (!search) {
73971        return;
73972      }
73973      const count = filteredBlockTypes.length;
73974      const resultsFoundMessage = (0,external_wp_i18n_namespaceObject.sprintf)(/* translators: %d: number of results. */
73975      (0,external_wp_i18n_namespaceObject._n)('%d result found.', '%d results found.', count), count);
73976      debouncedSpeak(resultsFoundMessage);
73977    }, [filteredBlockTypes?.length, search, debouncedSpeak]);
73978    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
73979      className: "block-editor-block-manager__content",
73980      children: [!!numberOfHiddenBlocks && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
73981        className: "block-editor-block-manager__disabled-blocks-count",
73982        children: [(0,external_wp_i18n_namespaceObject.sprintf)(/* translators: %d: number of blocks. */
73983        (0,external_wp_i18n_namespaceObject._n)('%d block is hidden.', '%d blocks are hidden.', numberOfHiddenBlocks), numberOfHiddenBlocks), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
73984          __next40pxDefaultSize: true,
73985          variant: "link",
73986          onClick: enableAllBlockTypes,
73987          children: (0,external_wp_i18n_namespaceObject.__)('Reset')
73988        })]
73989      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.SearchControl, {
73990        __nextHasNoMarginBottom: true,
73991        label: (0,external_wp_i18n_namespaceObject.__)('Search for a block'),
73992        placeholder: (0,external_wp_i18n_namespaceObject.__)('Search for a block'),
73993        value: search,
73994        onChange: nextSearch => setSearch(nextSearch),
73995        className: "block-editor-block-manager__search"
73996      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
73997        tabIndex: "0",
73998        role: "region",
73999        "aria-label": (0,external_wp_i18n_namespaceObject.__)('Available block types'),
74000        className: "block-editor-block-manager__results",
74001        children: [filteredBlockTypes.length === 0 && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("p", {
74002          className: "block-editor-block-manager__no-results",
74003          children: (0,external_wp_i18n_namespaceObject.__)('No blocks found.')
74004        }), categories.map(category => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_manager_category, {
74005          title: category.title,
74006          blockTypes: filteredBlockTypes.filter(blockType => blockType.category === category.slug),
74007          selectedBlockTypes: selectedBlockTypes,
74008          onChange: onChange
74009        }, category.slug)), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_manager_category, {
74010          title: (0,external_wp_i18n_namespaceObject.__)('Uncategorized'),
74011          blockTypes: filteredBlockTypes.filter(({
74012            category
74013          }) => !category),
74014          selectedBlockTypes: selectedBlockTypes,
74015          onChange: onChange
74016        })]
74017      })]
74018    });
74019  }
74020  
74021  ;// ./node_modules/@wordpress/block-editor/build-module/components/block-removal-warning-modal/index.js
74022  /**
74023   * WordPress dependencies
74024   */
74025  
74026  
74027  
74028  
74029  
74030  /**
74031   * Internal dependencies
74032   */
74033  
74034  
74035  
74036  function BlockRemovalWarningModal({
74037    rules
74038  }) {
74039    const {
74040      clientIds,
74041      selectPrevious,
74042      message
74043    } = (0,external_wp_data_namespaceObject.useSelect)(select => unlock(select(store)).getRemovalPromptData());
74044    const {
74045      clearBlockRemovalPrompt,
74046      setBlockRemovalRules,
74047      privateRemoveBlocks
74048    } = unlock((0,external_wp_data_namespaceObject.useDispatch)(store));
74049  
74050    // Load block removal rules, simultaneously signalling that the block
74051    // removal prompt is in place.
74052    (0,external_wp_element_namespaceObject.useEffect)(() => {
74053      setBlockRemovalRules(rules);
74054      return () => {
74055        setBlockRemovalRules();
74056      };
74057    }, [rules, setBlockRemovalRules]);
74058    if (!message) {
74059      return;
74060    }
74061    const onConfirmRemoval = () => {
74062      privateRemoveBlocks(clientIds, selectPrevious, /* force */true);
74063      clearBlockRemovalPrompt();
74064    };
74065    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.Modal, {
74066      title: (0,external_wp_i18n_namespaceObject.__)('Be careful!'),
74067      onRequestClose: clearBlockRemovalPrompt,
74068      size: "medium",
74069      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("p", {
74070        children: message
74071      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalHStack, {
74072        justify: "right",
74073        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
74074          variant: "tertiary",
74075          onClick: clearBlockRemovalPrompt,
74076          __next40pxDefaultSize: true,
74077          children: (0,external_wp_i18n_namespaceObject.__)('Cancel')
74078        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
74079          variant: "primary",
74080          onClick: onConfirmRemoval,
74081          __next40pxDefaultSize: true,
74082          children: (0,external_wp_i18n_namespaceObject.__)('Delete')
74083        })]
74084      })]
74085    });
74086  }
74087  
74088  ;// ./node_modules/@wordpress/block-editor/build-module/components/dimensions-tool/scale-tool.js
74089  /**
74090   * WordPress dependencies
74091   */
74092  
74093  
74094  
74095  
74096  /**
74097   * @typedef {import('@wordpress/components/build-types/select-control/types').SelectControlProps} SelectControlProps
74098   */
74099  
74100  /**
74101   * The descriptions are purposely made generic as object-fit could be used for
74102   * any replaced element. Provide your own set of options if you need different
74103   * help text or labels.
74104   *
74105   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/Replaced_element
74106   *
74107   * @type {SelectControlProps[]}
74108   */
74109  
74110  const DEFAULT_SCALE_OPTIONS = [{
74111    value: 'fill',
74112    label: (0,external_wp_i18n_namespaceObject._x)('Fill', 'Scale option for dimensions control'),
74113    help: (0,external_wp_i18n_namespaceObject.__)('Fill the space by stretching the content.')
74114  }, {
74115    value: 'contain',
74116    label: (0,external_wp_i18n_namespaceObject._x)('Contain', 'Scale option for dimensions control'),
74117    help: (0,external_wp_i18n_namespaceObject.__)('Fit the content to the space without clipping.')
74118  }, {
74119    value: 'cover',
74120    label: (0,external_wp_i18n_namespaceObject._x)('Cover', 'Scale option for dimensions control'),
74121    help: (0,external_wp_i18n_namespaceObject.__)("Fill the space by clipping what doesn't fit.")
74122  }, {
74123    value: 'none',
74124    label: (0,external_wp_i18n_namespaceObject._x)('None', 'Scale option for dimensions control'),
74125    help: (0,external_wp_i18n_namespaceObject.__)('Do not adjust the sizing of the content. Content that is too large will be clipped, and content that is too small will have additional padding.')
74126  }, {
74127    value: 'scale-down',
74128    label: (0,external_wp_i18n_namespaceObject._x)('Scale down', 'Scale option for dimensions control'),
74129    help: (0,external_wp_i18n_namespaceObject.__)('Scale down the content to fit the space if it is too big. Content that is too small will have additional padding.')
74130  }];
74131  
74132  /**
74133   * @callback ScaleToolPropsOnChange
74134   * @param {string} nextValue New scale value.
74135   * @return {void}
74136   */
74137  
74138  /**
74139   * @typedef {Object} ScaleToolProps
74140   * @property {string}                 [panelId]               ID of the panel that contains the controls.
74141   * @property {string}                 [value]                 Current scale value.
74142   * @property {ScaleToolPropsOnChange} [onChange]              Callback to update the scale value.
74143   * @property {SelectControlProps[]}   [options]               Scale options.
74144   * @property {string}                 [defaultValue]          Default scale value.
74145   * @property {boolean}                [showControl=true]      Whether to show the control.
74146   * @property {boolean}                [isShownByDefault=true] Whether the tool panel is shown by default.
74147   */
74148  
74149  /**
74150   * A tool to select the CSS object-fit property for the image.
74151   *
74152   * @param {ScaleToolProps} props
74153   *
74154   * @return {import('react').ReactElement} The scale tool.
74155   */
74156  function ScaleTool({
74157    panelId,
74158    value,
74159    onChange,
74160    options = DEFAULT_SCALE_OPTIONS,
74161    defaultValue = DEFAULT_SCALE_OPTIONS[0].value,
74162    isShownByDefault = true
74163  }) {
74164    // Match the CSS default so if the value is used directly in CSS it will look correct in the control.
74165    const displayValue = value !== null && value !== void 0 ? value : 'fill';
74166    const scaleHelp = (0,external_wp_element_namespaceObject.useMemo)(() => {
74167      return options.reduce((acc, option) => {
74168        acc[option.value] = option.help;
74169        return acc;
74170      }, {});
74171    }, [options]);
74172    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanelItem, {
74173      label: (0,external_wp_i18n_namespaceObject.__)('Scale'),
74174      isShownByDefault: isShownByDefault,
74175      hasValue: () => displayValue !== defaultValue,
74176      onDeselect: () => onChange(defaultValue),
74177      panelId: panelId,
74178      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControl, {
74179        __nextHasNoMarginBottom: true,
74180        label: (0,external_wp_i18n_namespaceObject.__)('Scale'),
74181        isBlock: true,
74182        help: scaleHelp[displayValue],
74183        value: displayValue,
74184        onChange: onChange,
74185        size: "__unstable-large",
74186        children: options.map(option => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControlOption, {
74187          ...option
74188        }, option.value))
74189      })
74190    });
74191  }
74192  
74193  ;// ./node_modules/@babel/runtime/helpers/esm/extends.js
74194  function extends_extends() {
74195    return extends_extends = Object.assign ? Object.assign.bind() : function (n) {
74196      for (var e = 1; e < arguments.length; e++) {
74197        var t = arguments[e];
74198        for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
74199      }
74200      return n;
74201    }, extends_extends.apply(null, arguments);
74202  }
74203  
74204  ;// ./node_modules/@emotion/memoize/dist/emotion-memoize.esm.js
74205  function memoize(fn) {
74206    var cache = Object.create(null);
74207    return function (arg) {
74208      if (cache[arg] === undefined) cache[arg] = fn(arg);
74209      return cache[arg];
74210    };
74211  }
74212  
74213  
74214  
74215  ;// ./node_modules/@emotion/styled/node_modules/@emotion/is-prop-valid/dist/emotion-is-prop-valid.esm.js
74216  
74217  
74218  var reactPropsRegex = /^((children|dangerouslySetInnerHTML|key|ref|autoFocus|defaultValue|defaultChecked|innerHTML|suppressContentEditableWarning|suppressHydrationWarning|valueLink|abbr|accept|acceptCharset|accessKey|action|allow|allowUserMedia|allowPaymentRequest|allowFullScreen|allowTransparency|alt|async|autoComplete|autoPlay|capture|cellPadding|cellSpacing|challenge|charSet|checked|cite|classID|className|cols|colSpan|content|contentEditable|contextMenu|controls|controlsList|coords|crossOrigin|data|dateTime|decoding|default|defer|dir|disabled|disablePictureInPicture|download|draggable|encType|enterKeyHint|form|formAction|formEncType|formMethod|formNoValidate|formTarget|frameBorder|headers|height|hidden|high|href|hrefLang|htmlFor|httpEquiv|id|inputMode|integrity|is|keyParams|keyType|kind|label|lang|list|loading|loop|low|marginHeight|marginWidth|max|maxLength|media|mediaGroup|method|min|minLength|multiple|muted|name|nonce|noValidate|open|optimum|pattern|placeholder|playsInline|poster|preload|profile|radioGroup|readOnly|referrerPolicy|rel|required|reversed|role|rows|rowSpan|sandbox|scope|scoped|scrolling|seamless|selected|shape|size|sizes|slot|span|spellCheck|src|srcDoc|srcLang|srcSet|start|step|style|summary|tabIndex|target|title|translate|type|useMap|value|width|wmode|wrap|about|datatype|inlist|prefix|property|resource|typeof|vocab|autoCapitalize|autoCorrect|autoSave|color|incremental|fallback|inert|itemProp|itemScope|itemType|itemID|itemRef|on|option|results|security|unselectable|accentHeight|accumulate|additive|alignmentBaseline|allowReorder|alphabetic|amplitude|arabicForm|ascent|attributeName|attributeType|autoReverse|azimuth|baseFrequency|baselineShift|baseProfile|bbox|begin|bias|by|calcMode|capHeight|clip|clipPathUnits|clipPath|clipRule|colorInterpolation|colorInterpolationFilters|colorProfile|colorRendering|contentScriptType|contentStyleType|cursor|cx|cy|d|decelerate|descent|diffuseConstant|direction|display|divisor|dominantBaseline|dur|dx|dy|edgeMode|elevation|enableBackground|end|exponent|externalResourcesRequired|fill|fillOpacity|fillRule|filter|filterRes|filterUnits|floodColor|floodOpacity|focusable|fontFamily|fontSize|fontSizeAdjust|fontStretch|fontStyle|fontVariant|fontWeight|format|from|fr|fx|fy|g1|g2|glyphName|glyphOrientationHorizontal|glyphOrientationVertical|glyphRef|gradientTransform|gradientUnits|hanging|horizAdvX|horizOriginX|ideographic|imageRendering|in|in2|intercept|k|k1|k2|k3|k4|kernelMatrix|kernelUnitLength|kerning|keyPoints|keySplines|keyTimes|lengthAdjust|letterSpacing|lightingColor|limitingConeAngle|local|markerEnd|markerMid|markerStart|markerHeight|markerUnits|markerWidth|mask|maskContentUnits|maskUnits|mathematical|mode|numOctaves|offset|opacity|operator|order|orient|orientation|origin|overflow|overlinePosition|overlineThickness|panose1|paintOrder|pathLength|patternContentUnits|patternTransform|patternUnits|pointerEvents|points|pointsAtX|pointsAtY|pointsAtZ|preserveAlpha|preserveAspectRatio|primitiveUnits|r|radius|refX|refY|renderingIntent|repeatCount|repeatDur|requiredExtensions|requiredFeatures|restart|result|rotate|rx|ry|scale|seed|shapeRendering|slope|spacing|specularConstant|specularExponent|speed|spreadMethod|startOffset|stdDeviation|stemh|stemv|stitchTiles|stopColor|stopOpacity|strikethroughPosition|strikethroughThickness|string|stroke|strokeDasharray|strokeDashoffset|strokeLinecap|strokeLinejoin|strokeMiterlimit|strokeOpacity|strokeWidth|surfaceScale|systemLanguage|tableValues|targetX|targetY|textAnchor|textDecoration|textRendering|textLength|to|transform|u1|u2|underlinePosition|underlineThickness|unicode|unicodeBidi|unicodeRange|unitsPerEm|vAlphabetic|vHanging|vIdeographic|vMathematical|values|vectorEffect|version|vertAdvY|vertOriginX|vertOriginY|viewBox|viewTarget|visibility|widths|wordSpacing|writingMode|x|xHeight|x1|x2|xChannelSelector|xlinkActuate|xlinkArcrole|xlinkHref|xlinkRole|xlinkShow|xlinkTitle|xlinkType|xmlBase|xmlns|xmlnsXlink|xmlLang|xmlSpace|y|y1|y2|yChannelSelector|z|zoomAndPan|for|class|autofocus)|(([Dd][Aa][Tt][Aa]|[Aa][Rr][Ii][Aa]|x)-.*))$/; // https://esbench.com/bench/5bfee68a4cd7e6009ef61d23
74219  
74220  var isPropValid = /* #__PURE__ */memoize(function (prop) {
74221    return reactPropsRegex.test(prop) || prop.charCodeAt(0) === 111
74222    /* o */
74223    && prop.charCodeAt(1) === 110
74224    /* n */
74225    && prop.charCodeAt(2) < 91;
74226  }
74227  /* Z+1 */
74228  );
74229  
74230  
74231  
74232  ;// ./node_modules/@emotion/sheet/dist/emotion-sheet.browser.esm.js
74233  /*
74234  
74235  Based off glamor's StyleSheet, thanks Sunil ❤️
74236  
74237  high performance StyleSheet for css-in-js systems
74238  
74239  - uses multiple style tags behind the scenes for millions of rules
74240  - uses `insertRule` for appending in production for *much* faster performance
74241  
74242  // usage
74243  
74244  import { StyleSheet } from '@emotion/sheet'
74245  
74246  let styleSheet = new StyleSheet({ key: '', container: document.head })
74247  
74248  styleSheet.insert('#box { border: 1px solid red; }')
74249  - appends a css rule into the stylesheet
74250  
74251  styleSheet.flush()
74252  - empties the stylesheet of all its contents
74253  
74254  */
74255  // $FlowFixMe
74256  function sheetForTag(tag) {
74257    if (tag.sheet) {
74258      // $FlowFixMe
74259      return tag.sheet;
74260    } // this weirdness brought to you by firefox
74261  
74262    /* istanbul ignore next */
74263  
74264  
74265    for (var i = 0; i < document.styleSheets.length; i++) {
74266      if (document.styleSheets[i].ownerNode === tag) {
74267        // $FlowFixMe
74268        return document.styleSheets[i];
74269      }
74270    }
74271  }
74272  
74273  function createStyleElement(options) {
74274    var tag = document.createElement('style');
74275    tag.setAttribute('data-emotion', options.key);
74276  
74277    if (options.nonce !== undefined) {
74278      tag.setAttribute('nonce', options.nonce);
74279    }
74280  
74281    tag.appendChild(document.createTextNode(''));
74282    tag.setAttribute('data-s', '');
74283    return tag;
74284  }
74285  
74286  var StyleSheet = /*#__PURE__*/function () {
74287    // Using Node instead of HTMLElement since container may be a ShadowRoot
74288    function StyleSheet(options) {
74289      var _this = this;
74290  
74291      this._insertTag = function (tag) {
74292        var before;
74293  
74294        if (_this.tags.length === 0) {
74295          if (_this.insertionPoint) {
74296            before = _this.insertionPoint.nextSibling;
74297          } else if (_this.prepend) {
74298            before = _this.container.firstChild;
74299          } else {
74300            before = _this.before;
74301          }
74302        } else {
74303          before = _this.tags[_this.tags.length - 1].nextSibling;
74304        }
74305  
74306        _this.container.insertBefore(tag, before);
74307  
74308        _this.tags.push(tag);
74309      };
74310  
74311      this.isSpeedy = options.speedy === undefined ? "production" === 'production' : options.speedy;
74312      this.tags = [];
74313      this.ctr = 0;
74314      this.nonce = options.nonce; // key is the value of the data-emotion attribute, it's used to identify different sheets
74315  
74316      this.key = options.key;
74317      this.container = options.container;
74318      this.prepend = options.prepend;
74319      this.insertionPoint = options.insertionPoint;
74320      this.before = null;
74321    }
74322  
74323    var _proto = StyleSheet.prototype;
74324  
74325    _proto.hydrate = function hydrate(nodes) {
74326      nodes.forEach(this._insertTag);
74327    };
74328  
74329    _proto.insert = function insert(rule) {
74330      // the max length is how many rules we have per style tag, it's 65000 in speedy mode
74331      // it's 1 in dev because we insert source maps that map a single rule to a location
74332      // and you can only have one source map per style tag
74333      if (this.ctr % (this.isSpeedy ? 65000 : 1) === 0) {
74334        this._insertTag(createStyleElement(this));
74335      }
74336  
74337      var tag = this.tags[this.tags.length - 1];
74338  
74339      if (false) { var isImportRule; }
74340  
74341      if (this.isSpeedy) {
74342        var sheet = sheetForTag(tag);
74343  
74344        try {
74345          // this is the ultrafast version, works across browsers
74346          // the big drawback is that the css won't be editable in devtools
74347          sheet.insertRule(rule, sheet.cssRules.length);
74348        } catch (e) {
74349          if (false) {}
74350        }
74351      } else {
74352        tag.appendChild(document.createTextNode(rule));
74353      }
74354  
74355      this.ctr++;
74356    };
74357  
74358    _proto.flush = function flush() {
74359      // $FlowFixMe
74360      this.tags.forEach(function (tag) {
74361        return tag.parentNode && tag.parentNode.removeChild(tag);
74362      });
74363      this.tags = [];
74364      this.ctr = 0;
74365  
74366      if (false) {}
74367    };
74368  
74369    return StyleSheet;
74370  }();
74371  
74372  
74373  
74374  ;// ./node_modules/stylis/src/Utility.js
74375  /**
74376   * @param {number}
74377   * @return {number}
74378   */
74379  var abs = Math.abs
74380  
74381  /**
74382   * @param {number}
74383   * @return {string}
74384   */
74385  var Utility_from = String.fromCharCode
74386  
74387  /**
74388   * @param {object}
74389   * @return {object}
74390   */
74391  var Utility_assign = Object.assign
74392  
74393  /**
74394   * @param {string} value
74395   * @param {number} length
74396   * @return {number}
74397   */
74398  function hash (value, length) {
74399      return Utility_charat(value, 0) ^ 45 ? (((((((length << 2) ^ Utility_charat(value, 0)) << 2) ^ Utility_charat(value, 1)) << 2) ^ Utility_charat(value, 2)) << 2) ^ Utility_charat(value, 3) : 0
74400  }
74401  
74402  /**
74403   * @param {string} value
74404   * @return {string}
74405   */
74406  function trim (value) {
74407      return value.trim()
74408  }
74409  
74410  /**
74411   * @param {string} value
74412   * @param {RegExp} pattern
74413   * @return {string?}
74414   */
74415  function Utility_match (value, pattern) {
74416      return (value = pattern.exec(value)) ? value[0] : value
74417  }
74418  
74419  /**
74420   * @param {string} value
74421   * @param {(string|RegExp)} pattern
74422   * @param {string} replacement
74423   * @return {string}
74424   */
74425  function Utility_replace (value, pattern, replacement) {
74426      return value.replace(pattern, replacement)
74427  }
74428  
74429  /**
74430   * @param {string} value
74431   * @param {string} search
74432   * @return {number}
74433   */
74434  function indexof (value, search) {
74435      return value.indexOf(search)
74436  }
74437  
74438  /**
74439   * @param {string} value
74440   * @param {number} index
74441   * @return {number}
74442   */
74443  function Utility_charat (value, index) {
74444      return value.charCodeAt(index) | 0
74445  }
74446  
74447  /**
74448   * @param {string} value
74449   * @param {number} begin
74450   * @param {number} end
74451   * @return {string}
74452   */
74453  function Utility_substr (value, begin, end) {
74454      return value.slice(begin, end)
74455  }
74456  
74457  /**
74458   * @param {string} value
74459   * @return {number}
74460   */
74461  function Utility_strlen (value) {
74462      return value.length
74463  }
74464  
74465  /**
74466   * @param {any[]} value
74467   * @return {number}
74468   */
74469  function Utility_sizeof (value) {
74470      return value.length
74471  }
74472  
74473  /**
74474   * @param {any} value
74475   * @param {any[]} array
74476   * @return {any}
74477   */
74478  function Utility_append (value, array) {
74479      return array.push(value), value
74480  }
74481  
74482  /**
74483   * @param {string[]} array
74484   * @param {function} callback
74485   * @return {string}
74486   */
74487  function Utility_combine (array, callback) {
74488      return array.map(callback).join('')
74489  }
74490  
74491  ;// ./node_modules/stylis/src/Tokenizer.js
74492  
74493  
74494  var line = 1
74495  var column = 1
74496  var Tokenizer_length = 0
74497  var Tokenizer_position = 0
74498  var Tokenizer_character = 0
74499  var characters = ''
74500  
74501  /**
74502   * @param {string} value
74503   * @param {object | null} root
74504   * @param {object | null} parent
74505   * @param {string} type
74506   * @param {string[] | string} props
74507   * @param {object[] | string} children
74508   * @param {number} length
74509   */
74510  function node (value, root, parent, type, props, children, length) {
74511      return {value: value, root: root, parent: parent, type: type, props: props, children: children, line: line, column: column, length: length, return: ''}
74512  }
74513  
74514  /**
74515   * @param {object} root
74516   * @param {object} props
74517   * @return {object}
74518   */
74519  function Tokenizer_copy (root, props) {
74520      return Utility_assign(node('', null, null, '', null, null, 0), root, {length: -root.length}, props)
74521  }
74522  
74523  /**
74524   * @return {number}
74525   */
74526  function Tokenizer_char () {
74527      return Tokenizer_character
74528  }
74529  
74530  /**
74531   * @return {number}
74532   */
74533  function prev () {
74534      Tokenizer_character = Tokenizer_position > 0 ? Utility_charat(characters, --Tokenizer_position) : 0
74535  
74536      if (column--, Tokenizer_character === 10)
74537          column = 1, line--
74538  
74539      return Tokenizer_character
74540  }
74541  
74542  /**
74543   * @return {number}
74544   */
74545  function next () {
74546      Tokenizer_character = Tokenizer_position < Tokenizer_length ? Utility_charat(characters, Tokenizer_position++) : 0
74547  
74548      if (column++, Tokenizer_character === 10)
74549          column = 1, line++
74550  
74551      return Tokenizer_character
74552  }
74553  
74554  /**
74555   * @return {number}
74556   */
74557  function peek () {
74558      return Utility_charat(characters, Tokenizer_position)
74559  }
74560  
74561  /**
74562   * @return {number}
74563   */
74564  function caret () {
74565      return Tokenizer_position
74566  }
74567  
74568  /**
74569   * @param {number} begin
74570   * @param {number} end
74571   * @return {string}
74572   */
74573  function slice (begin, end) {
74574      return Utility_substr(characters, begin, end)
74575  }
74576  
74577  /**
74578   * @param {number} type
74579   * @return {number}
74580   */
74581  function token (type) {
74582      switch (type) {
74583          // \0 \t \n \r \s whitespace token
74584          case 0: case 9: case 10: case 13: case 32:
74585              return 5
74586          // ! + , / > @ ~ isolate token
74587          case 33: case 43: case 44: case 47: case 62: case 64: case 126:
74588          // ; { } breakpoint token
74589          case 59: case 123: case 125:
74590              return 4
74591          // : accompanied token
74592          case 58:
74593              return 3
74594          // " ' ( [ opening delimit token
74595          case 34: case 39: case 40: case 91:
74596              return 2
74597          // ) ] closing delimit token
74598          case 41: case 93:
74599              return 1
74600      }
74601  
74602      return 0
74603  }
74604  
74605  /**
74606   * @param {string} value
74607   * @return {any[]}
74608   */
74609  function alloc (value) {
74610      return line = column = 1, Tokenizer_length = Utility_strlen(characters = value), Tokenizer_position = 0, []
74611  }
74612  
74613  /**
74614   * @param {any} value
74615   * @return {any}
74616   */
74617  function dealloc (value) {
74618      return characters = '', value
74619  }
74620  
74621  /**
74622   * @param {number} type
74623   * @return {string}
74624   */
74625  function delimit (type) {
74626      return trim(slice(Tokenizer_position - 1, delimiter(type === 91 ? type + 2 : type === 40 ? type + 1 : type)))
74627  }
74628  
74629  /**
74630   * @param {string} value
74631   * @return {string[]}
74632   */
74633  function Tokenizer_tokenize (value) {
74634      return dealloc(tokenizer(alloc(value)))
74635  }
74636  
74637  /**
74638   * @param {number} type
74639   * @return {string}
74640   */
74641  function whitespace (type) {
74642      while (Tokenizer_character = peek())
74643          if (Tokenizer_character < 33)
74644              next()
74645          else
74646              break
74647  
74648      return token(type) > 2 || token(Tokenizer_character) > 3 ? '' : ' '
74649  }
74650  
74651  /**
74652   * @param {string[]} children
74653   * @return {string[]}
74654   */
74655  function tokenizer (children) {
74656      while (next())
74657          switch (token(Tokenizer_character)) {
74658              case 0: append(identifier(Tokenizer_position - 1), children)
74659                  break
74660              case 2: append(delimit(Tokenizer_character), children)
74661                  break
74662              default: append(from(Tokenizer_character), children)
74663          }
74664  
74665      return children
74666  }
74667  
74668  /**
74669   * @param {number} index
74670   * @param {number} count
74671   * @return {string}
74672   */
74673  function escaping (index, count) {
74674      while (--count && next())
74675          // not 0-9 A-F a-f
74676          if (Tokenizer_character < 48 || Tokenizer_character > 102 || (Tokenizer_character > 57 && Tokenizer_character < 65) || (Tokenizer_character > 70 && Tokenizer_character < 97))
74677              break
74678  
74679      return slice(index, caret() + (count < 6 && peek() == 32 && next() == 32))
74680  }
74681  
74682  /**
74683   * @param {number} type
74684   * @return {number}
74685   */
74686  function delimiter (type) {
74687      while (next())
74688          switch (Tokenizer_character) {
74689              // ] ) " '
74690              case type:
74691                  return Tokenizer_position
74692              // " '
74693              case 34: case 39:
74694                  if (type !== 34 && type !== 39)
74695                      delimiter(Tokenizer_character)
74696                  break
74697              // (
74698              case 40:
74699                  if (type === 41)
74700                      delimiter(type)
74701                  break
74702              // \
74703              case 92:
74704                  next()
74705                  break
74706          }
74707  
74708      return Tokenizer_position
74709  }
74710  
74711  /**
74712   * @param {number} type
74713   * @param {number} index
74714   * @return {number}
74715   */
74716  function commenter (type, index) {
74717      while (next())
74718          // //
74719          if (type + Tokenizer_character === 47 + 10)
74720              break
74721          // /*
74722          else if (type + Tokenizer_character === 42 + 42 && peek() === 47)
74723              break
74724  
74725      return '/*' + slice(index, Tokenizer_position - 1) + '*' + Utility_from(type === 47 ? type : next())
74726  }
74727  
74728  /**
74729   * @param {number} index
74730   * @return {string}
74731   */
74732  function identifier (index) {
74733      while (!token(peek()))
74734          next()
74735  
74736      return slice(index, Tokenizer_position)
74737  }
74738  
74739  ;// ./node_modules/stylis/src/Enum.js
74740  var Enum_MS = '-ms-'
74741  var Enum_MOZ = '-moz-'
74742  var Enum_WEBKIT = '-webkit-'
74743  
74744  var COMMENT = 'comm'
74745  var Enum_RULESET = 'rule'
74746  var Enum_DECLARATION = 'decl'
74747  
74748  var PAGE = '@page'
74749  var MEDIA = '@media'
74750  var IMPORT = '@import'
74751  var CHARSET = '@charset'
74752  var VIEWPORT = '@viewport'
74753  var SUPPORTS = '@supports'
74754  var DOCUMENT = '@document'
74755  var NAMESPACE = '@namespace'
74756  var Enum_KEYFRAMES = '@keyframes'
74757  var FONT_FACE = '@font-face'
74758  var COUNTER_STYLE = '@counter-style'
74759  var FONT_FEATURE_VALUES = '@font-feature-values'
74760  
74761  ;// ./node_modules/stylis/src/Serializer.js
74762  
74763  
74764  
74765  /**
74766   * @param {object[]} children
74767   * @param {function} callback
74768   * @return {string}
74769   */
74770  function Serializer_serialize (children, callback) {
74771      var output = ''
74772      var length = Utility_sizeof(children)
74773  
74774      for (var i = 0; i < length; i++)
74775          output += callback(children[i], i, children, callback) || ''
74776  
74777      return output
74778  }
74779  
74780  /**
74781   * @param {object} element
74782   * @param {number} index
74783   * @param {object[]} children
74784   * @param {function} callback
74785   * @return {string}
74786   */
74787  function Serializer_stringify (element, index, children, callback) {
74788      switch (element.type) {
74789          case IMPORT: case Enum_DECLARATION: return element.return = element.return || element.value
74790          case COMMENT: return ''
74791          case Enum_KEYFRAMES: return element.return = element.value + '{' + Serializer_serialize(element.children, callback) + '}'
74792          case Enum_RULESET: element.value = element.props.join(',')
74793      }
74794  
74795      return Utility_strlen(children = Serializer_serialize(element.children, callback)) ? element.return = element.value + '{' + children + '}' : ''
74796  }
74797  
74798  ;// ./node_modules/stylis/src/Middleware.js
74799  
74800  
74801  
74802  
74803  
74804  
74805  /**
74806   * @param {function[]} collection
74807   * @return {function}
74808   */
74809  function middleware (collection) {
74810      var length = Utility_sizeof(collection)
74811  
74812      return function (element, index, children, callback) {
74813          var output = ''
74814  
74815          for (var i = 0; i < length; i++)
74816              output += collection[i](element, index, children, callback) || ''
74817  
74818          return output
74819      }
74820  }
74821  
74822  /**
74823   * @param {function} callback
74824   * @return {function}
74825   */
74826  function rulesheet (callback) {
74827      return function (element) {
74828          if (!element.root)
74829              if (element = element.return)
74830                  callback(element)
74831      }
74832  }
74833  
74834  /**
74835   * @param {object} element
74836   * @param {number} index
74837   * @param {object[]} children
74838   * @param {function} callback
74839   */
74840  function prefixer (element, index, children, callback) {
74841      if (element.length > -1)
74842          if (!element.return)
74843              switch (element.type) {
74844                  case DECLARATION: element.return = prefix(element.value, element.length, children)
74845                      return
74846                  case KEYFRAMES:
74847                      return serialize([copy(element, {value: replace(element.value, '@', '@' + WEBKIT)})], callback)
74848                  case RULESET:
74849                      if (element.length)
74850                          return combine(element.props, function (value) {
74851                              switch (match(value, /(::plac\w+|:read-\w+)/)) {
74852                                  // :read-(only|write)
74853                                  case ':read-only': case ':read-write':
74854                                      return serialize([copy(element, {props: [replace(value, /:(read-\w+)/, ':' + MOZ + '$1')]})], callback)
74855                                  // :placeholder
74856                                  case '::placeholder':
74857                                      return serialize([
74858                                          copy(element, {props: [replace(value, /:(plac\w+)/, ':' + WEBKIT + 'input-$1')]}),
74859                                          copy(element, {props: [replace(value, /:(plac\w+)/, ':' + MOZ + '$1')]}),
74860                                          copy(element, {props: [replace(value, /:(plac\w+)/, MS + 'input-$1')]})
74861                                      ], callback)
74862                              }
74863  
74864                              return ''
74865                          })
74866              }
74867  }
74868  
74869  /**
74870   * @param {object} element
74871   * @param {number} index
74872   * @param {object[]} children
74873   */
74874  function namespace (element) {
74875      switch (element.type) {
74876          case RULESET:
74877              element.props = element.props.map(function (value) {
74878                  return combine(tokenize(value), function (value, index, children) {
74879                      switch (charat(value, 0)) {
74880                          // \f
74881                          case 12:
74882                              return substr(value, 1, strlen(value))
74883                          // \0 ( + > ~
74884                          case 0: case 40: case 43: case 62: case 126:
74885                              return value
74886                          // :
74887                          case 58:
74888                              if (children[++index] === 'global')
74889                                  children[index] = '', children[++index] = '\f' + substr(children[index], index = 1, -1)
74890                          // \s
74891                          case 32:
74892                              return index === 1 ? '' : value
74893                          default:
74894                              switch (index) {
74895                                  case 0: element = value
74896                                      return sizeof(children) > 1 ? '' : value
74897                                  case index = sizeof(children) - 1: case 2:
74898                                      return index === 2 ? value + element + element : value + element
74899                                  default:
74900                                      return value
74901                              }
74902                      }
74903                  })
74904              })
74905      }
74906  }
74907  
74908  ;// ./node_modules/stylis/src/Parser.js
74909  
74910  
74911  
74912  
74913  /**
74914   * @param {string} value
74915   * @return {object[]}
74916   */
74917  function compile (value) {
74918      return dealloc(Parser_parse('', null, null, null, [''], value = alloc(value), 0, [0], value))
74919  }
74920  
74921  /**
74922   * @param {string} value
74923   * @param {object} root
74924   * @param {object?} parent
74925   * @param {string[]} rule
74926   * @param {string[]} rules
74927   * @param {string[]} rulesets
74928   * @param {number[]} pseudo
74929   * @param {number[]} points
74930   * @param {string[]} declarations
74931   * @return {object}
74932   */
74933  function Parser_parse (value, root, parent, rule, rules, rulesets, pseudo, points, declarations) {
74934      var index = 0
74935      var offset = 0
74936      var length = pseudo
74937      var atrule = 0
74938      var property = 0
74939      var previous = 0
74940      var variable = 1
74941      var scanning = 1
74942      var ampersand = 1
74943      var character = 0
74944      var type = ''
74945      var props = rules
74946      var children = rulesets
74947      var reference = rule
74948      var characters = type
74949  
74950      while (scanning)
74951          switch (previous = character, character = next()) {
74952              // (
74953              case 40:
74954                  if (previous != 108 && Utility_charat(characters, length - 1) == 58) {
74955                      if (indexof(characters += Utility_replace(delimit(character), '&', '&\f'), '&\f') != -1)
74956                          ampersand = -1
74957                      break
74958                  }
74959              // " ' [
74960              case 34: case 39: case 91:
74961                  characters += delimit(character)
74962                  break
74963              // \t \n \r \s
74964              case 9: case 10: case 13: case 32:
74965                  characters += whitespace(previous)
74966                  break
74967              // \
74968              case 92:
74969                  characters += escaping(caret() - 1, 7)
74970                  continue
74971              // /
74972              case 47:
74973                  switch (peek()) {
74974                      case 42: case 47:
74975                          Utility_append(comment(commenter(next(), caret()), root, parent), declarations)
74976                          break
74977                      default:
74978                          characters += '/'
74979                  }
74980                  break
74981              // {
74982              case 123 * variable:
74983                  points[index++] = Utility_strlen(characters) * ampersand
74984              // } ; \0
74985              case 125 * variable: case 59: case 0:
74986                  switch (character) {
74987                      // \0 }
74988                      case 0: case 125: scanning = 0
74989                      // ;
74990                      case 59 + offset:
74991                          if (property > 0 && (Utility_strlen(characters) - length))
74992                              Utility_append(property > 32 ? declaration(characters + ';', rule, parent, length - 1) : declaration(Utility_replace(characters, ' ', '') + ';', rule, parent, length - 2), declarations)
74993                          break
74994                      // @ ;
74995                      case 59: characters += ';'
74996                      // { rule/at-rule
74997                      default:
74998                          Utility_append(reference = ruleset(characters, root, parent, index, offset, rules, points, type, props = [], children = [], length), rulesets)
74999  
75000                          if (character === 123)
75001                              if (offset === 0)
75002                                  Parser_parse(characters, root, reference, reference, props, rulesets, length, points, children)
75003                              else
75004                                  switch (atrule === 99 && Utility_charat(characters, 3) === 110 ? 100 : atrule) {
75005                                      // d m s
75006                                      case 100: case 109: case 115:
75007                                          Parser_parse(value, reference, reference, rule && Utility_append(ruleset(value, reference, reference, 0, 0, rules, points, type, rules, props = [], length), children), rules, children, length, points, rule ? props : children)
75008                                          break
75009                                      default:
75010                                          Parser_parse(characters, reference, reference, reference, [''], children, 0, points, children)
75011                                  }
75012                  }
75013  
75014                  index = offset = property = 0, variable = ampersand = 1, type = characters = '', length = pseudo
75015                  break
75016              // :
75017              case 58:
75018                  length = 1 + Utility_strlen(characters), property = previous
75019              default:
75020                  if (variable < 1)
75021                      if (character == 123)
75022                          --variable
75023                      else if (character == 125 && variable++ == 0 && prev() == 125)
75024                          continue
75025  
75026                  switch (characters += Utility_from(character), character * variable) {
75027                      // &
75028                      case 38:
75029                          ampersand = offset > 0 ? 1 : (characters += '\f', -1)
75030                          break
75031                      // ,
75032                      case 44:
75033                          points[index++] = (Utility_strlen(characters) - 1) * ampersand, ampersand = 1
75034                          break
75035                      // @
75036                      case 64:
75037                          // -
75038                          if (peek() === 45)
75039                              characters += delimit(next())
75040  
75041                          atrule = peek(), offset = length = Utility_strlen(type = characters += identifier(caret())), character++
75042                          break
75043                      // -
75044                      case 45:
75045                          if (previous === 45 && Utility_strlen(characters) == 2)
75046                              variable = 0
75047                  }
75048          }
75049  
75050      return rulesets
75051  }
75052  
75053  /**
75054   * @param {string} value
75055   * @param {object} root
75056   * @param {object?} parent
75057   * @param {number} index
75058   * @param {number} offset
75059   * @param {string[]} rules
75060   * @param {number[]} points
75061   * @param {string} type
75062   * @param {string[]} props
75063   * @param {string[]} children
75064   * @param {number} length
75065   * @return {object}
75066   */
75067  function ruleset (value, root, parent, index, offset, rules, points, type, props, children, length) {
75068      var post = offset - 1
75069      var rule = offset === 0 ? rules : ['']
75070      var size = Utility_sizeof(rule)
75071  
75072      for (var i = 0, j = 0, k = 0; i < index; ++i)
75073          for (var x = 0, y = Utility_substr(value, post + 1, post = abs(j = points[i])), z = value; x < size; ++x)
75074              if (z = trim(j > 0 ? rule[x] + ' ' + y : Utility_replace(y, /&\f/g, rule[x])))
75075                  props[k++] = z
75076  
75077      return node(value, root, parent, offset === 0 ? Enum_RULESET : type, props, children, length)
75078  }
75079  
75080  /**
75081   * @param {number} value
75082   * @param {object} root
75083   * @param {object?} parent
75084   * @return {object}
75085   */
75086  function comment (value, root, parent) {
75087      return node(value, root, parent, COMMENT, Utility_from(Tokenizer_char()), Utility_substr(value, 2, -2), 0)
75088  }
75089  
75090  /**
75091   * @param {string} value
75092   * @param {object} root
75093   * @param {object?} parent
75094   * @param {number} length
75095   * @return {object}
75096   */
75097  function declaration (value, root, parent, length) {
75098      return node(value, root, parent, Enum_DECLARATION, Utility_substr(value, 0, length), Utility_substr(value, length + 1, -1), length)
75099  }
75100  
75101  ;// ./node_modules/@emotion/cache/dist/emotion-cache.browser.esm.js
75102  
75103  
75104  
75105  
75106  
75107  var identifierWithPointTracking = function identifierWithPointTracking(begin, points, index) {
75108    var previous = 0;
75109    var character = 0;
75110  
75111    while (true) {
75112      previous = character;
75113      character = peek(); // &\f
75114  
75115      if (previous === 38 && character === 12) {
75116        points[index] = 1;
75117      }
75118  
75119      if (token(character)) {
75120        break;
75121      }
75122  
75123      next();
75124    }
75125  
75126    return slice(begin, Tokenizer_position);
75127  };
75128  
75129  var toRules = function toRules(parsed, points) {
75130    // pretend we've started with a comma
75131    var index = -1;
75132    var character = 44;
75133  
75134    do {
75135      switch (token(character)) {
75136        case 0:
75137          // &\f
75138          if (character === 38 && peek() === 12) {
75139            // this is not 100% correct, we don't account for literal sequences here - like for example quoted strings
75140            // stylis inserts \f after & to know when & where it should replace this sequence with the context selector
75141            // and when it should just concatenate the outer and inner selectors
75142            // it's very unlikely for this sequence to actually appear in a different context, so we just leverage this fact here
75143            points[index] = 1;
75144          }
75145  
75146          parsed[index] += identifierWithPointTracking(Tokenizer_position - 1, points, index);
75147          break;
75148  
75149        case 2:
75150          parsed[index] += delimit(character);
75151          break;
75152  
75153        case 4:
75154          // comma
75155          if (character === 44) {
75156            // colon
75157            parsed[++index] = peek() === 58 ? '&\f' : '';
75158            points[index] = parsed[index].length;
75159            break;
75160          }
75161  
75162        // fallthrough
75163  
75164        default:
75165          parsed[index] += Utility_from(character);
75166      }
75167    } while (character = next());
75168  
75169    return parsed;
75170  };
75171  
75172  var getRules = function getRules(value, points) {
75173    return dealloc(toRules(alloc(value), points));
75174  }; // WeakSet would be more appropriate, but only WeakMap is supported in IE11
75175  
75176  
75177  var fixedElements = /* #__PURE__ */new WeakMap();
75178  var compat = function compat(element) {
75179    if (element.type !== 'rule' || !element.parent || // positive .length indicates that this rule contains pseudo
75180    // negative .length indicates that this rule has been already prefixed
75181    element.length < 1) {
75182      return;
75183    }
75184  
75185    var value = element.value,
75186        parent = element.parent;
75187    var isImplicitRule = element.column === parent.column && element.line === parent.line;
75188  
75189    while (parent.type !== 'rule') {
75190      parent = parent.parent;
75191      if (!parent) return;
75192    } // short-circuit for the simplest case
75193  
75194  
75195    if (element.props.length === 1 && value.charCodeAt(0) !== 58
75196    /* colon */
75197    && !fixedElements.get(parent)) {
75198      return;
75199    } // if this is an implicitly inserted rule (the one eagerly inserted at the each new nested level)
75200    // then the props has already been manipulated beforehand as they that array is shared between it and its "rule parent"
75201  
75202  
75203    if (isImplicitRule) {
75204      return;
75205    }
75206  
75207    fixedElements.set(element, true);
75208    var points = [];
75209    var rules = getRules(value, points);
75210    var parentRules = parent.props;
75211  
75212    for (var i = 0, k = 0; i < rules.length; i++) {
75213      for (var j = 0; j < parentRules.length; j++, k++) {
75214        element.props[k] = points[i] ? rules[i].replace(/&\f/g, parentRules[j]) : parentRules[j] + " " + rules[i];
75215      }
75216    }
75217  };
75218  var removeLabel = function removeLabel(element) {
75219    if (element.type === 'decl') {
75220      var value = element.value;
75221  
75222      if ( // charcode for l
75223      value.charCodeAt(0) === 108 && // charcode for b
75224      value.charCodeAt(2) === 98) {
75225        // this ignores label
75226        element["return"] = '';
75227        element.value = '';
75228      }
75229    }
75230  };
75231  var ignoreFlag = 'emotion-disable-server-rendering-unsafe-selector-warning-please-do-not-use-this-the-warning-exists-for-a-reason';
75232  
75233  var isIgnoringComment = function isIgnoringComment(element) {
75234    return element.type === 'comm' && element.children.indexOf(ignoreFlag) > -1;
75235  };
75236  
75237  var createUnsafeSelectorsAlarm = function createUnsafeSelectorsAlarm(cache) {
75238    return function (element, index, children) {
75239      if (element.type !== 'rule' || cache.compat) return;
75240      var unsafePseudoClasses = element.value.match(/(:first|:nth|:nth-last)-child/g);
75241  
75242      if (unsafePseudoClasses) {
75243        var isNested = element.parent === children[0]; // in nested rules comments become children of the "auto-inserted" rule
75244        //
75245        // considering this input:
75246        // .a {
75247        //   .b /* comm */ {}
75248        //   color: hotpink;
75249        // }
75250        // we get output corresponding to this:
75251        // .a {
75252        //   & {
75253        //     /* comm */
75254        //     color: hotpink;
75255        //   }
75256        //   .b {}
75257        // }
75258  
75259        var commentContainer = isNested ? children[0].children : // global rule at the root level
75260        children;
75261  
75262        for (var i = commentContainer.length - 1; i >= 0; i--) {
75263          var node = commentContainer[i];
75264  
75265          if (node.line < element.line) {
75266            break;
75267          } // it is quite weird but comments are *usually* put at `column: element.column - 1`
75268          // so we seek *from the end* for the node that is earlier than the rule's `element` and check that
75269          // this will also match inputs like this:
75270          // .a {
75271          //   /* comm */
75272          //   .b {}
75273          // }
75274          //
75275          // but that is fine
75276          //
75277          // it would be the easiest to change the placement of the comment to be the first child of the rule:
75278          // .a {
75279          //   .b { /* comm */ }
75280          // }
75281          // with such inputs we wouldn't have to search for the comment at all
75282          // TODO: consider changing this comment placement in the next major version
75283  
75284  
75285          if (node.column < element.column) {
75286            if (isIgnoringComment(node)) {
75287              return;
75288            }
75289  
75290            break;
75291          }
75292        }
75293  
75294        unsafePseudoClasses.forEach(function (unsafePseudoClass) {
75295          console.error("The pseudo class \"" + unsafePseudoClass + "\" is potentially unsafe when doing server-side rendering. Try changing it to \"" + unsafePseudoClass.split('-child')[0] + "-of-type\".");
75296        });
75297      }
75298    };
75299  };
75300  
75301  var isImportRule = function isImportRule(element) {
75302    return element.type.charCodeAt(1) === 105 && element.type.charCodeAt(0) === 64;
75303  };
75304  
75305  var isPrependedWithRegularRules = function isPrependedWithRegularRules(index, children) {
75306    for (var i = index - 1; i >= 0; i--) {
75307      if (!isImportRule(children[i])) {
75308        return true;
75309      }
75310    }
75311  
75312    return false;
75313  }; // use this to remove incorrect elements from further processing
75314  // so they don't get handed to the `sheet` (or anything else)
75315  // as that could potentially lead to additional logs which in turn could be overhelming to the user
75316  
75317  
75318  var nullifyElement = function nullifyElement(element) {
75319    element.type = '';
75320    element.value = '';
75321    element["return"] = '';
75322    element.children = '';
75323    element.props = '';
75324  };
75325  
75326  var incorrectImportAlarm = function incorrectImportAlarm(element, index, children) {
75327    if (!isImportRule(element)) {
75328      return;
75329    }
75330  
75331    if (element.parent) {
75332      console.error("`@import` rules can't be nested inside other rules. Please move it to the top level and put it before regular rules. Keep in mind that they can only be used within global styles.");
75333      nullifyElement(element);
75334    } else if (isPrependedWithRegularRules(index, children)) {
75335      console.error("`@import` rules can't be after other rules. Please put your `@import` rules before your other rules.");
75336      nullifyElement(element);
75337    }
75338  };
75339  
75340  /* eslint-disable no-fallthrough */
75341  
75342  function emotion_cache_browser_esm_prefix(value, length) {
75343    switch (hash(value, length)) {
75344      // color-adjust
75345      case 5103:
75346        return Enum_WEBKIT + 'print-' + value + value;
75347      // animation, animation-(delay|direction|duration|fill-mode|iteration-count|name|play-state|timing-function)
75348  
75349      case 5737:
75350      case 4201:
75351      case 3177:
75352      case 3433:
75353      case 1641:
75354      case 4457:
75355      case 2921: // text-decoration, filter, clip-path, backface-visibility, column, box-decoration-break
75356  
75357      case 5572:
75358      case 6356:
75359      case 5844:
75360      case 3191:
75361      case 6645:
75362      case 3005: // mask, mask-image, mask-(mode|clip|size), mask-(repeat|origin), mask-position, mask-composite,
75363  
75364      case 6391:
75365      case 5879:
75366      case 5623:
75367      case 6135:
75368      case 4599:
75369      case 4855: // background-clip, columns, column-(count|fill|gap|rule|rule-color|rule-style|rule-width|span|width)
75370  
75371      case 4215:
75372      case 6389:
75373      case 5109:
75374      case 5365:
75375      case 5621:
75376      case 3829:
75377        return Enum_WEBKIT + value + value;
75378      // appearance, user-select, transform, hyphens, text-size-adjust
75379  
75380      case 5349:
75381      case 4246:
75382      case 4810:
75383      case 6968:
75384      case 2756:
75385        return Enum_WEBKIT + value + Enum_MOZ + value + Enum_MS + value + value;
75386      // flex, flex-direction
75387  
75388      case 6828:
75389      case 4268:
75390        return Enum_WEBKIT + value + Enum_MS + value + value;
75391      // order
75392  
75393      case 6165:
75394        return Enum_WEBKIT + value + Enum_MS + 'flex-' + value + value;
75395      // align-items
75396  
75397      case 5187:
75398        return Enum_WEBKIT + value + Utility_replace(value, /(\w+).+(:[^]+)/, Enum_WEBKIT + 'box-$1$2' + Enum_MS + 'flex-$1$2') + value;
75399      // align-self
75400  
75401      case 5443:
75402        return Enum_WEBKIT + value + Enum_MS + 'flex-item-' + Utility_replace(value, /flex-|-self/, '') + value;
75403      // align-content
75404  
75405      case 4675:
75406        return Enum_WEBKIT + value + Enum_MS + 'flex-line-pack' + Utility_replace(value, /align-content|flex-|-self/, '') + value;
75407      // flex-shrink
75408  
75409      case 5548:
75410        return Enum_WEBKIT + value + Enum_MS + Utility_replace(value, 'shrink', 'negative') + value;
75411      // flex-basis
75412  
75413      case 5292:
75414        return Enum_WEBKIT + value + Enum_MS + Utility_replace(value, 'basis', 'preferred-size') + value;
75415      // flex-grow
75416  
75417      case 6060:
75418        return Enum_WEBKIT + 'box-' + Utility_replace(value, '-grow', '') + Enum_WEBKIT + value + Enum_MS + Utility_replace(value, 'grow', 'positive') + value;
75419      // transition
75420  
75421      case 4554:
75422        return Enum_WEBKIT + Utility_replace(value, /([^-])(transform)/g, '$1' + Enum_WEBKIT + '$2') + value;
75423      // cursor
75424  
75425      case 6187:
75426        return Utility_replace(Utility_replace(Utility_replace(value, /(zoom-|grab)/, Enum_WEBKIT + '$1'), /(image-set)/, Enum_WEBKIT + '$1'), value, '') + value;
75427      // background, background-image
75428  
75429      case 5495:
75430      case 3959:
75431        return Utility_replace(value, /(image-set\([^]*)/, Enum_WEBKIT + '$1' + '$`$1');
75432      // justify-content
75433  
75434      case 4968:
75435        return Utility_replace(Utility_replace(value, /(.+:)(flex-)?(.*)/, Enum_WEBKIT + 'box-pack:$3' + Enum_MS + 'flex-pack:$3'), /s.+-b[^;]+/, 'justify') + Enum_WEBKIT + value + value;
75436      // (margin|padding)-inline-(start|end)
75437  
75438      case 4095:
75439      case 3583:
75440      case 4068:
75441      case 2532:
75442        return Utility_replace(value, /(.+)-inline(.+)/, Enum_WEBKIT + '$1$2') + value;
75443      // (min|max)?(width|height|inline-size|block-size)
75444  
75445      case 8116:
75446      case 7059:
75447      case 5753:
75448      case 5535:
75449      case 5445:
75450      case 5701:
75451      case 4933:
75452      case 4677:
75453      case 5533:
75454      case 5789:
75455      case 5021:
75456      case 4765:
75457        // stretch, max-content, min-content, fill-available
75458        if (Utility_strlen(value) - 1 - length > 6) switch (Utility_charat(value, length + 1)) {
75459          // (m)ax-content, (m)in-content
75460          case 109:
75461            // -
75462            if (Utility_charat(value, length + 4) !== 45) break;
75463          // (f)ill-available, (f)it-content
75464  
75465          case 102:
75466            return Utility_replace(value, /(.+:)(.+)-([^]+)/, '$1' + Enum_WEBKIT + '$2-$3' + '$1' + Enum_MOZ + (Utility_charat(value, length + 3) == 108 ? '$3' : '$2-$3')) + value;
75467          // (s)tretch
75468  
75469          case 115:
75470            return ~indexof(value, 'stretch') ? emotion_cache_browser_esm_prefix(Utility_replace(value, 'stretch', 'fill-available'), length) + value : value;
75471        }
75472        break;
75473      // position: sticky
75474  
75475      case 4949:
75476        // (s)ticky?
75477        if (Utility_charat(value, length + 1) !== 115) break;
75478      // display: (flex|inline-flex)
75479  
75480      case 6444:
75481        switch (Utility_charat(value, Utility_strlen(value) - 3 - (~indexof(value, '!important') && 10))) {
75482          // stic(k)y
75483          case 107:
75484            return Utility_replace(value, ':', ':' + Enum_WEBKIT) + value;
75485          // (inline-)?fl(e)x
75486  
75487          case 101:
75488            return Utility_replace(value, /(.+:)([^;!]+)(;|!.+)?/, '$1' + Enum_WEBKIT + (Utility_charat(value, 14) === 45 ? 'inline-' : '') + 'box$3' + '$1' + Enum_WEBKIT + '$2$3' + '$1' + Enum_MS + '$2box$3') + value;
75489        }
75490  
75491        break;
75492      // writing-mode
75493  
75494      case 5936:
75495        switch (Utility_charat(value, length + 11)) {
75496          // vertical-l(r)
75497          case 114:
75498            return Enum_WEBKIT + value + Enum_MS + Utility_replace(value, /[svh]\w+-[tblr]{2}/, 'tb') + value;
75499          // vertical-r(l)
75500  
75501          case 108:
75502            return Enum_WEBKIT + value + Enum_MS + Utility_replace(value, /[svh]\w+-[tblr]{2}/, 'tb-rl') + value;
75503          // horizontal(-)tb
75504  
75505          case 45:
75506            return Enum_WEBKIT + value + Enum_MS + Utility_replace(value, /[svh]\w+-[tblr]{2}/, 'lr') + value;
75507        }
75508  
75509        return Enum_WEBKIT + value + Enum_MS + value + value;
75510    }
75511  
75512    return value;
75513  }
75514  
75515  var emotion_cache_browser_esm_prefixer = function prefixer(element, index, children, callback) {
75516    if (element.length > -1) if (!element["return"]) switch (element.type) {
75517      case Enum_DECLARATION:
75518        element["return"] = emotion_cache_browser_esm_prefix(element.value, element.length);
75519        break;
75520  
75521      case Enum_KEYFRAMES:
75522        return Serializer_serialize([Tokenizer_copy(element, {
75523          value: Utility_replace(element.value, '@', '@' + Enum_WEBKIT)
75524        })], callback);
75525  
75526      case Enum_RULESET:
75527        if (element.length) return Utility_combine(element.props, function (value) {
75528          switch (Utility_match(value, /(::plac\w+|:read-\w+)/)) {
75529            // :read-(only|write)
75530            case ':read-only':
75531            case ':read-write':
75532              return Serializer_serialize([Tokenizer_copy(element, {
75533                props: [Utility_replace(value, /:(read-\w+)/, ':' + Enum_MOZ + '$1')]
75534              })], callback);
75535            // :placeholder
75536  
75537            case '::placeholder':
75538              return Serializer_serialize([Tokenizer_copy(element, {
75539                props: [Utility_replace(value, /:(plac\w+)/, ':' + Enum_WEBKIT + 'input-$1')]
75540              }), Tokenizer_copy(element, {
75541                props: [Utility_replace(value, /:(plac\w+)/, ':' + Enum_MOZ + '$1')]
75542              }), Tokenizer_copy(element, {
75543                props: [Utility_replace(value, /:(plac\w+)/, Enum_MS + 'input-$1')]
75544              })], callback);
75545          }
75546  
75547          return '';
75548        });
75549    }
75550  };
75551  
75552  var defaultStylisPlugins = [emotion_cache_browser_esm_prefixer];
75553  
75554  var createCache = function createCache(options) {
75555    var key = options.key;
75556  
75557    if (false) {}
75558  
75559    if ( key === 'css') {
75560      var ssrStyles = document.querySelectorAll("style[data-emotion]:not([data-s])"); // get SSRed styles out of the way of React's hydration
75561      // document.head is a safe place to move them to(though note document.head is not necessarily the last place they will be)
75562      // note this very very intentionally targets all style elements regardless of the key to ensure
75563      // that creating a cache works inside of render of a React component
75564  
75565      Array.prototype.forEach.call(ssrStyles, function (node) {
75566        // we want to only move elements which have a space in the data-emotion attribute value
75567        // because that indicates that it is an Emotion 11 server-side rendered style elements
75568        // while we will already ignore Emotion 11 client-side inserted styles because of the :not([data-s]) part in the selector
75569        // Emotion 10 client-side inserted styles did not have data-s (but importantly did not have a space in their data-emotion attributes)
75570        // so checking for the space ensures that loading Emotion 11 after Emotion 10 has inserted some styles
75571        // will not result in the Emotion 10 styles being destroyed
75572        var dataEmotionAttribute = node.getAttribute('data-emotion');
75573  
75574        if (dataEmotionAttribute.indexOf(' ') === -1) {
75575          return;
75576        }
75577        document.head.appendChild(node);
75578        node.setAttribute('data-s', '');
75579      });
75580    }
75581  
75582    var stylisPlugins = options.stylisPlugins || defaultStylisPlugins;
75583  
75584    if (false) {}
75585  
75586    var inserted = {};
75587    var container;
75588    var nodesToHydrate = [];
75589  
75590    {
75591      container = options.container || document.head;
75592      Array.prototype.forEach.call( // this means we will ignore elements which don't have a space in them which
75593      // means that the style elements we're looking at are only Emotion 11 server-rendered style elements
75594      document.querySelectorAll("style[data-emotion^=\"" + key + " \"]"), function (node) {
75595        var attrib = node.getAttribute("data-emotion").split(' '); // $FlowFixMe
75596  
75597        for (var i = 1; i < attrib.length; i++) {
75598          inserted[attrib[i]] = true;
75599        }
75600  
75601        nodesToHydrate.push(node);
75602      });
75603    }
75604  
75605    var _insert;
75606  
75607    var omnipresentPlugins = [compat, removeLabel];
75608  
75609    if (false) {}
75610  
75611    {
75612      var currentSheet;
75613      var finalizingPlugins = [Serializer_stringify,  false ? 0 : rulesheet(function (rule) {
75614        currentSheet.insert(rule);
75615      })];
75616      var serializer = middleware(omnipresentPlugins.concat(stylisPlugins, finalizingPlugins));
75617  
75618      var stylis = function stylis(styles) {
75619        return Serializer_serialize(compile(styles), serializer);
75620      };
75621  
75622      _insert = function insert(selector, serialized, sheet, shouldCache) {
75623        currentSheet = sheet;
75624  
75625        if (false) {}
75626  
75627        stylis(selector ? selector + "{" + serialized.styles + "}" : serialized.styles);
75628  
75629        if (shouldCache) {
75630          cache.inserted[serialized.name] = true;
75631        }
75632      };
75633    }
75634  
75635    var cache = {
75636      key: key,
75637      sheet: new StyleSheet({
75638        key: key,
75639        container: container,
75640        nonce: options.nonce,
75641        speedy: options.speedy,
75642        prepend: options.prepend,
75643        insertionPoint: options.insertionPoint
75644      }),
75645      nonce: options.nonce,
75646      inserted: inserted,
75647      registered: {},
75648      insert: _insert
75649    };
75650    cache.sheet.hydrate(nodesToHydrate);
75651    return cache;
75652  };
75653  
75654  /* harmony default export */ const emotion_cache_browser_esm = (createCache);
75655  
75656  ;// ./node_modules/@emotion/hash/dist/emotion-hash.esm.js
75657  /* eslint-disable */
75658  // Inspired by https://github.com/garycourt/murmurhash-js
75659  // Ported from https://github.com/aappleby/smhasher/blob/61a0530f28277f2e850bfc39600ce61d02b518de/src/MurmurHash2.cpp#L37-L86
75660  function murmur2(str) {
75661    // 'm' and 'r' are mixing constants generated offline.
75662    // They're not really 'magic', they just happen to work well.
75663    // const m = 0x5bd1e995;
75664    // const r = 24;
75665    // Initialize the hash
75666    var h = 0; // Mix 4 bytes at a time into the hash
75667  
75668    var k,
75669        i = 0,
75670        len = str.length;
75671  
75672    for (; len >= 4; ++i, len -= 4) {
75673      k = str.charCodeAt(i) & 0xff | (str.charCodeAt(++i) & 0xff) << 8 | (str.charCodeAt(++i) & 0xff) << 16 | (str.charCodeAt(++i) & 0xff) << 24;
75674      k =
75675      /* Math.imul(k, m): */
75676      (k & 0xffff) * 0x5bd1e995 + ((k >>> 16) * 0xe995 << 16);
75677      k ^=
75678      /* k >>> r: */
75679      k >>> 24;
75680      h =
75681      /* Math.imul(k, m): */
75682      (k & 0xffff) * 0x5bd1e995 + ((k >>> 16) * 0xe995 << 16) ^
75683      /* Math.imul(h, m): */
75684      (h & 0xffff) * 0x5bd1e995 + ((h >>> 16) * 0xe995 << 16);
75685    } // Handle the last few bytes of the input array
75686  
75687  
75688    switch (len) {
75689      case 3:
75690        h ^= (str.charCodeAt(i + 2) & 0xff) << 16;
75691  
75692      case 2:
75693        h ^= (str.charCodeAt(i + 1) & 0xff) << 8;
75694  
75695      case 1:
75696        h ^= str.charCodeAt(i) & 0xff;
75697        h =
75698        /* Math.imul(h, m): */
75699        (h & 0xffff) * 0x5bd1e995 + ((h >>> 16) * 0xe995 << 16);
75700    } // Do a few final mixes of the hash to ensure the last few
75701    // bytes are well-incorporated.
75702  
75703  
75704    h ^= h >>> 13;
75705    h =
75706    /* Math.imul(h, m): */
75707    (h & 0xffff) * 0x5bd1e995 + ((h >>> 16) * 0xe995 << 16);
75708    return ((h ^ h >>> 15) >>> 0).toString(36);
75709  }
75710  
75711  /* harmony default export */ const emotion_hash_esm = (murmur2);
75712  
75713  ;// ./node_modules/@emotion/unitless/dist/emotion-unitless.esm.js
75714  var unitlessKeys = {
75715    animationIterationCount: 1,
75716    borderImageOutset: 1,
75717    borderImageSlice: 1,
75718    borderImageWidth: 1,
75719    boxFlex: 1,
75720    boxFlexGroup: 1,
75721    boxOrdinalGroup: 1,
75722    columnCount: 1,
75723    columns: 1,
75724    flex: 1,
75725    flexGrow: 1,
75726    flexPositive: 1,
75727    flexShrink: 1,
75728    flexNegative: 1,
75729    flexOrder: 1,
75730    gridRow: 1,
75731    gridRowEnd: 1,
75732    gridRowSpan: 1,
75733    gridRowStart: 1,
75734    gridColumn: 1,
75735    gridColumnEnd: 1,
75736    gridColumnSpan: 1,
75737    gridColumnStart: 1,
75738    msGridRow: 1,
75739    msGridRowSpan: 1,
75740    msGridColumn: 1,
75741    msGridColumnSpan: 1,
75742    fontWeight: 1,
75743    lineHeight: 1,
75744    opacity: 1,
75745    order: 1,
75746    orphans: 1,
75747    tabSize: 1,
75748    widows: 1,
75749    zIndex: 1,
75750    zoom: 1,
75751    WebkitLineClamp: 1,
75752    // SVG-related properties
75753    fillOpacity: 1,
75754    floodOpacity: 1,
75755    stopOpacity: 1,
75756    strokeDasharray: 1,
75757    strokeDashoffset: 1,
75758    strokeMiterlimit: 1,
75759    strokeOpacity: 1,
75760    strokeWidth: 1
75761  };
75762  
75763  /* harmony default export */ const emotion_unitless_esm = (unitlessKeys);
75764  
75765  ;// ./node_modules/@emotion/serialize/dist/emotion-serialize.browser.esm.js
75766  
75767  
75768  
75769  
75770  var ILLEGAL_ESCAPE_SEQUENCE_ERROR = "You have illegal escape sequence in your template literal, most likely inside content's property value.\nBecause you write your CSS inside a JavaScript string you actually have to do double escaping, so for example \"content: '\\00d7';\" should become \"content: '\\\\00d7';\".\nYou can read more about this here:\nhttps://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Template_literals#ES2018_revision_of_illegal_escape_sequences";
75771  var UNDEFINED_AS_OBJECT_KEY_ERROR = "You have passed in falsy value as style object's key (can happen when in example you pass unexported component as computed key).";
75772  var hyphenateRegex = /[A-Z]|^ms/g;
75773  var animationRegex = /_EMO_([^_]+?)_([^]*?)_EMO_/g;
75774  
75775  var isCustomProperty = function isCustomProperty(property) {
75776    return property.charCodeAt(1) === 45;
75777  };
75778  
75779  var isProcessableValue = function isProcessableValue(value) {
75780    return value != null && typeof value !== 'boolean';
75781  };
75782  
75783  var processStyleName = /* #__PURE__ */memoize(function (styleName) {
75784    return isCustomProperty(styleName) ? styleName : styleName.replace(hyphenateRegex, '-$&').toLowerCase();
75785  });
75786  
75787  var processStyleValue = function processStyleValue(key, value) {
75788    switch (key) {
75789      case 'animation':
75790      case 'animationName':
75791        {
75792          if (typeof value === 'string') {
75793            return value.replace(animationRegex, function (match, p1, p2) {
75794              cursor = {
75795                name: p1,
75796                styles: p2,
75797                next: cursor
75798              };
75799              return p1;
75800            });
75801          }
75802        }
75803    }
75804  
75805    if (emotion_unitless_esm[key] !== 1 && !isCustomProperty(key) && typeof value === 'number' && value !== 0) {
75806      return value + 'px';
75807    }
75808  
75809    return value;
75810  };
75811  
75812  if (false) { var hyphenatedCache, hyphenPattern, msPattern, oldProcessStyleValue, contentValues, contentValuePattern; }
75813  
75814  var noComponentSelectorMessage = (/* unused pure expression or super */ null && ('Component selectors can only be used in conjunction with ' + '@emotion/babel-plugin, the swc Emotion plugin, or another Emotion-aware ' + 'compiler transform.'));
75815  
75816  function handleInterpolation(mergedProps, registered, interpolation) {
75817    if (interpolation == null) {
75818      return '';
75819    }
75820  
75821    if (interpolation.__emotion_styles !== undefined) {
75822      if (false) {}
75823  
75824      return interpolation;
75825    }
75826  
75827    switch (typeof interpolation) {
75828      case 'boolean':
75829        {
75830          return '';
75831        }
75832  
75833      case 'object':
75834        {
75835          if (interpolation.anim === 1) {
75836            cursor = {
75837              name: interpolation.name,
75838              styles: interpolation.styles,
75839              next: cursor
75840            };
75841            return interpolation.name;
75842          }
75843  
75844          if (interpolation.styles !== undefined) {
75845            var next = interpolation.next;
75846  
75847            if (next !== undefined) {
75848              // not the most efficient thing ever but this is a pretty rare case
75849              // and there will be very few iterations of this generally
75850              while (next !== undefined) {
75851                cursor = {
75852                  name: next.name,
75853                  styles: next.styles,
75854                  next: cursor
75855                };
75856                next = next.next;
75857              }
75858            }
75859  
75860            var styles = interpolation.styles + ";";
75861  
75862            if (false) {}
75863  
75864            return styles;
75865          }
75866  
75867          return createStringFromObject(mergedProps, registered, interpolation);
75868        }
75869  
75870      case 'function':
75871        {
75872          if (mergedProps !== undefined) {
75873            var previousCursor = cursor;
75874            var result = interpolation(mergedProps);
75875            cursor = previousCursor;
75876            return handleInterpolation(mergedProps, registered, result);
75877          } else if (false) {}
75878  
75879          break;
75880        }
75881  
75882      case 'string':
75883        if (false) { var replaced, matched; }
75884  
75885        break;
75886    } // finalize string values (regular strings and functions interpolated into css calls)
75887  
75888  
75889    if (registered == null) {
75890      return interpolation;
75891    }
75892  
75893    var cached = registered[interpolation];
75894    return cached !== undefined ? cached : interpolation;
75895  }
75896  
75897  function createStringFromObject(mergedProps, registered, obj) {
75898    var string = '';
75899  
75900    if (Array.isArray(obj)) {
75901      for (var i = 0; i < obj.length; i++) {
75902        string += handleInterpolation(mergedProps, registered, obj[i]) + ";";
75903      }
75904    } else {
75905      for (var _key in obj) {
75906        var value = obj[_key];
75907  
75908        if (typeof value !== 'object') {
75909          if (registered != null && registered[value] !== undefined) {
75910            string += _key + "{" + registered[value] + "}";
75911          } else if (isProcessableValue(value)) {
75912            string += processStyleName(_key) + ":" + processStyleValue(_key, value) + ";";
75913          }
75914        } else {
75915          if (_key === 'NO_COMPONENT_SELECTOR' && "production" !== 'production') {}
75916  
75917          if (Array.isArray(value) && typeof value[0] === 'string' && (registered == null || registered[value[0]] === undefined)) {
75918            for (var _i = 0; _i < value.length; _i++) {
75919              if (isProcessableValue(value[_i])) {
75920                string += processStyleName(_key) + ":" + processStyleValue(_key, value[_i]) + ";";
75921              }
75922            }
75923          } else {
75924            var interpolated = handleInterpolation(mergedProps, registered, value);
75925  
75926            switch (_key) {
75927              case 'animation':
75928              case 'animationName':
75929                {
75930                  string += processStyleName(_key) + ":" + interpolated + ";";
75931                  break;
75932                }
75933  
75934              default:
75935                {
75936                  if (false) {}
75937  
75938                  string += _key + "{" + interpolated + "}";
75939                }
75940            }
75941          }
75942        }
75943      }
75944    }
75945  
75946    return string;
75947  }
75948  
75949  var labelPattern = /label:\s*([^\s;\n{]+)\s*(;|$)/g;
75950  var sourceMapPattern;
75951  
75952  if (false) {} // this is the cursor for keyframes
75953  // keyframes are stored on the SerializedStyles object as a linked list
75954  
75955  
75956  var cursor;
75957  var emotion_serialize_browser_esm_serializeStyles = function serializeStyles(args, registered, mergedProps) {
75958    if (args.length === 1 && typeof args[0] === 'object' && args[0] !== null && args[0].styles !== undefined) {
75959      return args[0];
75960    }
75961  
75962    var stringMode = true;
75963    var styles = '';
75964    cursor = undefined;
75965    var strings = args[0];
75966  
75967    if (strings == null || strings.raw === undefined) {
75968      stringMode = false;
75969      styles += handleInterpolation(mergedProps, registered, strings);
75970    } else {
75971      if (false) {}
75972  
75973      styles += strings[0];
75974    } // we start at 1 since we've already handled the first arg
75975  
75976  
75977    for (var i = 1; i < args.length; i++) {
75978      styles += handleInterpolation(mergedProps, registered, args[i]);
75979  
75980      if (stringMode) {
75981        if (false) {}
75982  
75983        styles += strings[i];
75984      }
75985    }
75986  
75987    var sourceMap;
75988  
75989    if (false) {} // using a global regex with .exec is stateful so lastIndex has to be reset each time
75990  
75991  
75992    labelPattern.lastIndex = 0;
75993    var identifierName = '';
75994    var match; // https://esbench.com/bench/5b809c2cf2949800a0f61fb5
75995  
75996    while ((match = labelPattern.exec(styles)) !== null) {
75997      identifierName += '-' + // $FlowFixMe we know it's not null
75998      match[1];
75999    }
76000  
76001    var name = emotion_hash_esm(styles) + identifierName;
76002  
76003    if (false) {}
76004  
76005    return {
76006      name: name,
76007      styles: styles,
76008      next: cursor
76009    };
76010  };
76011  
76012  
76013  
76014  ;// ./node_modules/@emotion/use-insertion-effect-with-fallbacks/dist/emotion-use-insertion-effect-with-fallbacks.browser.esm.js
76015  
76016  
76017  
76018  var syncFallback = function syncFallback(create) {
76019    return create();
76020  };
76021  
76022  var useInsertionEffect = external_React_['useInsertion' + 'Effect'] ? external_React_['useInsertion' + 'Effect'] : false;
76023  var emotion_use_insertion_effect_with_fallbacks_browser_esm_useInsertionEffectAlwaysWithSyncFallback =  useInsertionEffect || syncFallback;
76024  var useInsertionEffectWithLayoutFallback = (/* unused pure expression or super */ null && (useInsertionEffect || useLayoutEffect));
76025  
76026  
76027  
76028  ;// ./node_modules/@emotion/react/dist/emotion-element-6a883da9.browser.esm.js
76029  
76030  
76031  
76032  
76033  
76034  
76035  
76036  
76037  
76038  var emotion_element_6a883da9_browser_esm_hasOwnProperty = {}.hasOwnProperty;
76039  
76040  var EmotionCacheContext = /* #__PURE__ */(0,external_React_.createContext)( // we're doing this to avoid preconstruct's dead code elimination in this one case
76041  // because this module is primarily intended for the browser and node
76042  // but it's also required in react native and similar environments sometimes
76043  // and we could have a special build just for that
76044  // but this is much easier and the native packages
76045  // might use a different theme context in the future anyway
76046  typeof HTMLElement !== 'undefined' ? /* #__PURE__ */emotion_cache_browser_esm({
76047    key: 'css'
76048  }) : null);
76049  
76050  if (false) {}
76051  
76052  var CacheProvider = EmotionCacheContext.Provider;
76053  var __unsafe_useEmotionCache = function useEmotionCache() {
76054    return useContext(EmotionCacheContext);
76055  };
76056  
76057  var withEmotionCache = function withEmotionCache(func) {
76058    // $FlowFixMe
76059    return /*#__PURE__*/(0,external_React_.forwardRef)(function (props, ref) {
76060      // the cache will never be null in the browser
76061      var cache = (0,external_React_.useContext)(EmotionCacheContext);
76062      return func(props, cache, ref);
76063    });
76064  };
76065  
76066  var ThemeContext = /* #__PURE__ */(0,external_React_.createContext)({});
76067  
76068  if (false) {}
76069  
76070  var useTheme = function useTheme() {
76071    return useContext(ThemeContext);
76072  };
76073  
76074  var getTheme = function getTheme(outerTheme, theme) {
76075    if (typeof theme === 'function') {
76076      var mergedTheme = theme(outerTheme);
76077  
76078      if (false) {}
76079  
76080      return mergedTheme;
76081    }
76082  
76083    if (false) {}
76084  
76085    return _extends({}, outerTheme, theme);
76086  };
76087  
76088  var createCacheWithTheme = /* #__PURE__ */(/* unused pure expression or super */ null && (weakMemoize(function (outerTheme) {
76089    return weakMemoize(function (theme) {
76090      return getTheme(outerTheme, theme);
76091    });
76092  })));
76093  var ThemeProvider = function ThemeProvider(props) {
76094    var theme = useContext(ThemeContext);
76095  
76096    if (props.theme !== theme) {
76097      theme = createCacheWithTheme(theme)(props.theme);
76098    }
76099  
76100    return /*#__PURE__*/createElement(ThemeContext.Provider, {
76101      value: theme
76102    }, props.children);
76103  };
76104  function withTheme(Component) {
76105    var componentName = Component.displayName || Component.name || 'Component';
76106  
76107    var render = function render(props, ref) {
76108      var theme = useContext(ThemeContext);
76109      return /*#__PURE__*/createElement(Component, _extends({
76110        theme: theme,
76111        ref: ref
76112      }, props));
76113    }; // $FlowFixMe
76114  
76115  
76116    var WithTheme = /*#__PURE__*/forwardRef(render);
76117    WithTheme.displayName = "WithTheme(" + componentName + ")";
76118    return hoistNonReactStatics(WithTheme, Component);
76119  }
76120  
76121  var getLastPart = function getLastPart(functionName) {
76122    // The match may be something like 'Object.createEmotionProps' or
76123    // 'Loader.prototype.render'
76124    var parts = functionName.split('.');
76125    return parts[parts.length - 1];
76126  };
76127  
76128  var getFunctionNameFromStackTraceLine = function getFunctionNameFromStackTraceLine(line) {
76129    // V8
76130    var match = /^\s+at\s+([A-Za-z0-9$.]+)\s/.exec(line);
76131    if (match) return getLastPart(match[1]); // Safari / Firefox
76132  
76133    match = /^([A-Za-z0-9$.]+)@/.exec(line);
76134    if (match) return getLastPart(match[1]);
76135    return undefined;
76136  };
76137  
76138  var internalReactFunctionNames = /* #__PURE__ */new Set(['renderWithHooks', 'processChild', 'finishClassComponent', 'renderToString']); // These identifiers come from error stacks, so they have to be valid JS
76139  // identifiers, thus we only need to replace what is a valid character for JS,
76140  // but not for CSS.
76141  
76142  var sanitizeIdentifier = function sanitizeIdentifier(identifier) {
76143    return identifier.replace(/\$/g, '-');
76144  };
76145  
76146  var getLabelFromStackTrace = function getLabelFromStackTrace(stackTrace) {
76147    if (!stackTrace) return undefined;
76148    var lines = stackTrace.split('\n');
76149  
76150    for (var i = 0; i < lines.length; i++) {
76151      var functionName = getFunctionNameFromStackTraceLine(lines[i]); // The first line of V8 stack traces is just "Error"
76152  
76153      if (!functionName) continue; // If we reach one of these, we have gone too far and should quit
76154  
76155      if (internalReactFunctionNames.has(functionName)) break; // The component name is the first function in the stack that starts with an
76156      // uppercase letter
76157  
76158      if (/^[A-Z]/.test(functionName)) return sanitizeIdentifier(functionName);
76159    }
76160  
76161    return undefined;
76162  };
76163  
76164  var typePropName = '__EMOTION_TYPE_PLEASE_DO_NOT_USE__';
76165  var labelPropName = '__EMOTION_LABEL_PLEASE_DO_NOT_USE__';
76166  var createEmotionProps = function createEmotionProps(type, props) {
76167    if (false) {}
76168  
76169    var newProps = {};
76170  
76171    for (var key in props) {
76172      if (emotion_element_6a883da9_browser_esm_hasOwnProperty.call(props, key)) {
76173        newProps[key] = props[key];
76174      }
76175    }
76176  
76177    newProps[typePropName] = type; // For performance, only call getLabelFromStackTrace in development and when
76178    // the label hasn't already been computed
76179  
76180    if (false) { var label; }
76181  
76182    return newProps;
76183  };
76184  
76185  var Insertion = function Insertion(_ref) {
76186    var cache = _ref.cache,
76187        serialized = _ref.serialized,
76188        isStringTag = _ref.isStringTag;
76189    registerStyles(cache, serialized, isStringTag);
76190    var rules = useInsertionEffectAlwaysWithSyncFallback(function () {
76191      return insertStyles(cache, serialized, isStringTag);
76192    });
76193  
76194    return null;
76195  };
76196  
76197  var Emotion = /* #__PURE__ */(/* unused pure expression or super */ null && (withEmotionCache(function (props, cache, ref) {
76198    var cssProp = props.css; // so that using `css` from `emotion` and passing the result to the css prop works
76199    // not passing the registered cache to serializeStyles because it would
76200    // make certain babel optimisations not possible
76201  
76202    if (typeof cssProp === 'string' && cache.registered[cssProp] !== undefined) {
76203      cssProp = cache.registered[cssProp];
76204    }
76205  
76206    var WrappedComponent = props[typePropName];
76207    var registeredStyles = [cssProp];
76208    var className = '';
76209  
76210    if (typeof props.className === 'string') {
76211      className = getRegisteredStyles(cache.registered, registeredStyles, props.className);
76212    } else if (props.className != null) {
76213      className = props.className + " ";
76214    }
76215  
76216    var serialized = serializeStyles(registeredStyles, undefined, useContext(ThemeContext));
76217  
76218    if (false) { var labelFromStack; }
76219  
76220    className += cache.key + "-" + serialized.name;
76221    var newProps = {};
76222  
76223    for (var key in props) {
76224      if (emotion_element_6a883da9_browser_esm_hasOwnProperty.call(props, key) && key !== 'css' && key !== typePropName && ( true || 0)) {
76225        newProps[key] = props[key];
76226      }
76227    }
76228  
76229    newProps.ref = ref;
76230    newProps.className = className;
76231    return /*#__PURE__*/createElement(Fragment, null, /*#__PURE__*/createElement(Insertion, {
76232      cache: cache,
76233      serialized: serialized,
76234      isStringTag: typeof WrappedComponent === 'string'
76235    }), /*#__PURE__*/createElement(WrappedComponent, newProps));
76236  })));
76237  
76238  if (false) {}
76239  
76240  
76241  
76242  ;// ./node_modules/@emotion/utils/dist/emotion-utils.browser.esm.js
76243  var isBrowser = "object" !== 'undefined';
76244  function emotion_utils_browser_esm_getRegisteredStyles(registered, registeredStyles, classNames) {
76245    var rawClassName = '';
76246    classNames.split(' ').forEach(function (className) {
76247      if (registered[className] !== undefined) {
76248        registeredStyles.push(registered[className] + ";");
76249      } else {
76250        rawClassName += className + " ";
76251      }
76252    });
76253    return rawClassName;
76254  }
76255  var emotion_utils_browser_esm_registerStyles = function registerStyles(cache, serialized, isStringTag) {
76256    var className = cache.key + "-" + serialized.name;
76257  
76258    if ( // we only need to add the styles to the registered cache if the
76259    // class name could be used further down
76260    // the tree but if it's a string tag, we know it won't
76261    // so we don't have to add it to registered cache.
76262    // this improves memory usage since we can avoid storing the whole style string
76263    (isStringTag === false || // we need to always store it if we're in compat mode and
76264    // in node since emotion-server relies on whether a style is in
76265    // the registered cache to know whether a style is global or not
76266    // also, note that this check will be dead code eliminated in the browser
76267    isBrowser === false ) && cache.registered[className] === undefined) {
76268      cache.registered[className] = serialized.styles;
76269    }
76270  };
76271  var emotion_utils_browser_esm_insertStyles = function insertStyles(cache, serialized, isStringTag) {
76272    emotion_utils_browser_esm_registerStyles(cache, serialized, isStringTag);
76273    var className = cache.key + "-" + serialized.name;
76274  
76275    if (cache.inserted[serialized.name] === undefined) {
76276      var current = serialized;
76277  
76278      do {
76279        var maybeStyles = cache.insert(serialized === current ? "." + className : '', current, cache.sheet, true);
76280  
76281        current = current.next;
76282      } while (current !== undefined);
76283    }
76284  };
76285  
76286  
76287  
76288  ;// ./node_modules/@emotion/styled/base/dist/emotion-styled-base.browser.esm.js
76289  
76290  
76291  
76292  
76293  
76294  
76295  
76296  
76297  var testOmitPropsOnStringTag = isPropValid;
76298  
76299  var testOmitPropsOnComponent = function testOmitPropsOnComponent(key) {
76300    return key !== 'theme';
76301  };
76302  
76303  var getDefaultShouldForwardProp = function getDefaultShouldForwardProp(tag) {
76304    return typeof tag === 'string' && // 96 is one less than the char code
76305    // for "a" so this is checking that
76306    // it's a lowercase character
76307    tag.charCodeAt(0) > 96 ? testOmitPropsOnStringTag : testOmitPropsOnComponent;
76308  };
76309  var composeShouldForwardProps = function composeShouldForwardProps(tag, options, isReal) {
76310    var shouldForwardProp;
76311  
76312    if (options) {
76313      var optionsShouldForwardProp = options.shouldForwardProp;
76314      shouldForwardProp = tag.__emotion_forwardProp && optionsShouldForwardProp ? function (propName) {
76315        return tag.__emotion_forwardProp(propName) && optionsShouldForwardProp(propName);
76316      } : optionsShouldForwardProp;
76317    }
76318  
76319    if (typeof shouldForwardProp !== 'function' && isReal) {
76320      shouldForwardProp = tag.__emotion_forwardProp;
76321    }
76322  
76323    return shouldForwardProp;
76324  };
76325  
76326  var emotion_styled_base_browser_esm_ILLEGAL_ESCAPE_SEQUENCE_ERROR = "You have illegal escape sequence in your template literal, most likely inside content's property value.\nBecause you write your CSS inside a JavaScript string you actually have to do double escaping, so for example \"content: '\\00d7';\" should become \"content: '\\\\00d7';\".\nYou can read more about this here:\nhttps://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Template_literals#ES2018_revision_of_illegal_escape_sequences";
76327  
76328  var emotion_styled_base_browser_esm_Insertion = function Insertion(_ref) {
76329    var cache = _ref.cache,
76330        serialized = _ref.serialized,
76331        isStringTag = _ref.isStringTag;
76332    emotion_utils_browser_esm_registerStyles(cache, serialized, isStringTag);
76333    var rules = emotion_use_insertion_effect_with_fallbacks_browser_esm_useInsertionEffectAlwaysWithSyncFallback(function () {
76334      return emotion_utils_browser_esm_insertStyles(cache, serialized, isStringTag);
76335    });
76336  
76337    return null;
76338  };
76339  
76340  var createStyled = function createStyled(tag, options) {
76341    if (false) {}
76342  
76343    var isReal = tag.__emotion_real === tag;
76344    var baseTag = isReal && tag.__emotion_base || tag;
76345    var identifierName;
76346    var targetClassName;
76347  
76348    if (options !== undefined) {
76349      identifierName = options.label;
76350      targetClassName = options.target;
76351    }
76352  
76353    var shouldForwardProp = composeShouldForwardProps(tag, options, isReal);
76354    var defaultShouldForwardProp = shouldForwardProp || getDefaultShouldForwardProp(baseTag);
76355    var shouldUseAs = !defaultShouldForwardProp('as');
76356    return function () {
76357      var args = arguments;
76358      var styles = isReal && tag.__emotion_styles !== undefined ? tag.__emotion_styles.slice(0) : [];
76359  
76360      if (identifierName !== undefined) {
76361        styles.push("label:" + identifierName + ";");
76362      }
76363  
76364      if (args[0] == null || args[0].raw === undefined) {
76365        styles.push.apply(styles, args);
76366      } else {
76367        if (false) {}
76368  
76369        styles.push(args[0][0]);
76370        var len = args.length;
76371        var i = 1;
76372  
76373        for (; i < len; i++) {
76374          if (false) {}
76375  
76376          styles.push(args[i], args[0][i]);
76377        }
76378      } // $FlowFixMe: we need to cast StatelessFunctionalComponent to our PrivateStyledComponent class
76379  
76380  
76381      var Styled = withEmotionCache(function (props, cache, ref) {
76382        var FinalTag = shouldUseAs && props.as || baseTag;
76383        var className = '';
76384        var classInterpolations = [];
76385        var mergedProps = props;
76386  
76387        if (props.theme == null) {
76388          mergedProps = {};
76389  
76390          for (var key in props) {
76391            mergedProps[key] = props[key];
76392          }
76393  
76394          mergedProps.theme = (0,external_React_.useContext)(ThemeContext);
76395        }
76396  
76397        if (typeof props.className === 'string') {
76398          className = emotion_utils_browser_esm_getRegisteredStyles(cache.registered, classInterpolations, props.className);
76399        } else if (props.className != null) {
76400          className = props.className + " ";
76401        }
76402  
76403        var serialized = emotion_serialize_browser_esm_serializeStyles(styles.concat(classInterpolations), cache.registered, mergedProps);
76404        className += cache.key + "-" + serialized.name;
76405  
76406        if (targetClassName !== undefined) {
76407          className += " " + targetClassName;
76408        }
76409  
76410        var finalShouldForwardProp = shouldUseAs && shouldForwardProp === undefined ? getDefaultShouldForwardProp(FinalTag) : defaultShouldForwardProp;
76411        var newProps = {};
76412  
76413        for (var _key in props) {
76414          if (shouldUseAs && _key === 'as') continue;
76415  
76416          if ( // $FlowFixMe
76417          finalShouldForwardProp(_key)) {
76418            newProps[_key] = props[_key];
76419          }
76420        }
76421  
76422        newProps.className = className;
76423        newProps.ref = ref;
76424        return /*#__PURE__*/(0,external_React_.createElement)(external_React_.Fragment, null, /*#__PURE__*/(0,external_React_.createElement)(emotion_styled_base_browser_esm_Insertion, {
76425          cache: cache,
76426          serialized: serialized,
76427          isStringTag: typeof FinalTag === 'string'
76428        }), /*#__PURE__*/(0,external_React_.createElement)(FinalTag, newProps));
76429      });
76430      Styled.displayName = identifierName !== undefined ? identifierName : "Styled(" + (typeof baseTag === 'string' ? baseTag : baseTag.displayName || baseTag.name || 'Component') + ")";
76431      Styled.defaultProps = tag.defaultProps;
76432      Styled.__emotion_real = Styled;
76433      Styled.__emotion_base = baseTag;
76434      Styled.__emotion_styles = styles;
76435      Styled.__emotion_forwardProp = shouldForwardProp;
76436      Object.defineProperty(Styled, 'toString', {
76437        value: function value() {
76438          if (targetClassName === undefined && "production" !== 'production') {} // $FlowFixMe: coerce undefined to string
76439  
76440  
76441          return "." + targetClassName;
76442        }
76443      });
76444  
76445      Styled.withComponent = function (nextTag, nextOptions) {
76446        return createStyled(nextTag, extends_extends({}, options, nextOptions, {
76447          shouldForwardProp: composeShouldForwardProps(Styled, nextOptions, true)
76448        })).apply(void 0, styles);
76449      };
76450  
76451      return Styled;
76452    };
76453  };
76454  
76455  /* harmony default export */ const emotion_styled_base_browser_esm = (createStyled);
76456  
76457  ;// ./node_modules/@wordpress/block-editor/build-module/components/dimensions-tool/width-height-tool.js
76458  
76459  function _EMOTION_STRINGIFIED_CSS_ERROR__() { return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop)."; }
76460  /**
76461   * External dependencies
76462   */
76463  
76464  /**
76465   * WordPress dependencies
76466   */
76467  
76468  
76469  
76470  const SingleColumnToolsPanelItem = /*#__PURE__*/emotion_styled_base_browser_esm(external_wp_components_namespaceObject.__experimentalToolsPanelItem,  true ? {
76471    target: "ef8pe3d0"
76472  } : 0)( true ? {
76473    name: "957xgf",
76474    styles: "grid-column:span 1"
76475  } : 0);
76476  
76477  /**
76478   * @typedef {import('@wordpress/components/build-types/unit-control/types').WPUnitControlUnit} WPUnitControlUnit
76479   */
76480  
76481  /**
76482   * @typedef {Object} WidthHeightToolValue
76483   * @property {string} [width]  Width CSS value.
76484   * @property {string} [height] Height CSS value.
76485   */
76486  
76487  /**
76488   * @callback WidthHeightToolOnChange
76489   * @param {WidthHeightToolValue} nextValue Next dimensions value.
76490   * @return {void}
76491   */
76492  
76493  /**
76494   * @typedef {Object} WidthHeightToolProps
76495   * @property {string}                  [panelId]          ID of the panel that contains the controls.
76496   * @property {WidthHeightToolValue}    [value]            Current dimensions values.
76497   * @property {WidthHeightToolOnChange} [onChange]         Callback to update the dimensions values.
76498   * @property {WPUnitControlUnit[]}     [units]            Units options.
76499   * @property {boolean}                 [isShownByDefault] Whether the panel is shown by default.
76500   */
76501  
76502  /**
76503   * Component that renders controls to edit the dimensions of an image or container.
76504   *
76505   * @param {WidthHeightToolProps} props The component props.
76506   *
76507   * @return {import('react').ReactElement} The width and height tool.
76508   */
76509  function WidthHeightTool({
76510    panelId,
76511    value = {},
76512    onChange = () => {},
76513    units,
76514    isShownByDefault = true
76515  }) {
76516    var _value$width, _value$height;
76517    // null, undefined, and 'auto' all represent the default value.
76518    const width = value.width === 'auto' ? '' : (_value$width = value.width) !== null && _value$width !== void 0 ? _value$width : '';
76519    const height = value.height === 'auto' ? '' : (_value$height = value.height) !== null && _value$height !== void 0 ? _value$height : '';
76520    const onDimensionChange = dimension => nextDimension => {
76521      const nextValue = {
76522        ...value
76523      };
76524      // Empty strings or undefined may be passed and both represent removing the value.
76525      if (!nextDimension) {
76526        delete nextValue[dimension];
76527      } else {
76528        nextValue[dimension] = nextDimension;
76529      }
76530      onChange(nextValue);
76531    };
76532    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
76533      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(SingleColumnToolsPanelItem, {
76534        label: (0,external_wp_i18n_namespaceObject.__)('Width'),
76535        isShownByDefault: isShownByDefault,
76536        hasValue: () => width !== '',
76537        onDeselect: onDimensionChange('width'),
76538        panelId: panelId,
76539        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalUnitControl, {
76540          label: (0,external_wp_i18n_namespaceObject.__)('Width'),
76541          placeholder: (0,external_wp_i18n_namespaceObject.__)('Auto'),
76542          labelPosition: "top",
76543          units: units,
76544          min: 0,
76545          value: width,
76546          onChange: onDimensionChange('width'),
76547          size: "__unstable-large"
76548        })
76549      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(SingleColumnToolsPanelItem, {
76550        label: (0,external_wp_i18n_namespaceObject.__)('Height'),
76551        isShownByDefault: isShownByDefault,
76552        hasValue: () => height !== '',
76553        onDeselect: onDimensionChange('height'),
76554        panelId: panelId,
76555        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalUnitControl, {
76556          label: (0,external_wp_i18n_namespaceObject.__)('Height'),
76557          placeholder: (0,external_wp_i18n_namespaceObject.__)('Auto'),
76558          labelPosition: "top",
76559          units: units,
76560          min: 0,
76561          value: height,
76562          onChange: onDimensionChange('height'),
76563          size: "__unstable-large"
76564        })
76565      })]
76566    });
76567  }
76568  
76569  ;// ./node_modules/@wordpress/block-editor/build-module/components/dimensions-tool/index.js
76570  /**
76571   * WordPress dependencies
76572   */
76573  
76574  
76575  /**
76576   * Internal dependencies
76577   */
76578  
76579  
76580  
76581  
76582  /**
76583   * @typedef {import('@wordpress/components/build-types/select-control/types').SelectControlProps} SelectControlProps
76584   */
76585  
76586  /**
76587   * @typedef {import('@wordpress/components/build-types/unit-control/types').WPUnitControlUnit} WPUnitControlUnit
76588   */
76589  
76590  /**
76591   * @typedef {Object} Dimensions
76592   * @property {string} [width]       CSS width property.
76593   * @property {string} [height]      CSS height property.
76594   * @property {string} [scale]       CSS object-fit property.
76595   * @property {string} [aspectRatio] CSS aspect-ratio property.
76596   */
76597  
76598  /**
76599   * @callback DimensionsControlsOnChange
76600   * @param {Dimensions} nextValue
76601   * @return {void}
76602   */
76603  
76604  /**
76605   * @typedef {Object} DimensionsControlsProps
76606   * @property {string}                     [panelId]            ID of the panel that contains the controls.
76607   * @property {Dimensions}                 [value]              Current dimensions values.
76608   * @property {DimensionsControlsOnChange} [onChange]           Callback to update the dimensions values.
76609   * @property {SelectControlProps[]}       [aspectRatioOptions] Aspect ratio options.
76610   * @property {SelectControlProps[]}       [scaleOptions]       Scale options.
76611   * @property {WPUnitControlUnit[]}        [unitsOptions]       Units options.
76612   */
76613  
76614  /**
76615   * Component that renders controls to edit the dimensions of an image or container.
76616   *
76617   * @param {DimensionsControlsProps} props The component props.
76618   *
76619   * @return {Element} The dimensions controls.
76620   */
76621  
76622  function DimensionsTool({
76623    panelId,
76624    value = {},
76625    onChange = () => {},
76626    aspectRatioOptions,
76627    // Default options handled by AspectRatioTool.
76628    defaultAspectRatio = 'auto',
76629    // Match CSS default value for aspect-ratio.
76630    scaleOptions,
76631    // Default options handled by ScaleTool.
76632    defaultScale = 'fill',
76633    // Match CSS default value for object-fit.
76634    unitsOptions,
76635    // Default options handled by UnitControl.
76636    tools = ['aspectRatio', 'widthHeight', 'scale']
76637  }) {
76638    // Coerce undefined and CSS default values to be null.
76639    const width = value.width === undefined || value.width === 'auto' ? null : value.width;
76640    const height = value.height === undefined || value.height === 'auto' ? null : value.height;
76641    const aspectRatio = value.aspectRatio === undefined || value.aspectRatio === 'auto' ? null : value.aspectRatio;
76642    const scale = value.scale === undefined || value.scale === 'fill' ? null : value.scale;
76643  
76644    // Keep track of state internally, so when the value is cleared by means
76645    // other than directly editing that field, it's easier to restore the
76646    // previous value.
76647    const [lastScale, setLastScale] = (0,external_wp_element_namespaceObject.useState)(scale);
76648    const [lastAspectRatio, setLastAspectRatio] = (0,external_wp_element_namespaceObject.useState)(aspectRatio);
76649  
76650    // 'custom' is not a valid value for CSS aspect-ratio, but it is used in the
76651    // dropdown to indicate that setting both the width and height is the same
76652    // as a custom aspect ratio.
76653    const aspectRatioValue = width && height ? 'custom' : lastAspectRatio;
76654    const showScaleControl = aspectRatio || width && height;
76655    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
76656      children: [tools.includes('aspectRatio') && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(AspectRatioTool, {
76657        panelId: panelId,
76658        options: aspectRatioOptions,
76659        defaultValue: defaultAspectRatio,
76660        value: aspectRatioValue,
76661        onChange: nextAspectRatio => {
76662          const nextValue = {
76663            ...value
76664          };
76665  
76666          // 'auto' is CSS default, so it gets treated as null.
76667          nextAspectRatio = nextAspectRatio === 'auto' ? null : nextAspectRatio;
76668          setLastAspectRatio(nextAspectRatio);
76669  
76670          // Update aspectRatio.
76671          if (!nextAspectRatio) {
76672            delete nextValue.aspectRatio;
76673          } else {
76674            nextValue.aspectRatio = nextAspectRatio;
76675          }
76676  
76677          // Auto-update scale.
76678          if (!nextAspectRatio) {
76679            delete nextValue.scale;
76680          } else if (lastScale) {
76681            nextValue.scale = lastScale;
76682          } else {
76683            nextValue.scale = defaultScale;
76684            setLastScale(defaultScale);
76685          }
76686  
76687          // Auto-update width and height.
76688          if ('custom' !== nextAspectRatio && width && height) {
76689            delete nextValue.height;
76690          }
76691          onChange(nextValue);
76692        }
76693      }), tools.includes('widthHeight') && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(WidthHeightTool, {
76694        panelId: panelId,
76695        units: unitsOptions,
76696        value: {
76697          width,
76698          height
76699        },
76700        onChange: ({
76701          width: nextWidth,
76702          height: nextHeight
76703        }) => {
76704          const nextValue = {
76705            ...value
76706          };
76707  
76708          // 'auto' is CSS default, so it gets treated as null.
76709          nextWidth = nextWidth === 'auto' ? null : nextWidth;
76710          nextHeight = nextHeight === 'auto' ? null : nextHeight;
76711  
76712          // Update width.
76713          if (!nextWidth) {
76714            delete nextValue.width;
76715          } else {
76716            nextValue.width = nextWidth;
76717          }
76718  
76719          // Update height.
76720          if (!nextHeight) {
76721            delete nextValue.height;
76722          } else {
76723            nextValue.height = nextHeight;
76724          }
76725  
76726          // Auto-update aspectRatio.
76727          if (nextWidth && nextHeight) {
76728            delete nextValue.aspectRatio;
76729          } else if (lastAspectRatio) {
76730            nextValue.aspectRatio = lastAspectRatio;
76731          } else {
76732            // No setting defaultAspectRatio here, because
76733            // aspectRatio is optional in this scenario,
76734            // unlike scale.
76735          }
76736  
76737          // Auto-update scale.
76738          if (!lastAspectRatio && !!nextWidth !== !!nextHeight) {
76739            delete nextValue.scale;
76740          } else if (lastScale) {
76741            nextValue.scale = lastScale;
76742          } else {
76743            nextValue.scale = defaultScale;
76744            setLastScale(defaultScale);
76745          }
76746          onChange(nextValue);
76747        }
76748      }), tools.includes('scale') && showScaleControl && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ScaleTool, {
76749        panelId: panelId,
76750        options: scaleOptions,
76751        defaultValue: defaultScale,
76752        value: lastScale,
76753        onChange: nextScale => {
76754          const nextValue = {
76755            ...value
76756          };
76757  
76758          // 'fill' is CSS default, so it gets treated as null.
76759          nextScale = nextScale === 'fill' ? null : nextScale;
76760          setLastScale(nextScale);
76761  
76762          // Update scale.
76763          if (!nextScale) {
76764            delete nextValue.scale;
76765          } else {
76766            nextValue.scale = nextScale;
76767          }
76768          onChange(nextValue);
76769        }
76770      })]
76771    });
76772  }
76773  /* harmony default export */ const dimensions_tool = (DimensionsTool);
76774  
76775  ;// ./node_modules/@wordpress/block-editor/build-module/components/resolution-tool/index.js
76776  /**
76777   * WordPress dependencies
76778   */
76779  
76780  
76781  
76782  const DEFAULT_SIZE_OPTIONS = [{
76783    label: (0,external_wp_i18n_namespaceObject._x)('Thumbnail', 'Image size option for resolution control'),
76784    value: 'thumbnail'
76785  }, {
76786    label: (0,external_wp_i18n_namespaceObject._x)('Medium', 'Image size option for resolution control'),
76787    value: 'medium'
76788  }, {
76789    label: (0,external_wp_i18n_namespaceObject._x)('Large', 'Image size option for resolution control'),
76790    value: 'large'
76791  }, {
76792    label: (0,external_wp_i18n_namespaceObject._x)('Full Size', 'Image size option for resolution control'),
76793    value: 'full'
76794  }];
76795  function ResolutionTool({
76796    panelId,
76797    value,
76798    onChange,
76799    options = DEFAULT_SIZE_OPTIONS,
76800    defaultValue = DEFAULT_SIZE_OPTIONS[0].value,
76801    isShownByDefault = true,
76802    resetAllFilter
76803  }) {
76804    const displayValue = value !== null && value !== void 0 ? value : defaultValue;
76805    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanelItem, {
76806      hasValue: () => displayValue !== defaultValue,
76807      label: (0,external_wp_i18n_namespaceObject.__)('Resolution'),
76808      onDeselect: () => onChange(defaultValue),
76809      isShownByDefault: isShownByDefault,
76810      panelId: panelId,
76811      resetAllFilter: resetAllFilter,
76812      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.SelectControl, {
76813        __nextHasNoMarginBottom: true,
76814        label: (0,external_wp_i18n_namespaceObject.__)('Resolution'),
76815        value: displayValue,
76816        options: options,
76817        onChange: onChange,
76818        help: (0,external_wp_i18n_namespaceObject.__)('Select the size of the source image.'),
76819        size: "__unstable-large"
76820      })
76821    });
76822  }
76823  
76824  ;// ./node_modules/@wordpress/block-editor/build-module/private-apis.js
76825  /**
76826   * Internal dependencies
76827   */
76828  
76829  
76830  
76831  
76832  
76833  
76834  
76835  
76836  
76837  
76838  
76839  
76840  
76841  
76842  
76843  
76844  
76845  
76846  
76847  
76848  
76849  
76850  
76851  
76852  
76853  
76854  
76855  
76856  
76857  
76858  
76859  
76860  
76861  /**
76862   * Private @wordpress/block-editor APIs.
76863   */
76864  const privateApis = {};
76865  lock(privateApis, {
76866    ...global_styles_namespaceObject,
76867    ExperimentalBlockCanvas: ExperimentalBlockCanvas,
76868    ExperimentalBlockEditorProvider: ExperimentalBlockEditorProvider,
76869    getDuotoneFilter: getDuotoneFilter,
76870    getRichTextValues: getRichTextValues,
76871    PrivateQuickInserter: QuickInserter,
76872    extractWords: extractWords,
76873    getNormalizedSearchTerms: getNormalizedSearchTerms,
76874    normalizeString: normalizeString,
76875    PrivateListView: PrivateListView,
76876    ResizableBoxPopover: ResizableBoxPopover,
76877    useHasBlockToolbar: useHasBlockToolbar,
76878    cleanEmptyObject: utils_cleanEmptyObject,
76879    BlockQuickNavigation: BlockQuickNavigation,
76880    LayoutStyle: LayoutStyle,
76881    BlockManager: BlockManager,
76882    BlockRemovalWarningModal: BlockRemovalWarningModal,
76883    useLayoutClasses: useLayoutClasses,
76884    useLayoutStyles: useLayoutStyles,
76885    DimensionsTool: dimensions_tool,
76886    ResolutionTool: ResolutionTool,
76887    TabbedSidebar: tabbed_sidebar,
76888    TextAlignmentControl: TextAlignmentControl,
76889    usesContextKey: usesContextKey,
76890    useFlashEditableBlocks: useFlashEditableBlocks,
76891    useZoomOut: useZoomOut,
76892    globalStylesDataKey: globalStylesDataKey,
76893    globalStylesLinksDataKey: globalStylesLinksDataKey,
76894    selectBlockPatternsKey: selectBlockPatternsKey,
76895    requiresWrapperOnCopy: requiresWrapperOnCopy,
76896    PrivateRichText: PrivateRichText,
76897    PrivateInserterLibrary: PrivateInserterLibrary,
76898    reusableBlocksSelectKey: reusableBlocksSelectKey,
76899    PrivateBlockPopover: PrivateBlockPopover,
76900    PrivatePublishDateTimePicker: PrivatePublishDateTimePicker,
76901    useSpacingSizes: useSpacingSizes,
76902    useBlockDisplayTitle: useBlockDisplayTitle,
76903    __unstableBlockStyleVariationOverridesWithConfig: __unstableBlockStyleVariationOverridesWithConfig,
76904    setBackgroundStyleDefaults: setBackgroundStyleDefaults,
76905    sectionRootClientIdKey: sectionRootClientIdKey,
76906    CommentIconSlotFill: block_comment_icon_slot,
76907    CommentIconToolbarSlotFill: block_comment_icon_toolbar_slot
76908  });
76909  
76910  ;// ./node_modules/@wordpress/block-editor/build-module/index.js
76911  /**
76912   * Internal dependencies
76913   */
76914  
76915  
76916  
76917  
76918  
76919  
76920  
76921  
76922  
76923  })();
76924  
76925  (window.wp = window.wp || {}).blockEditor = __webpack_exports__;
76926  /******/ })()
76927  ;