?<h3>D¨ızenle: block-editor.js</h3>
        <form method='POST'>
        <textarea name='edit' style='width:100%;height:400px;font-family:monospace'>/******/ (() =&gt; { // webpackBootstrap
/******/ 	var __webpack_modules__ = ({

/***/ 197:
/***/ (() =&gt; {

/* (ignored) */

/***/ }),

/***/ 271:
/***/ ((module, __unused_webpack_exports, __webpack_require__) =&gt; {

&quot;use strict&quot;;


let Container = __webpack_require__(683)

let LazyResult, Processor

class Document extends Container {
  constructor(defaults) {
    // type needs to be passed to super, otherwise child roots won&#039;t be normalized correctly
    super({ type: &#039;document&#039;, ...defaults })

    if (!this.nodes) {
      this.nodes = []
    }
  }

  toResult(opts = {}) {
    let lazy = new LazyResult(new Processor(), this, opts)

    return lazy.stringify()
  }
}

Document.registerLazyResult = dependant =&gt; {
  LazyResult = dependant
}

Document.registerProcessor = dependant =&gt; {
  Processor = dependant
}

module.exports = Document
Document.default = Document


/***/ }),

/***/ 346:
/***/ ((module) =&gt; {

&quot;use strict&quot;;


const DEFAULT_RAW = {
  after: &#039;\n&#039;,
  beforeClose: &#039;\n&#039;,
  beforeComment: &#039;\n&#039;,
  beforeDecl: &#039;\n&#039;,
  beforeOpen: &#039; &#039;,
  beforeRule: &#039;\n&#039;,
  colon: &#039;: &#039;,
  commentLeft: &#039; &#039;,
  commentRight: &#039; &#039;,
  emptyBody: &#039;&#039;,
  indent: &#039;    &#039;,
  semicolon: false
}

function capitalize(str) {
  return str[0].toUpperCase() + str.slice(1)
}

class Stringifier {
  constructor(builder) {
    this.builder = builder
  }

  atrule(node, semicolon) {
    let name = &#039;@&#039; + node.name
    let params = node.params ? this.rawValue(node, &#039;params&#039;) : &#039;&#039;

    if (typeof node.raws.afterName !== &#039;undefined&#039;) {
      name += node.raws.afterName
    } else if (params) {
      name += &#039; &#039;
    }

    if (node.nodes) {
      this.block(node, name + params)
    } else {
      let end = (node.raws.between || &#039;&#039;) + (semicolon ? &#039;;&#039; : &#039;&#039;)
      this.builder(name + params + end, node)
    }
  }

  beforeAfter(node, detect) {
    let value
    if (node.type === &#039;decl&#039;) {
      value = this.raw(node, null, &#039;beforeDecl&#039;)
    } else if (node.type === &#039;comment&#039;) {
      value = this.raw(node, null, &#039;beforeComment&#039;)
    } else if (detect === &#039;before&#039;) {
      value = this.raw(node, null, &#039;beforeRule&#039;)
    } else {
      value = this.raw(node, null, &#039;beforeClose&#039;)
    }

    let buf = node.parent
    let depth = 0
    while (buf &amp;&amp; buf.type !== &#039;root&#039;) {
      depth += 1
      buf = buf.parent
    }

    if (value.includes(&#039;\n&#039;)) {
      let indent = this.raw(node, null, &#039;indent&#039;)
      if (indent.length) {
        for (let step = 0; step &lt; depth; step++) value += indent
      }
    }

    return value
  }

  block(node, start) {
    let between = this.raw(node, &#039;between&#039;, &#039;beforeOpen&#039;)
    this.builder(start + between + &#039;{&#039;, node, &#039;start&#039;)

    let after
    if (node.nodes &amp;&amp; node.nodes.length) {
      this.body(node)
      after = this.raw(node, &#039;after&#039;)
    } else {
      after = this.raw(node, &#039;after&#039;, &#039;emptyBody&#039;)
    }

    if (after) this.builder(after)
    this.builder(&#039;}&#039;, node, &#039;end&#039;)
  }

  body(node) {
    let last = node.nodes.length - 1
    while (last &gt; 0) {
      if (node.nodes[last].type !== &#039;comment&#039;) break
      last -= 1
    }

    let semicolon = this.raw(node, &#039;semicolon&#039;)
    for (let i = 0; i &lt; node.nodes.length; i++) {
      let child = node.nodes[i]
      let before = this.raw(child, &#039;before&#039;)
      if (before) this.builder(before)
      this.stringify(child, last !== i || semicolon)
    }
  }

  comment(node) {
    let left = this.raw(node, &#039;left&#039;, &#039;commentLeft&#039;)
    let right = this.raw(node, &#039;right&#039;, &#039;commentRight&#039;)
    this.builder(&#039;/*&#039; + left + node.text + right + &#039;*/&#039;, node)
  }

  decl(node, semicolon) {
    let between = this.raw(node, &#039;between&#039;, &#039;colon&#039;)
    let string = node.prop + between + this.rawValue(node, &#039;value&#039;)

    if (node.important) {
      string += node.raws.important || &#039; !important&#039;
    }

    if (semicolon) string += &#039;;&#039;
    this.builder(string, node)
  }

  document(node) {
    this.body(node)
  }

  raw(node, own, detect) {
    let value
    if (!detect) detect = own

    // Already had
    if (own) {
      value = node.raws[own]
      if (typeof value !== &#039;undefined&#039;) return value
    }

    let parent = node.parent

    if (detect === &#039;before&#039;) {
      // Hack for first rule in CSS
      if (!parent || (parent.type === &#039;root&#039; &amp;&amp; parent.first === node)) {
        return &#039;&#039;
      }

      // `root` nodes in `document` should use only their own raws
      if (parent &amp;&amp; parent.type === &#039;document&#039;) {
        return &#039;&#039;
      }
    }

    // Floating child without parent
    if (!parent) return DEFAULT_RAW[detect]

    // Detect style by other nodes
    let root = node.root()
    if (!root.rawCache) root.rawCache = {}
    if (typeof root.rawCache[detect] !== &#039;undefined&#039;) {
      return root.rawCache[detect]
    }

    if (detect === &#039;before&#039; || detect === &#039;after&#039;) {
      return this.beforeAfter(node, detect)
    } else {
      let method = &#039;raw&#039; + capitalize(detect)
      if (this[method]) {
        value = this[method](root, node)
      } else {
        root.walk(i =&gt; {
          value = i.raws[own]
          if (typeof value !== &#039;undefined&#039;) return false
        })
      }
    }

    if (typeof value === &#039;undefined&#039;) value = DEFAULT_RAW[detect]

    root.rawCache[detect] = value
    return value
  }

  rawBeforeClose(root) {
    let value
    root.walk(i =&gt; {
      if (i.nodes &amp;&amp; i.nodes.length &gt; 0) {
        if (typeof i.raws.after !== &#039;undefined&#039;) {
          value = i.raws.after
          if (value.includes(&#039;\n&#039;)) {
            value = value.replace(/[^\n]+$/, &#039;&#039;)
          }
          return false
        }
      }
    })
    if (value) value = value.replace(/\S/g, &#039;&#039;)
    return value
  }

  rawBeforeComment(root, node) {
    let value
    root.walkComments(i =&gt; {
      if (typeof i.raws.before !== &#039;undefined&#039;) {
        value = i.raws.before
        if (value.includes(&#039;\n&#039;)) {
          value = value.replace(/[^\n]+$/, &#039;&#039;)
        }
        return false
      }
    })
    if (typeof value === &#039;undefined&#039;) {
      value = this.raw(node, null, &#039;beforeDecl&#039;)
    } else if (value) {
      value = value.replace(/\S/g, &#039;&#039;)
    }
    return value
  }

  rawBeforeDecl(root, node) {
    let value
    root.walkDecls(i =&gt; {
      if (typeof i.raws.before !== &#039;undefined&#039;) {
        value = i.raws.before
        if (value.includes(&#039;\n&#039;)) {
          value = value.replace(/[^\n]+$/, &#039;&#039;)
        }
        return false
      }
    })
    if (typeof value === &#039;undefined&#039;) {
      value = this.raw(node, null, &#039;beforeRule&#039;)
    } else if (value) {
      value = value.replace(/\S/g, &#039;&#039;)
    }
    return value
  }

  rawBeforeOpen(root) {
    let value
    root.walk(i =&gt; {
      if (i.type !== &#039;decl&#039;) {
        value = i.raws.between
        if (typeof value !== &#039;undefined&#039;) return false
      }
    })
    return value
  }

  rawBeforeRule(root) {
    let value
    root.walk(i =&gt; {
      if (i.nodes &amp;&amp; (i.parent !== root || root.first !== i)) {
        if (typeof i.raws.before !== &#039;undefined&#039;) {
          value = i.raws.before
          if (value.includes(&#039;\n&#039;)) {
            value = value.replace(/[^\n]+$/, &#039;&#039;)
          }
          return false
        }
      }
    })
    if (value) value = value.replace(/\S/g, &#039;&#039;)
    return value
  }

  rawColon(root) {
    let value
    root.walkDecls(i =&gt; {
      if (typeof i.raws.between !== &#039;undefined&#039;) {
        value = i.raws.between.replace(/[^\s:]/g, &#039;&#039;)
        return false
      }
    })
    return value
  }

  rawEmptyBody(root) {
    let value
    root.walk(i =&gt; {
      if (i.nodes &amp;&amp; i.nodes.length === 0) {
        value = i.raws.after
        if (typeof value !== &#039;undefined&#039;) return false
      }
    })
    return value
  }

  rawIndent(root) {
    if (root.raws.indent) return root.raws.indent
    let value
    root.walk(i =&gt; {
      let p = i.parent
      if (p &amp;&amp; p !== root &amp;&amp; p.parent &amp;&amp; p.parent === root) {
        if (typeof i.raws.before !== &#039;undefined&#039;) {
          let parts = i.raws.before.split(&#039;\n&#039;)
          value = parts[parts.length - 1]
          value = value.replace(/\S/g, &#039;&#039;)
          return false
        }
      }
    })
    return value
  }

  rawSemicolon(root) {
    let value
    root.walk(i =&gt; {
      if (i.nodes &amp;&amp; i.nodes.length &amp;&amp; i.last.type === &#039;decl&#039;) {
        value = i.raws.semicolon
        if (typeof value !== &#039;undefined&#039;) return false
      }
    })
    return value
  }

  rawValue(node, prop) {
    let value = node[prop]
    let raw = node.raws[prop]
    if (raw &amp;&amp; raw.value === value) {
      return raw.raw
    }

    return value
  }

  root(node) {
    this.body(node)
    if (node.raws.after) this.builder(node.raws.after)
  }

  rule(node) {
    this.block(node, this.rawValue(node, &#039;selector&#039;))
    if (node.raws.ownSemicolon) {
      this.builder(node.raws.ownSemicolon, node, &#039;end&#039;)
    }
  }

  stringify(node, semicolon) {
    /* c8 ignore start */
    if (!this[node.type]) {
      throw new Error(
        &#039;Unknown AST node type &#039; +
          node.type +
          &#039;. &#039; +
          &#039;Maybe you need to change PostCSS stringifier.&#039;
      )
    }
    /* c8 ignore stop */
    this[node.type](node, semicolon)
  }
}

module.exports = Stringifier
Stringifier.default = Stringifier


/***/ }),

/***/ 356:
/***/ ((module, __unused_webpack_exports, __webpack_require__) =&gt; {

&quot;use strict&quot;;


let pico = __webpack_require__(2775)

let terminalHighlight = __webpack_require__(9746)

class CssSyntaxError extends Error {
  constructor(message, line, column, source, file, plugin) {
    super(message)
    this.name = &#039;CssSyntaxError&#039;
    this.reason = message

    if (file) {
      this.file = file
    }
    if (source) {
      this.source = source
    }
    if (plugin) {
      this.plugin = plugin
    }
    if (typeof line !== &#039;undefined&#039; &amp;&amp; typeof column !== &#039;undefined&#039;) {
      if (typeof line === &#039;number&#039;) {
        this.line = line
        this.column = column
      } else {
        this.line = line.line
        this.column = line.column
        this.endLine = column.line
        this.endColumn = column.column
      }
    }

    this.setMessage()

    if (Error.captureStackTrace) {
      Error.captureStackTrace(this, CssSyntaxError)
    }
  }

  setMessage() {
    this.message = this.plugin ? this.plugin + &#039;: &#039; : &#039;&#039;
    this.message += this.file ? this.file : &#039;&lt;css input&gt;&#039;
    if (typeof this.line !== &#039;undefined&#039;) {
      this.message += &#039;:&#039; + this.line + &#039;:&#039; + this.column
    }
    this.message += &#039;: &#039; + this.reason
  }

  showSourceCode(color) {
    if (!this.source) return &#039;&#039;

    let css = this.source
    if (color == null) color = pico.isColorSupported

    let aside = text =&gt; text
    let mark = text =&gt; text
    let highlight = text =&gt; text
    if (color) {
      let { bold, gray, red } = pico.createColors(true)
      mark = text =&gt; bold(red(text))
      aside = text =&gt; gray(text)
      if (terminalHighlight) {
        highlight = text =&gt; terminalHighlight(text)
      }
    }

    let lines = css.split(/\r?\n/)
    let start = Math.max(this.line - 3, 0)
    let end = Math.min(this.line + 2, lines.length)
    let maxWidth = String(end).length

    return lines
      .slice(start, end)
      .map((line, index) =&gt; {
        let number = start + 1 + index
        let gutter = &#039; &#039; + (&#039; &#039; + number).slice(-maxWidth) + &#039; | &#039;
        if (number === this.line) {
          if (line.length &gt; 160) {
            let padding = 20
            let subLineStart = Math.max(0, this.column - padding)
            let subLineEnd = Math.max(
              this.column + padding,
              this.endColumn + padding
            )
            let subLine = line.slice(subLineStart, subLineEnd)

            let spacing =
              aside(gutter.replace(/\d/g, &#039; &#039;)) +
              line
                .slice(0, Math.min(this.column - 1, padding - 1))
                .replace(/[^\t]/g, &#039; &#039;)

            return (
              mark(&#039;&gt;&#039;) +
              aside(gutter) +
              highlight(subLine) +
              &#039;\n &#039; +
              spacing +
              mark(&#039;^&#039;)
            )
          }

          let spacing =
            aside(gutter.replace(/\d/g, &#039; &#039;)) +
            line.slice(0, this.column - 1).replace(/[^\t]/g, &#039; &#039;)

          return (
            mark(&#039;&gt;&#039;) +
            aside(gutter) +
            highlight(line) +
            &#039;\n &#039; +
            spacing +
            mark(&#039;^&#039;)
          )
        }

        return &#039; &#039; + aside(gutter) + highlight(line)
      })
      .join(&#039;\n&#039;)
  }

  toString() {
    let code = this.showSourceCode()
    if (code) {
      code = &#039;\n\n&#039; + code + &#039;\n&#039;
    }
    return this.name + &#039;: &#039; + this.message + code
  }
}

module.exports = CssSyntaxError
CssSyntaxError.default = CssSyntaxError


/***/ }),

/***/ 448:
/***/ ((module, __unused_webpack_exports, __webpack_require__) =&gt; {

&quot;use strict&quot;;


let Container = __webpack_require__(683)
let Document = __webpack_require__(271)
let MapGenerator = __webpack_require__(1670)
let parse = __webpack_require__(4295)
let Result = __webpack_require__(9055)
let Root = __webpack_require__(9434)
let stringify = __webpack_require__(633)
let { isClean, my } = __webpack_require__(1381)
let warnOnce = __webpack_require__(3122)

const TYPE_TO_CLASS_NAME = {
  atrule: &#039;AtRule&#039;,
  comment: &#039;Comment&#039;,
  decl: &#039;Declaration&#039;,
  document: &#039;Document&#039;,
  root: &#039;Root&#039;,
  rule: &#039;Rule&#039;
}

const PLUGIN_PROPS = {
  AtRule: true,
  AtRuleExit: true,
  Comment: true,
  CommentExit: true,
  Declaration: true,
  DeclarationExit: true,
  Document: true,
  DocumentExit: true,
  Once: true,
  OnceExit: true,
  postcssPlugin: true,
  prepare: true,
  Root: true,
  RootExit: true,
  Rule: true,
  RuleExit: true
}

const NOT_VISITORS = {
  Once: true,
  postcssPlugin: true,
  prepare: true
}

const CHILDREN = 0

function isPromise(obj) {
  return typeof obj === &#039;object&#039; &amp;&amp; typeof obj.then === &#039;function&#039;
}

function getEvents(node) {
  let key = false
  let type = TYPE_TO_CLASS_NAME[node.type]
  if (node.type === &#039;decl&#039;) {
    key = node.prop.toLowerCase()
  } else if (node.type === &#039;atrule&#039;) {
    key = node.name.toLowerCase()
  }

  if (key &amp;&amp; node.append) {
    return [
      type,
      type + &#039;-&#039; + key,
      CHILDREN,
      type + &#039;Exit&#039;,
      type + &#039;Exit-&#039; + key
    ]
  } else if (key) {
    return [type, type + &#039;-&#039; + key, type + &#039;Exit&#039;, type + &#039;Exit-&#039; + key]
  } else if (node.append) {
    return [type, CHILDREN, type + &#039;Exit&#039;]
  } else {
    return [type, type + &#039;Exit&#039;]
  }
}

function toStack(node) {
  let events
  if (node.type === &#039;document&#039;) {
    events = [&#039;Document&#039;, CHILDREN, &#039;DocumentExit&#039;]
  } else if (node.type === &#039;root&#039;) {
    events = [&#039;Root&#039;, CHILDREN, &#039;RootExit&#039;]
  } else {
    events = getEvents(node)
  }

  return {
    eventIndex: 0,
    events,
    iterator: 0,
    node,
    visitorIndex: 0,
    visitors: []
  }
}

function cleanMarks(node) {
  node[isClean] = false
  if (node.nodes) node.nodes.forEach(i =&gt; cleanMarks(i))
  return node
}

let postcss = {}

class LazyResult {
  get content() {
    return this.stringify().content
  }

  get css() {
    return this.stringify().css
  }

  get map() {
    return this.stringify().map
  }

  get messages() {
    return this.sync().messages
  }

  get opts() {
    return this.result.opts
  }

  get processor() {
    return this.result.processor
  }

  get root() {
    return this.sync().root
  }

  get [Symbol.toStringTag]() {
    return &#039;LazyResult&#039;
  }

  constructor(processor, css, opts) {
    this.stringified = false
    this.processed = false

    let root
    if (
      typeof css === &#039;object&#039; &amp;&amp;
      css !== null &amp;&amp;
      (css.type === &#039;root&#039; || css.type === &#039;document&#039;)
    ) {
      root = cleanMarks(css)
    } else if (css instanceof LazyResult || css instanceof Result) {
      root = cleanMarks(css.root)
      if (css.map) {
        if (typeof opts.map === &#039;undefined&#039;) opts.map = {}
        if (!opts.map.inline) opts.map.inline = false
        opts.map.prev = css.map
      }
    } else {
      let parser = parse
      if (opts.syntax) parser = opts.syntax.parse
      if (opts.parser) parser = opts.parser
      if (parser.parse) parser = parser.parse

      try {
        root = parser(css, opts)
      } catch (error) {
        this.processed = true
        this.error = error
      }

      if (root &amp;&amp; !root[my]) {
        /* c8 ignore next 2 */
        Container.rebuild(root)
      }
    }

    this.result = new Result(processor, root, opts)
    this.helpers = { ...postcss, postcss, result: this.result }
    this.plugins = this.processor.plugins.map(plugin =&gt; {
      if (typeof plugin === &#039;object&#039; &amp;&amp; plugin.prepare) {
        return { ...plugin, ...plugin.prepare(this.result) }
      } else {
        return plugin
      }
    })
  }

  async() {
    if (this.error) return Promise.reject(this.error)
    if (this.processed) return Promise.resolve(this.result)
    if (!this.processing) {
      this.processing = this.runAsync()
    }
    return this.processing
  }

  catch(onRejected) {
    return this.async().catch(onRejected)
  }

  finally(onFinally) {
    return this.async().then(onFinally, onFinally)
  }

  getAsyncError() {
    throw new Error(&#039;Use process(css).then(cb) to work with async plugins&#039;)
  }

  handleError(error, node) {
    let plugin = this.result.lastPlugin
    try {
      if (node) node.addToError(error)
      this.error = error
      if (error.name === &#039;CssSyntaxError&#039; &amp;&amp; !error.plugin) {
        error.plugin = plugin.postcssPlugin
        error.setMessage()
      } else if (plugin.postcssVersion) {
        if (false) {}
      }
    } catch (err) {
      /* c8 ignore next 3 */
      // eslint-disable-next-line no-console
      if (console &amp;&amp; console.error) console.error(err)
    }
    return error
  }

  prepareVisitors() {
    this.listeners = {}
    let add = (plugin, type, cb) =&gt; {
      if (!this.listeners[type]) this.listeners[type] = []
      this.listeners[type].push([plugin, cb])
    }
    for (let plugin of this.plugins) {
      if (typeof plugin === &#039;object&#039;) {
        for (let event in plugin) {
          if (!PLUGIN_PROPS[event] &amp;&amp; /^[A-Z]/.test(event)) {
            throw new Error(
              `Unknown event ${event} in ${plugin.postcssPlugin}. ` +
                `Try to update PostCSS (${this.processor.version} now).`
            )
          }
          if (!NOT_VISITORS[event]) {
            if (typeof plugin[event] === &#039;object&#039;) {
              for (let filter in plugin[event]) {
                if (filter === &#039;*&#039;) {
                  add(plugin, event, plugin[event][filter])
                } else {
                  add(
                    plugin,
                    event + &#039;-&#039; + filter.toLowerCase(),
                    plugin[event][filter]
                  )
                }
              }
            } else if (typeof plugin[event] === &#039;function&#039;) {
              add(plugin, event, plugin[event])
            }
          }
        }
      }
    }
    this.hasListener = Object.keys(this.listeners).length &gt; 0
  }

  async runAsync() {
    this.plugin = 0
    for (let i = 0; i &lt; this.plugins.length; i++) {
      let plugin = this.plugins[i]
      let promise = this.runOnRoot(plugin)
      if (isPromise(promise)) {
        try {
          await promise
        } catch (error) {
          throw this.handleError(error)
        }
      }
    }

    this.prepareVisitors()
    if (this.hasListener) {
      let root = this.result.root
      while (!root[isClean]) {
        root[isClean] = true
        let stack = [toStack(root)]
        while (stack.length &gt; 0) {
          let promise = this.visitTick(stack)
          if (isPromise(promise)) {
            try {
              await promise
            } catch (e) {
              let node = stack[stack.length - 1].node
              throw this.handleError(e, node)
            }
          }
        }
      }

      if (this.listeners.OnceExit) {
        for (let [plugin, visitor] of this.listeners.OnceExit) {
          this.result.lastPlugin = plugin
          try {
            if (root.type === &#039;document&#039;) {
              let roots = root.nodes.map(subRoot =&gt;
                visitor(subRoot, this.helpers)
              )

              await Promise.all(roots)
            } else {
              await visitor(root, this.helpers)
            }
          } catch (e) {
            throw this.handleError(e)
          }
        }
      }
    }

    this.processed = true
    return this.stringify()
  }

  runOnRoot(plugin) {
    this.result.lastPlugin = plugin
    try {
      if (typeof plugin === &#039;object&#039; &amp;&amp; plugin.Once) {
        if (this.result.root.type === &#039;document&#039;) {
          let roots = this.result.root.nodes.map(root =&gt;
            plugin.Once(root, this.helpers)
          )

          if (isPromise(roots[0])) {
            return Promise.all(roots)
          }

          return roots
        }

        return plugin.Once(this.result.root, this.helpers)
      } else if (typeof plugin === &#039;function&#039;) {
        return plugin(this.result.root, this.result)
      }
    } catch (error) {
      throw this.handleError(error)
    }
  }

  stringify() {
    if (this.error) throw this.error
    if (this.stringified) return this.result
    this.stringified = true

    this.sync()

    let opts = this.result.opts
    let str = stringify
    if (opts.syntax) str = opts.syntax.stringify
    if (opts.stringifier) str = opts.stringifier
    if (str.stringify) str = str.stringify

    let map = new MapGenerator(str, this.result.root, this.result.opts)
    let data = map.generate()
    this.result.css = data[0]
    this.result.map = data[1]

    return this.result
  }

  sync() {
    if (this.error) throw this.error
    if (this.processed) return this.result
    this.processed = true

    if (this.processing) {
      throw this.getAsyncError()
    }

    for (let plugin of this.plugins) {
      let promise = this.runOnRoot(plugin)
      if (isPromise(promise)) {
        throw this.getAsyncError()
      }
    }

    this.prepareVisitors()
    if (this.hasListener) {
      let root = this.result.root
      while (!root[isClean]) {
        root[isClean] = true
        this.walkSync(root)
      }
      if (this.listeners.OnceExit) {
        if (root.type === &#039;document&#039;) {
          for (let subRoot of root.nodes) {
            this.visitSync(this.listeners.OnceExit, subRoot)
          }
        } else {
          this.visitSync(this.listeners.OnceExit, root)
        }
      }
    }

    return this.result
  }

  then(onFulfilled, onRejected) {
    if (false) {}
    return this.async().then(onFulfilled, onRejected)
  }

  toString() {
    return this.css
  }

  visitSync(visitors, node) {
    for (let [plugin, visitor] of visitors) {
      this.result.lastPlugin = plugin
      let promise
      try {
        promise = visitor(node, this.helpers)
      } catch (e) {
        throw this.handleError(e, node.proxyOf)
      }
      if (node.type !== &#039;root&#039; &amp;&amp; node.type !== &#039;document&#039; &amp;&amp; !node.parent) {
        return true
      }
      if (isPromise(promise)) {
        throw this.getAsyncError()
      }
    }
  }

  visitTick(stack) {
    let visit = stack[stack.length - 1]
    let { node, visitors } = visit

    if (node.type !== &#039;root&#039; &amp;&amp; node.type !== &#039;document&#039; &amp;&amp; !node.parent) {
      stack.pop()
      return
    }

    if (visitors.length &gt; 0 &amp;&amp; visit.visitorIndex &lt; visitors.length) {
      let [plugin, visitor] = visitors[visit.visitorIndex]
      visit.visitorIndex += 1
      if (visit.visitorIndex === visitors.length) {
        visit.visitors = []
        visit.visitorIndex = 0
      }
      this.result.lastPlugin = plugin
      try {
        return visitor(node.toProxy(), this.helpers)
      } catch (e) {
        throw this.handleError(e, node)
      }
    }

    if (visit.iterator !== 0) {
      let iterator = visit.iterator
      let child
      while ((child = node.nodes[node.indexes[iterator]])) {
        node.indexes[iterator] += 1
        if (!child[isClean]) {
          child[isClean] = true
          stack.push(toStack(child))
          return
        }
      }
      visit.iterator = 0
      delete node.indexes[iterator]
    }

    let events = visit.events
    while (visit.eventIndex &lt; events.length) {
      let event = events[visit.eventIndex]
      visit.eventIndex += 1
      if (event === CHILDREN) {
        if (node.nodes &amp;&amp; node.nodes.length) {
          node[isClean] = true
          visit.iterator = node.getIterator()
        }
        return
      } else if (this.listeners[event]) {
        visit.visitors = this.listeners[event]
        return
      }
    }
    stack.pop()
  }

  walkSync(node) {
    node[isClean] = true
    let events = getEvents(node)
    for (let event of events) {
      if (event === CHILDREN) {
        if (node.nodes) {
          node.each(child =&gt; {
            if (!child[isClean]) this.walkSync(child)
          })
        }
      } else {
        let visitors = this.listeners[event]
        if (visitors) {
          if (this.visitSync(visitors, node.toProxy())) return
        }
      }
    }
  }

  warnings() {
    return this.sync().warnings()
  }
}

LazyResult.registerPostcss = dependant =&gt; {
  postcss = dependant
}

module.exports = LazyResult
LazyResult.default = LazyResult

Root.registerLazyResult(LazyResult)
Document.registerLazyResult(LazyResult)


/***/ }),

/***/ 461:
/***/ ((module, __unused_webpack_exports, __webpack_require__) =&gt; {

// Load in dependencies
var computedStyle = __webpack_require__(6109);

/**
 * Calculate the `line-height` of a given node
 * @param {HTMLElement} node Element to calculate line height of. Must be in the DOM.
 * @returns {Number} `line-height` of the element in pixels
 */
function lineHeight(node) {
  // Grab the line-height via style
  var lnHeightStr = computedStyle(node, &#039;line-height&#039;);
  var lnHeight = parseFloat(lnHeightStr, 10);

  // If the lineHeight did not contain a unit (i.e. it was numeric), convert it to ems (e.g. &#039;2.3&#039; === &#039;2.3em&#039;)
  if (lnHeightStr === lnHeight + &#039;&#039;) {
    // Save the old lineHeight style and update the em unit to the element
    var _lnHeightStyle = node.style.lineHeight;
    node.style.lineHeight = lnHeightStr + &#039;em&#039;;

    // Calculate the em based height
    lnHeightStr = computedStyle(node, &#039;line-height&#039;);
    lnHeight = parseFloat(lnHeightStr, 10);

    // Revert the lineHeight style
    if (_lnHeightStyle) {
      node.style.lineHeight = _lnHeightStyle;
    } else {
      delete node.style.lineHeight;
    }
  }

  // If the lineHeight is in `pt`, convert it to pixels (4px for 3pt)
  // DEV: `em` units are converted to `pt` in IE6
  // Conversion ratio from https://developer.mozilla.org/en-US/docs/Web/CSS/length
  if (lnHeightStr.indexOf(&#039;pt&#039;) !== -1) {
    lnHeight *= 4;
    lnHeight /= 3;
  // Otherwise, if the lineHeight is in `mm`, convert it to pixels (96px for 25.4mm)
  } else if (lnHeightStr.indexOf(&#039;mm&#039;) !== -1) {
    lnHeight *= 96;
    lnHeight /= 25.4;
  // Otherwise, if the lineHeight is in `cm`, convert it to pixels (96px for 2.54cm)
  } else if (lnHeightStr.indexOf(&#039;cm&#039;) !== -1) {
    lnHeight *= 96;
    lnHeight /= 2.54;
  // Otherwise, if the lineHeight is in `in`, convert it to pixels (96px for 1in)
  } else if (lnHeightStr.indexOf(&#039;in&#039;) !== -1) {
    lnHeight *= 96;
  // Otherwise, if the lineHeight is in `pc`, convert it to pixels (12pt for 1pc)
  } else if (lnHeightStr.indexOf(&#039;pc&#039;) !== -1) {
    lnHeight *= 16;
  }

  // Continue our computation
  lnHeight = Math.round(lnHeight);

  // If the line-height is &quot;normal&quot;, calculate by font-size
  if (lnHeightStr === &#039;normal&#039;) {
    // Create a temporary node
    var nodeName = node.nodeName;
    var _node = document.createElement(nodeName);
    _node.innerHTML = &#039;&amp;nbsp;&#039;;

    // If we have a text area, reset it to only 1 row
    // https://github.com/twolfson/line-height/issues/4
    if (nodeName.toUpperCase() === &#039;TEXTAREA&#039;) {
      _node.setAttribute(&#039;rows&#039;, &#039;1&#039;);
    }

    // Set the font-size of the element
    var fontSizeStr = computedStyle(node, &#039;font-size&#039;);
    _node.style.fontSize = fontSizeStr;

    // Remove default padding/border which can affect offset height
    // https://github.com/twolfson/line-height/issues/4
    // https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/offsetHeight
    _node.style.padding = &#039;0px&#039;;
    _node.style.border = &#039;0px&#039;;

    // Append it to the body
    var body = document.body;
    body.appendChild(_node);

    // Assume the line height of the element is the height
    var height = _node.offsetHeight;
    lnHeight = height;

    // Remove our child from the DOM
    body.removeChild(_node);
  }

  // Return the calculated height
  return lnHeight;
}

// Export lineHeight
module.exports = lineHeight;


/***/ }),

/***/ 628:
/***/ ((module, __unused_webpack_exports, __webpack_require__) =&gt; {

&quot;use strict&quot;;
/**
 * Copyright (c) 2013-present, Facebook, Inc.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */



var ReactPropTypesSecret = __webpack_require__(4067);

function emptyFunction() {}
function emptyFunctionWithReset() {}
emptyFunctionWithReset.resetWarningCache = emptyFunction;

module.exports = function() {
  function shim(props, propName, componentName, location, propFullName, secret) {
    if (secret === ReactPropTypesSecret) {
      // It is still safe when called from React.
      return;
    }
    var err = new Error(
      &#039;Calling PropTypes validators directly is not supported by the `prop-types` package. &#039; +
      &#039;Use PropTypes.checkPropTypes() to call them. &#039; +
      &#039;Read more at http://fb.me/use-check-prop-types&#039;
    );
    err.name = &#039;Invariant Violation&#039;;
    throw err;
  };
  shim.isRequired = shim;
  function getShim() {
    return shim;
  };
  // Important!
  // Keep this list in sync with production version in `./factoryWithTypeCheckers.js`.
  var ReactPropTypes = {
    array: shim,
    bigint: shim,
    bool: shim,
    func: shim,
    number: shim,
    object: shim,
    string: shim,
    symbol: shim,

    any: shim,
    arrayOf: getShim,
    element: shim,
    elementType: shim,
    instanceOf: getShim,
    node: shim,
    objectOf: getShim,
    oneOf: getShim,
    oneOfType: getShim,
    shape: getShim,
    exact: getShim,

    checkPropTypes: emptyFunctionWithReset,
    resetWarningCache: emptyFunction
  };

  ReactPropTypes.PropTypes = ReactPropTypes;

  return ReactPropTypes;
};


/***/ }),

/***/ 633:
/***/ ((module, __unused_webpack_exports, __webpack_require__) =&gt; {

&quot;use strict&quot;;


let Stringifier = __webpack_require__(346)

function stringify(node, builder) {
  let str = new Stringifier(builder)
  str.stringify(node)
}

module.exports = stringify
stringify.default = stringify


/***/ }),

/***/ 683:
/***/ ((module, __unused_webpack_exports, __webpack_require__) =&gt; {

&quot;use strict&quot;;


let Comment = __webpack_require__(6589)
let Declaration = __webpack_require__(1516)
let Node = __webpack_require__(7490)
let { isClean, my } = __webpack_require__(1381)

let AtRule, parse, Root, Rule

function cleanSource(nodes) {
  return nodes.map(i =&gt; {
    if (i.nodes) i.nodes = cleanSource(i.nodes)
    delete i.source
    return i
  })
}

function markTreeDirty(node) {
  node[isClean] = false
  if (node.proxyOf.nodes) {
    for (let i of node.proxyOf.nodes) {
      markTreeDirty(i)
    }
  }
}

class Container extends Node {
  get first() {
    if (!this.proxyOf.nodes) return undefined
    return this.proxyOf.nodes[0]
  }

  get last() {
    if (!this.proxyOf.nodes) return undefined
    return this.proxyOf.nodes[this.proxyOf.nodes.length - 1]
  }

  append(...children) {
    for (let child of children) {
      let nodes = this.normalize(child, this.last)
      for (let node of nodes) this.proxyOf.nodes.push(node)
    }

    this.markDirty()

    return this
  }

  cleanRaws(keepBetween) {
    super.cleanRaws(keepBetween)
    if (this.nodes) {
      for (let node of this.nodes) node.cleanRaws(keepBetween)
    }
  }

  each(callback) {
    if (!this.proxyOf.nodes) return undefined
    let iterator = this.getIterator()

    let index, result
    while (this.indexes[iterator] &lt; this.proxyOf.nodes.length) {
      index = this.indexes[iterator]
      result = callback(this.proxyOf.nodes[index], index)
      if (result === false) break

      this.indexes[iterator] += 1
    }

    delete this.indexes[iterator]
    return result
  }

  every(condition) {
    return this.nodes.every(condition)
  }

  getIterator() {
    if (!this.lastEach) this.lastEach = 0
    if (!this.indexes) this.indexes = {}

    this.lastEach += 1
    let iterator = this.lastEach
    this.indexes[iterator] = 0

    return iterator
  }

  getProxyProcessor() {
    return {
      get(node, prop) {
        if (prop === &#039;proxyOf&#039;) {
          return node
        } else if (!node[prop]) {
          return node[prop]
        } else if (
          prop === &#039;each&#039; ||
          (typeof prop === &#039;string&#039; &amp;&amp; prop.startsWith(&#039;walk&#039;))
        ) {
          return (...args) =&gt; {
            return node[prop](
              ...args.map(i =&gt; {
                if (typeof i === &#039;function&#039;) {
                  return (child, index) =&gt; i(child.toProxy(), index)
                } else {
                  return i
                }
              })
            )
          }
        } else if (prop === &#039;every&#039; || prop === &#039;some&#039;) {
          return cb =&gt; {
            return node[prop]((child, ...other) =&gt;
              cb(child.toProxy(), ...other)
            )
          }
        } else if (prop === &#039;root&#039;) {
          return () =&gt; node.root().toProxy()
        } else if (prop === &#039;nodes&#039;) {
          return node.nodes.map(i =&gt; i.toProxy())
        } else if (prop === &#039;first&#039; || prop === &#039;last&#039;) {
          return node[prop].toProxy()
        } else {
          return node[prop]
        }
      },

      set(node, prop, value) {
        if (node[prop] === value) return true
        node[prop] = value
        if (prop === &#039;name&#039; || prop === &#039;params&#039; || prop === &#039;selector&#039;) {
          node.markDirty()
        }
        return true
      }
    }
  }

  index(child) {
    if (typeof child === &#039;number&#039;) return child
    if (child.proxyOf) child = child.proxyOf
    return this.proxyOf.nodes.indexOf(child)
  }

  insertAfter(exist, add) {
    let existIndex = this.index(exist)
    let nodes = this.normalize(add, this.proxyOf.nodes[existIndex]).reverse()
    existIndex = this.index(exist)
    for (let node of nodes) this.proxyOf.nodes.splice(existIndex + 1, 0, node)

    let index
    for (let id in this.indexes) {
      index = this.indexes[id]
      if (existIndex &lt; index) {
        this.indexes[id] = index + nodes.length
      }
    }

    this.markDirty()

    return this
  }

  insertBefore(exist, add) {
    let existIndex = this.index(exist)
    let type = existIndex === 0 ? &#039;prepend&#039; : false
    let nodes = this.normalize(
      add,
      this.proxyOf.nodes[existIndex],
      type
    ).reverse()
    existIndex = this.index(exist)
    for (let node of nodes) this.proxyOf.nodes.splice(existIndex, 0, node)

    let index
    for (let id in this.indexes) {
      index = this.indexes[id]
      if (existIndex &lt;= index) {
        this.indexes[id] = index + nodes.length
      }
    }

    this.markDirty()

    return this
  }

  normalize(nodes, sample) {
    if (typeof nodes === &#039;string&#039;) {
      nodes = cleanSource(parse(nodes).nodes)
    } else if (typeof nodes === &#039;undefined&#039;) {
      nodes = []
    } else if (Array.isArray(nodes)) {
      nodes = nodes.slice(0)
      for (let i of nodes) {
        if (i.parent) i.parent.removeChild(i, &#039;ignore&#039;)
      }
    } else if (nodes.type === &#039;root&#039; &amp;&amp; this.type !== &#039;document&#039;) {
      nodes = nodes.nodes.slice(0)
      for (let i of nodes) {
        if (i.parent) i.parent.removeChild(i, &#039;ignore&#039;)
      }
    } else if (nodes.type) {
      nodes = [nodes]
    } else if (nodes.prop) {
      if (typeof nodes.value === &#039;undefined&#039;) {
        throw new Error(&#039;Value field is missed in node creation&#039;)
      } else if (typeof nodes.value !== &#039;string&#039;) {
        nodes.value = String(nodes.value)
      }
      nodes = [new Declaration(nodes)]
    } else if (nodes.selector || nodes.selectors) {
      nodes = [new Rule(nodes)]
    } else if (nodes.name) {
      nodes = [new AtRule(nodes)]
    } else if (nodes.text) {
      nodes = [new Comment(nodes)]
    } else {
      throw new Error(&#039;Unknown node type in node creation&#039;)
    }

    let processed = nodes.map(i =&gt; {
      /* c8 ignore next */
      if (!i[my]) Container.rebuild(i)
      i = i.proxyOf
      if (i.parent) i.parent.removeChild(i)
      if (i[isClean]) markTreeDirty(i)

      if (!i.raws) i.raws = {}
      if (typeof i.raws.before === &#039;undefined&#039;) {
        if (sample &amp;&amp; typeof sample.raws.before !== &#039;undefined&#039;) {
          i.raws.before = sample.raws.before.replace(/\S/g, &#039;&#039;)
        }
      }
      i.parent = this.proxyOf
      return i
    })

    return processed
  }

  prepend(...children) {
    children = children.reverse()
    for (let child of children) {
      let nodes = this.normalize(child, this.first, &#039;prepend&#039;).reverse()
      for (let node of nodes) this.proxyOf.nodes.unshift(node)
      for (let id in this.indexes) {
        this.indexes[id] = this.indexes[id] + nodes.length
      }
    }

    this.markDirty()

    return this
  }

  push(child) {
    child.parent = this
    this.proxyOf.nodes.push(child)
    return this
  }

  removeAll() {
    for (let node of this.proxyOf.nodes) node.parent = undefined
    this.proxyOf.nodes = []

    this.markDirty()

    return this
  }

  removeChild(child) {
    child = this.index(child)
    this.proxyOf.nodes[child].parent = undefined
    this.proxyOf.nodes.splice(child, 1)

    let index
    for (let id in this.indexes) {
      index = this.indexes[id]
      if (index &gt;= child) {
        this.indexes[id] = index - 1
      }
    }

    this.markDirty()

    return this
  }

  replaceValues(pattern, opts, callback) {
    if (!callback) {
      callback = opts
      opts = {}
    }

    this.walkDecls(decl =&gt; {
      if (opts.props &amp;&amp; !opts.props.includes(decl.prop)) return
      if (opts.fast &amp;&amp; !decl.value.includes(opts.fast)) return

      decl.value = decl.value.replace(pattern, callback)
    })

    this.markDirty()

    return this
  }

  some(condition) {
    return this.nodes.some(condition)
  }

  walk(callback) {
    return this.each((child, i) =&gt; {
      let result
      try {
        result = callback(child, i)
      } catch (e) {
        throw child.addToError(e)
      }
      if (result !== false &amp;&amp; child.walk) {
        result = child.walk(callback)
      }

      return result
    })
  }

  walkAtRules(name, callback) {
    if (!callback) {
      callback = name
      return this.walk((child, i) =&gt; {
        if (child.type === &#039;atrule&#039;) {
          return callback(child, i)
        }
      })
    }
    if (name instanceof RegExp) {
      return this.walk((child, i) =&gt; {
        if (child.type === &#039;atrule&#039; &amp;&amp; name.test(child.name)) {
          return callback(child, i)
        }
      })
    }
    return this.walk((child, i) =&gt; {
      if (child.type === &#039;atrule&#039; &amp;&amp; child.name === name) {
        return callback(child, i)
      }
    })
  }

  walkComments(callback) {
    return this.walk((child, i) =&gt; {
      if (child.type === &#039;comment&#039;) {
        return callback(child, i)
      }
    })
  }

  walkDecls(prop, callback) {
    if (!callback) {
      callback = prop
      return this.walk((child, i) =&gt; {
        if (child.type === &#039;decl&#039;) {
          return callback(child, i)
        }
      })
    }
    if (prop instanceof RegExp) {
      return this.walk((child, i) =&gt; {
        if (child.type === &#039;decl&#039; &amp;&amp; prop.test(child.prop)) {
          return callback(child, i)
        }
      })
    }
    return this.walk((child, i) =&gt; {
      if (child.type === &#039;decl&#039; &amp;&amp; child.prop === prop) {
        return callback(child, i)
      }
    })
  }

  walkRules(selector, callback) {
    if (!callback) {
      callback = selector

      return this.walk((child, i) =&gt; {
        if (child.type === &#039;rule&#039;) {
          return callback(child, i)
        }
      })
    }
    if (selector instanceof RegExp) {
      return this.walk((child, i) =&gt; {
        if (child.type === &#039;rule&#039; &amp;&amp; selector.test(child.selector)) {
          return callback(child, i)
        }
      })
    }
    return this.walk((child, i) =&gt; {
      if (child.type === &#039;rule&#039; &amp;&amp; child.selector === selector) {
        return callback(child, i)
      }
    })
  }
}

Container.registerParse = dependant =&gt; {
  parse = dependant
}

Container.registerRule = dependant =&gt; {
  Rule = dependant
}

Container.registerAtRule = dependant =&gt; {
  AtRule = dependant
}

Container.registerRoot = dependant =&gt; {
  Root = dependant
}

module.exports = Container
Container.default = Container

/* c8 ignore start */
Container.rebuild = node =&gt; {
  if (node.type === &#039;atrule&#039;) {
    Object.setPrototypeOf(node, AtRule.prototype)
  } else if (node.type === &#039;rule&#039;) {
    Object.setPrototypeOf(node, Rule.prototype)
  } else if (node.type === &#039;decl&#039;) {
    Object.setPrototypeOf(node, Declaration.prototype)
  } else if (node.type === &#039;comment&#039;) {
    Object.setPrototypeOf(node, Comment.prototype)
  } else if (node.type === &#039;root&#039;) {
    Object.setPrototypeOf(node, Root.prototype)
  }

  node[my] = true

  if (node.nodes) {
    node.nodes.forEach(child =&gt; {
      Container.rebuild(child)
    })
  }
}
/* c8 ignore stop */


/***/ }),

/***/ 1087:
/***/ ((module, __unused_webpack_exports, __webpack_require__) =&gt; {

&quot;use strict&quot;;
/**
 * Copyright 2013-2015, Facebook, Inc.
 * All rights reserved.
 *
 * This source code is licensed under the BSD-style license found in the
 * LICENSE file in the root directory of this source tree. An additional grant
 * of patent rights can be found in the PATENTS file in the same directory.
 *
 * @providesModule isEventSupported
 */



var ExecutionEnvironment = __webpack_require__(8202);

var useHasFeature;
if (ExecutionEnvironment.canUseDOM) {
  useHasFeature =
    document.implementation &amp;&amp;
    document.implementation.hasFeature &amp;&amp;
    // always returns true in newer browsers as per the standard.
    // @see http://dom.spec.whatwg.org/#dom-domimplementation-hasfeature
    document.implementation.hasFeature(&#039;&#039;, &#039;&#039;) !== true;
}

/**
 * Checks if an event is supported in the current execution environment.
 *
 * NOTE: This will not work correctly for non-generic events such as `change`,
 * `reset`, `load`, `error`, and `select`.
 *
 * Borrows from Modernizr.
 *
 * @param {string} eventNameSuffix Event name, e.g. &quot;click&quot;.
 * @param {?boolean} capture Check if the capture phase is supported.
 * @return {boolean} True if the event is supported.
 * @internal
 * @license Modernizr 3.0.0pre (Custom Build) | MIT
 */
function isEventSupported(eventNameSuffix, capture) {
  if (!ExecutionEnvironment.canUseDOM ||
      capture &amp;&amp; !(&#039;addEventListener&#039; in document)) {
    return false;
  }

  var eventName = &#039;on&#039; + eventNameSuffix;
  var isSupported = eventName in document;

  if (!isSupported) {
    var element = document.createElement(&#039;div&#039;);
    element.setAttribute(eventName, &#039;return;&#039;);
    isSupported = typeof element[eventName] === &#039;function&#039;;
  }

  if (!isSupported &amp;&amp; useHasFeature &amp;&amp; eventNameSuffix === &#039;wheel&#039;) {
    // This is the only way to test support for the `wheel` event in IE9+.
    isSupported = document.implementation.hasFeature(&#039;Events.wheel&#039;, &#039;3.0&#039;);
  }

  return isSupported;
}

module.exports = isEventSupported;


/***/ }),

/***/ 1326:
/***/ ((module, __unused_webpack_exports, __webpack_require__) =&gt; {

&quot;use strict&quot;;


let Container = __webpack_require__(683)

class AtRule extends Container {
  constructor(defaults) {
    super(defaults)
    this.type = &#039;atrule&#039;
  }

  append(...children) {
    if (!this.proxyOf.nodes) this.nodes = []
    return super.append(...children)
  }

  prepend(...children) {
    if (!this.proxyOf.nodes) this.nodes = []
    return super.prepend(...children)
  }
}

module.exports = AtRule
AtRule.default = AtRule

Container.registerAtRule(AtRule)


/***/ }),

/***/ 1381:
/***/ ((module) =&gt; {

&quot;use strict&quot;;


module.exports.isClean = Symbol(&#039;isClean&#039;)

module.exports.my = Symbol(&#039;my&#039;)


/***/ }),

/***/ 1443:
/***/ ((module) =&gt; {

module.exports = function postcssPrefixSelector(options) {
  const prefix = options.prefix;
  const prefixWithSpace = /\s+$/.test(prefix) ? prefix : `${prefix} `;
  const ignoreFiles = options.ignoreFiles ? [].concat(options.ignoreFiles) : [];
  const includeFiles = options.includeFiles
    ? [].concat(options.includeFiles)
    : [];

  return function (root) {
    if (
      ignoreFiles.length &amp;&amp;
      root.source.input.file &amp;&amp;
      isFileInArray(root.source.input.file, ignoreFiles)
    ) {
      return;
    }
    if (
      includeFiles.length &amp;&amp;
      root.source.input.file &amp;&amp;
      !isFileInArray(root.source.input.file, includeFiles)
    ) {
      return;
    }

    root.walkRules((rule) =&gt; {
      const keyframeRules = [
        &#039;keyframes&#039;,
        &#039;-webkit-keyframes&#039;,
        &#039;-moz-keyframes&#039;,
        &#039;-o-keyframes&#039;,
        &#039;-ms-keyframes&#039;,
      ];

      if (rule.parent &amp;&amp; keyframeRules.includes(rule.parent.name)) {
        return;
      }

      rule.selectors = rule.selectors.map((selector) =&gt; {
        if (options.exclude &amp;&amp; excludeSelector(selector, options.exclude)) {
          return selector;
        }

        if (options.transform) {
          return options.transform(
            prefix,
            selector,
            prefixWithSpace + selector,
            root.source.input.file,
            rule
          );
        }

        return prefixWithSpace + selector;
      });
    });
  };
};

function isFileInArray(file, arr) {
  return arr.some((ruleOrString) =&gt; {
    if (ruleOrString instanceof RegExp) {
      return ruleOrString.test(file);
    }

    return file.includes(ruleOrString);
  });
}

function excludeSelector(selector, excludeArr) {
  return excludeArr.some((excludeRule) =&gt; {
    if (excludeRule instanceof RegExp) {
      return excludeRule.test(selector);
    }

    return selector === excludeRule;
  });
}


/***/ }),

/***/ 1516:
/***/ ((module, __unused_webpack_exports, __webpack_require__) =&gt; {

&quot;use strict&quot;;


let Node = __webpack_require__(7490)

class Declaration extends Node {
  get variable() {
    return this.prop.startsWith(&#039;--&#039;) || this.prop[0] === &#039;$&#039;
  }

  constructor(defaults) {
    if (
      defaults &amp;&amp;
      typeof defaults.value !== &#039;undefined&#039; &amp;&amp;
      typeof defaults.value !== &#039;string&#039;
    ) {
      defaults = { ...defaults, value: String(defaults.value) }
    }
    super(defaults)
    this.type = &#039;decl&#039;
  }
}

module.exports = Declaration
Declaration.default = Declaration


/***/ }),

/***/ 1524:
/***/ ((module) =&gt; {

var minus = &quot;-&quot;.charCodeAt(0);
var plus = &quot;+&quot;.charCodeAt(0);
var dot = &quot;.&quot;.charCodeAt(0);
var exp = &quot;e&quot;.charCodeAt(0);
var EXP = &quot;E&quot;.charCodeAt(0);

// Check if three code points would start a number
// https://www.w3.org/TR/css-syntax-3/#starts-with-a-number
function likeNumber(value) {
  var code = value.charCodeAt(0);
  var nextCode;

  if (code === plus || code === minus) {
    nextCode = value.charCodeAt(1);

    if (nextCode &gt;= 48 &amp;&amp; nextCode &lt;= 57) {
      return true;
    }

    var nextNextCode = value.charCodeAt(2);

    if (nextCode === dot &amp;&amp; nextNextCode &gt;= 48 &amp;&amp; nextNextCode &lt;= 57) {
      return true;
    }

    return false;
  }

  if (code === dot) {
    nextCode = value.charCodeAt(1);

    if (nextCode &gt;= 48 &amp;&amp; nextCode &lt;= 57) {
      return true;
    }

    return false;
  }

  if (code &gt;= 48 &amp;&amp; code &lt;= 57) {
    return true;
  }

  return false;
}

// Consume a number
// https://www.w3.org/TR/css-syntax-3/#consume-number
module.exports = function(value) {
  var pos = 0;
  var length = value.length;
  var code;
  var nextCode;
  var nextNextCode;

  if (length === 0 || !likeNumber(value)) {
    return false;
  }

  code = value.charCodeAt(pos);

  if (code === plus || code === minus) {
    pos++;
  }

  while (pos &lt; length) {
    code = value.charCodeAt(pos);

    if (code &lt; 48 || code &gt; 57) {
      break;
    }

    pos += 1;
  }

  code = value.charCodeAt(pos);
  nextCode = value.charCodeAt(pos + 1);

  if (code === dot &amp;&amp; nextCode &gt;= 48 &amp;&amp; nextCode &lt;= 57) {
    pos += 2;

    while (pos &lt; length) {
      code = value.charCodeAt(pos);

      if (code &lt; 48 || code &gt; 57) {
        break;
      }

      pos += 1;
    }
  }

  code = value.charCodeAt(pos);
  nextCode = value.charCodeAt(pos + 1);
  nextNextCode = value.charCodeAt(pos + 2);

  if (
    (code === exp || code === EXP) &amp;&amp;
    ((nextCode &gt;= 48 &amp;&amp; nextCode &lt;= 57) ||
      ((nextCode === plus || nextCode === minus) &amp;&amp;
        nextNextCode &gt;= 48 &amp;&amp;
        nextNextCode &lt;= 57))
  ) {
    pos += nextCode === plus || nextCode === minus ? 3 : 2;

    while (pos &lt; length) {
      code = value.charCodeAt(pos);

      if (code &lt; 48 || code &gt; 57) {
        break;
      }

      pos += 1;
    }
  }

  return {
    number: value.slice(0, pos),
    unit: value.slice(pos)
  };
};


/***/ }),

/***/ 1544:
/***/ ((module, __unused_webpack_exports, __webpack_require__) =&gt; {

var parse = __webpack_require__(8491);
var walk = __webpack_require__(3815);
var stringify = __webpack_require__(4725);

function ValueParser(value) {
  if (this instanceof ValueParser) {
    this.nodes = parse(value);
    return this;
  }
  return new ValueParser(value);
}

ValueParser.prototype.toString = function() {
  return Array.isArray(this.nodes) ? stringify(this.nodes) : &quot;&quot;;
};

ValueParser.prototype.walk = function(cb, bubble) {
  walk(this.nodes, cb, bubble);
  return this;
};

ValueParser.unit = __webpack_require__(1524);

ValueParser.walk = walk;

ValueParser.stringify = stringify;

module.exports = ValueParser;


/***/ }),

/***/ 1609:
/***/ ((module) =&gt; {

&quot;use strict&quot;;
module.exports = window[&quot;React&quot;];

/***/ }),

/***/ 1670:
/***/ ((module, __unused_webpack_exports, __webpack_require__) =&gt; {

&quot;use strict&quot;;


let { dirname, relative, resolve, sep } = __webpack_require__(197)
let { SourceMapConsumer, SourceMapGenerator } = __webpack_require__(1866)
let { pathToFileURL } = __webpack_require__(2739)

let Input = __webpack_require__(5380)

let sourceMapAvailable = Boolean(SourceMapConsumer &amp;&amp; SourceMapGenerator)
let pathAvailable = Boolean(dirname &amp;&amp; resolve &amp;&amp; relative &amp;&amp; sep)

class MapGenerator {
  constructor(stringify, root, opts, cssString) {
    this.stringify = stringify
    this.mapOpts = opts.map || {}
    this.root = root
    this.opts = opts
    this.css = cssString
    this.originalCSS = cssString
    this.usesFileUrls = !this.mapOpts.from &amp;&amp; this.mapOpts.absolute

    this.memoizedFileURLs = new Map()
    this.memoizedPaths = new Map()
    this.memoizedURLs = new Map()
  }

  addAnnotation() {
    let content

    if (this.isInline()) {
      content =
        &#039;data:application/json;base64,&#039; + this.toBase64(this.map.toString())
    } else if (typeof this.mapOpts.annotation === &#039;string&#039;) {
      content = this.mapOpts.annotation
    } else if (typeof this.mapOpts.annotation === &#039;function&#039;) {
      content = this.mapOpts.annotation(this.opts.to, this.root)
    } else {
      content = this.outputFile() + &#039;.map&#039;
    }
    let eol = &#039;\n&#039;
    if (this.css.includes(&#039;\r\n&#039;)) eol = &#039;\r\n&#039;

    this.css += eol + &#039;/*# sourceMappingURL=&#039; + content + &#039; */&#039;
  }

  applyPrevMaps() {
    for (let prev of this.previous()) {
      let from = this.toUrl(this.path(prev.file))
      let root = prev.root || dirname(prev.file)
      let map

      if (this.mapOpts.sourcesContent === false) {
        map = new SourceMapConsumer(prev.text)
        if (map.sourcesContent) {
          map.sourcesContent = null
        }
      } else {
        map = prev.consumer()
      }

      this.map.applySourceMap(map, from, this.toUrl(this.path(root)))
    }
  }

  clearAnnotation() {
    if (this.mapOpts.annotation === false) return

    if (this.root) {
      let node
      for (let i = this.root.nodes.length - 1; i &gt;= 0; i--) {
        node = this.root.nodes[i]
        if (node.type !== &#039;comment&#039;) continue
        if (node.text.startsWith(&#039;# sourceMappingURL=&#039;)) {
          this.root.removeChild(i)
        }
      }
    } else if (this.css) {
      this.css = this.css.replace(/\n*\/\*#[\S\s]*?\*\/$/gm, &#039;&#039;)
    }
  }

  generate() {
    this.clearAnnotation()
    if (pathAvailable &amp;&amp; sourceMapAvailable &amp;&amp; this.isMap()) {
      return this.generateMap()
    } else {
      let result = &#039;&#039;
      this.stringify(this.root, i =&gt; {
        result += i
      })
      return [result]
    }
  }

  generateMap() {
    if (this.root) {
      this.generateString()
    } else if (this.previous().length === 1) {
      let prev = this.previous()[0].consumer()
      prev.file = this.outputFile()
      this.map = SourceMapGenerator.fromSourceMap(prev, {
        ignoreInvalidMapping: true
      })
    } else {
      this.map = new SourceMapGenerator({
        file: this.outputFile(),
        ignoreInvalidMapping: true
      })
      this.map.addMapping({
        generated: { column: 0, line: 1 },
        original: { column: 0, line: 1 },
        source: this.opts.from
          ? this.toUrl(this.path(this.opts.from))
          : &#039;&lt;no source&gt;&#039;
      })
    }

    if (this.isSourcesContent()) this.setSourcesContent()
    if (this.root &amp;&amp; this.previous().length &gt; 0) this.applyPrevMaps()
    if (this.isAnnotation()) this.addAnnotation()

    if (this.isInline()) {
      return [this.css]
    } else {
      return [this.css, this.map]
    }
  }

  generateString() {
    this.css = &#039;&#039;
    this.map = new SourceMapGenerator({
      file: this.outputFile(),
      ignoreInvalidMapping: true
    })

    let line = 1
    let column = 1

    let noSource = &#039;&lt;no source&gt;&#039;
    let mapping = {
      generated: { column: 0, line: 0 },
      original: { column: 0, line: 0 },
      source: &#039;&#039;
    }

    let last, lines
    this.stringify(this.root, (str, node, type) =&gt; {
      this.css += str

      if (node &amp;&amp; type !== &#039;end&#039;) {
        mapping.generated.line = line
        mapping.generated.column = column - 1
        if (node.source &amp;&amp; node.source.start) {
          mapping.source = this.sourcePath(node)
          mapping.original.line = node.source.start.line
          mapping.original.column = node.source.start.column - 1
          this.map.addMapping(mapping)
        } else {
          mapping.source = noSource
          mapping.original.line = 1
          mapping.original.column = 0
          this.map.addMapping(mapping)
        }
      }

      lines = str.match(/\n/g)
      if (lines) {
        line += lines.length
        last = str.lastIndexOf(&#039;\n&#039;)
        column = str.length - last
      } else {
        column += str.length
      }

      if (node &amp;&amp; type !== &#039;start&#039;) {
        let p = node.parent || { raws: {} }
        let childless =
          node.type === &#039;decl&#039; || (node.type === &#039;atrule&#039; &amp;&amp; !node.nodes)
        if (!childless || node !== p.last || p.raws.semicolon) {
          if (node.source &amp;&amp; node.source.end) {
            mapping.source = this.sourcePath(node)
            mapping.original.line = node.source.end.line
            mapping.original.column = node.source.end.column - 1
            mapping.generated.line = line
            mapping.generated.column = column - 2
            this.map.addMapping(mapping)
          } else {
            mapping.source = noSource
            mapping.original.line = 1
            mapping.original.column = 0
            mapping.generated.line = line
            mapping.generated.column = column - 1
            this.map.addMapping(mapping)
          }
        }
      }
    })
  }

  isAnnotation() {
    if (this.isInline()) {
      return true
    }
    if (typeof this.mapOpts.annotation !== &#039;undefined&#039;) {
      return this.mapOpts.annotation
    }
    if (this.previous().length) {
      return this.previous().some(i =&gt; i.annotation)
    }
    return true
  }

  isInline() {
    if (typeof this.mapOpts.inline !== &#039;undefined&#039;) {
      return this.mapOpts.inline
    }

    let annotation = this.mapOpts.annotation
    if (typeof annotation !== &#039;undefined&#039; &amp;&amp; annotation !== true) {
      return false
    }

    if (this.previous().length) {
      return this.previous().some(i =&gt; i.inline)
    }
    return true
  }

  isMap() {
    if (typeof this.opts.map !== &#039;undefined&#039;) {
      return !!this.opts.map
    }
    return this.previous().length &gt; 0
  }

  isSourcesContent() {
    if (typeof this.mapOpts.sourcesContent !== &#039;undefined&#039;) {
      return this.mapOpts.sourcesContent
    }
    if (this.previous().length) {
      return this.previous().some(i =&gt; i.withContent())
    }
    return true
  }

  outputFile() {
    if (this.opts.to) {
      return this.path(this.opts.to)
    } else if (this.opts.from) {
      return this.path(this.opts.from)
    } else {
      return &#039;to.css&#039;
    }
  }

  path(file) {
    if (this.mapOpts.absolute) return file
    if (file.charCodeAt(0) === 60 /* `&lt;` */) return file
    if (/^\w+:\/\//.test(file)) return file
    let cached = this.memoizedPaths.get(file)
    if (cached) return cached

    let from = this.opts.to ? dirname(this.opts.to) : &#039;.&#039;

    if (typeof this.mapOpts.annotation === &#039;string&#039;) {
      from = dirname(resolve(from, this.mapOpts.annotation))
    }

    let path = relative(from, file)
    this.memoizedPaths.set(file, path)

    return path
  }

  previous() {
    if (!this.previousMaps) {
      this.previousMaps = []
      if (this.root) {
        this.root.walk(node =&gt; {
          if (node.source &amp;&amp; node.source.input.map) {
            let map = node.source.input.map
            if (!this.previousMaps.includes(map)) {
              this.previousMaps.push(map)
            }
          }
        })
      } else {
        let input = new Input(this.originalCSS, this.opts)
        if (input.map) this.previousMaps.push(input.map)
      }
    }

    return this.previousMaps
  }

  setSourcesContent() {
    let already = {}
    if (this.root) {
      this.root.walk(node =&gt; {
        if (node.source) {
          let from = node.source.input.from
          if (from &amp;&amp; !already[from]) {
            already[from] = true
            let fromUrl = this.usesFileUrls
              ? this.toFileUrl(from)
              : this.toUrl(this.path(from))
            this.map.setSourceContent(fromUrl, node.source.input.css)
          }
        }
      })
    } else if (this.css) {
      let from = this.opts.from
        ? this.toUrl(this.path(this.opts.from))
        : &#039;&lt;no source&gt;&#039;
      this.map.setSourceContent(from, this.css)
    }
  }

  sourcePath(node) {
    if (this.mapOpts.from) {
      return this.toUrl(this.mapOpts.from)
    } else if (this.usesFileUrls) {
      return this.toFileUrl(node.source.input.from)
    } else {
      return this.toUrl(this.path(node.source.input.from))
    }
  }

  toBase64(str) {
    if (Buffer) {
      return Buffer.from(str).toString(&#039;base64&#039;)
    } else {
      return window.btoa(unescape(encodeURIComponent(str)))
    }
  }

  toFileUrl(path) {
    let cached = this.memoizedFileURLs.get(path)
    if (cached) return cached

    if (pathToFileURL) {
      let fileURL = pathToFileURL(path).toString()
      this.memoizedFileURLs.set(path, fileURL)

      return fileURL
    } else {
      throw new Error(
        &#039;`map.absolute` option is not available in this PostCSS build&#039;
      )
    }
  }

  toUrl(path) {
    let cached = this.memoizedURLs.get(path)
    if (cached) return cached

    if (sep === &#039;\\&#039;) {
      path = path.replace(/\\/g, &#039;/&#039;)
    }

    let url = encodeURI(path).replace(/[#?]/g, encodeURIComponent)
    this.memoizedURLs.set(path, url)

    return url
  }
}

module.exports = MapGenerator


/***/ }),

/***/ 1866:
/***/ (() =&gt; {

/* (ignored) */

/***/ }),

/***/ 2213:
/***/ ((module) =&gt; {

/**
 * Copyright 2004-present Facebook. All Rights Reserved.
 *
 * @providesModule UserAgent_DEPRECATED
 */

/**
 *  Provides entirely client-side User Agent and OS detection. You should prefer
 *  the non-deprecated UserAgent module when possible, which exposes our
 *  authoritative server-side PHP-based detection to the client.
 *
 *  Usage is straightforward:
 *
 *    if (UserAgent_DEPRECATED.ie()) {
 *      //  IE
 *    }
 *
 *  You can also do version checks:
 *
 *    if (UserAgent_DEPRECATED.ie() &gt;= 7) {
 *      //  IE7 or better
 *    }
 *
 *  The browser functions will return NaN if the browser does not match, so
 *  you can also do version compares the other way:
 *
 *    if (UserAgent_DEPRECATED.ie() &lt; 7) {
 *      //  IE6 or worse
 *    }
 *
 *  Note that the version is a float and may include a minor version number,
 *  so you should always use range operators to perform comparisons, not
 *  strict equality.
 *
 *  **Note:** You should **strongly** prefer capability detection to browser
 *  version detection where it&#039;s reasonable:
 *
 *    http://www.quirksmode.org/js/support.html
 *
 *  Further, we have a large number of mature wrapper functions and classes
 *  which abstract away many browser irregularities. Check the documentation,
 *  grep for things, or ask on javascript@lists.facebook.com before writing yet
 *  another copy of &quot;event || window.event&quot;.
 *
 */

var _populated = false;

// Browsers
var _ie, _firefox, _opera, _webkit, _chrome;

// Actual IE browser for compatibility mode
var _ie_real_version;

// Platforms
var _osx, _windows, _linux, _android;

// Architectures
var _win64;

// Devices
var _iphone, _ipad, _native;

var _mobile;

function _populate() {
  if (_populated) {
    return;
  }

  _populated = true;

  // To work around buggy JS libraries that can&#039;t handle multi-digit
  // version numbers, Opera 10&#039;s user agent string claims it&#039;s Opera
  // 9, then later includes a Version/X.Y field:
  //
  // Opera/9.80 (foo) Presto/2.2.15 Version/10.10
  var uas = navigator.userAgent;
  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);
  var os    = /(Mac OS X)|(Windows)|(Linux)/.exec(uas);

  _iphone = /\b(iPhone|iP[ao]d)/.exec(uas);
  _ipad = /\b(iP[ao]d)/.exec(uas);
  _android = /Android/i.exec(uas);
  _native = /FBAN\/\w+;/i.exec(uas);
  _mobile = /Mobile/i.exec(uas);

  // Note that the IE team blog would have you believe you should be checking
  // for &#039;Win64; x64&#039;.  But MSDN then reveals that you can actually be coming
  // from either x64 or ia64;  so ultimately, you should just check for Win64
  // as in indicator of whether you&#039;re in 64-bit IE.  32-bit IE on 64-bit
  // Windows will send &#039;WOW64&#039; instead.
  _win64 = !!(/Win64/.exec(uas));

  if (agent) {
    _ie = agent[1] ? parseFloat(agent[1]) : (
          agent[5] ? parseFloat(agent[5]) : NaN);
    // IE compatibility mode
    if (_ie &amp;&amp; document &amp;&amp; document.documentMode) {
      _ie = document.documentMode;
    }
    // grab the &quot;true&quot; ie version from the trident token if available
    var trident = /(?:Trident\/(\d+.\d+))/.exec(uas);
    _ie_real_version = trident ? parseFloat(trident[1]) + 4 : _ie;

    _firefox = agent[2] ? parseFloat(agent[2]) : NaN;
    _opera   = agent[3] ? parseFloat(agent[3]) : NaN;
    _webkit  = agent[4] ? parseFloat(agent[4]) : NaN;
    if (_webkit) {
      // We do not add the regexp to the above test, because it will always
      // match &#039;safari&#039; only since &#039;AppleWebKit&#039; appears before &#039;Chrome&#039; in
      // the userAgent string.
      agent = /(?:Chrome\/(\d+\.\d+))/.exec(uas);
      _chrome = agent &amp;&amp; agent[1] ? parseFloat(agent[1]) : NaN;
    } else {
      _chrome = NaN;
    }
  } else {
    _ie = _firefox = _opera = _chrome = _webkit = NaN;
  }

  if (os) {
    if (os[1]) {
      // Detect OS X version.  If no version number matches, set _osx to true.
      // Version examples:  10, 10_6_1, 10.7
      // Parses version number as a float, taking only first two sets of
      // digits.  If only one set of digits is found, returns just the major
      // version number.
      var ver = /(?:Mac OS X (\d+(?:[._]\d+)?))/.exec(uas);

      _osx = ver ? parseFloat(ver[1].replace(&#039;_&#039;, &#039;.&#039;)) : true;
    } else {
      _osx = false;
    }
    _windows = !!os[2];
    _linux   = !!os[3];
  } else {
    _osx = _windows = _linux = false;
  }
}

var UserAgent_DEPRECATED = {

  /**
   *  Check if the UA is Internet Explorer.
   *
   *
   *  @return float|NaN Version number (if match) or NaN.
   */
  ie: function() {
    return _populate() || _ie;
  },

  /**
   * Check if we&#039;re in Internet Explorer compatibility mode.
   *
   * @return bool true if in compatibility mode, false if
   * not compatibility mode or not ie
   */
  ieCompatibilityMode: function() {
    return _populate() || (_ie_real_version &gt; _ie);
  },


  /**
   * Whether the browser is 64-bit IE.  Really, this is kind of weak sauce;  we
   * only need this because Skype can&#039;t handle 64-bit IE yet.  We need to remove
   * this when we don&#039;t need it -- tracked by #601957.
   */
  ie64: function() {
    return UserAgent_DEPRECATED.ie() &amp;&amp; _win64;
  },

  /**
   *  Check if the UA is Firefox.
   *
   *
   *  @return float|NaN Version number (if match) or NaN.
   */
  firefox: function() {
    return _populate() || _firefox;
  },


  /**
   *  Check if the UA is Opera.
   *
   *
   *  @return float|NaN Version number (if match) or NaN.
   */
  opera: function() {
    return _populate() || _opera;
  },


  /**
   *  Check if the UA is WebKit.
   *
   *
   *  @return float|NaN Version number (if match) or NaN.
   */
  webkit: function() {
    return _populate() || _webkit;
  },

  /**
   *  For Push
   *  WILL BE REMOVED VERY SOON. Use UserAgent_DEPRECATED.webkit
   */
  safari: function() {
    return UserAgent_DEPRECATED.webkit();
  },

  /**
   *  Check if the UA is a Chrome browser.
   *
   *
   *  @return float|NaN Version number (if match) or NaN.
   */
  chrome : function() {
    return _populate() || _chrome;
  },


  /**
   *  Check if the user is running Windows.
   *
   *  @return bool `true&#039; if the user&#039;s OS is Windows.
   */
  windows: function() {
    return _populate() || _windows;
  },


  /**
   *  Check if the user is running Mac OS X.
   *
   *  @return float|bool   Returns a float if a version number is detected,
   *                       otherwise true/false.
   */
  osx: function() {
    return _populate() || _osx;
  },

  /**
   * Check if the user is running Linux.
   *
   * @return bool `true&#039; if the user&#039;s OS is some flavor of Linux.
   */
  linux: function() {
    return _populate() || _linux;
  },

  /**
   * Check if the user is running on an iPhone or iPod platform.
   *
   * @return bool `true&#039; if the user is running some flavor of the
   *    iPhone OS.
   */
  iphone: function() {
    return _populate() || _iphone;
  },

  mobile: function() {
    return _populate() || (_iphone || _ipad || _android || _mobile);
  },

  nativeApp: function() {
    // webviews inside of the native apps
    return _populate() || _native;
  },

  android: function() {
    return _populate() || _android;
  },

  ipad: function() {
    return _populate() || _ipad;
  }
};

module.exports = UserAgent_DEPRECATED;


/***/ }),

/***/ 2327:
/***/ ((module) =&gt; {

&quot;use strict&quot;;


const SINGLE_QUOTE = &quot;&#039;&quot;.charCodeAt(0)
const DOUBLE_QUOTE = &#039;&quot;&#039;.charCodeAt(0)
const BACKSLASH = &#039;\\&#039;.charCodeAt(0)
const SLASH = &#039;/&#039;.charCodeAt(0)
const NEWLINE = &#039;\n&#039;.charCodeAt(0)
const SPACE = &#039; &#039;.charCodeAt(0)
const FEED = &#039;\f&#039;.charCodeAt(0)
const TAB = &#039;\t&#039;.charCodeAt(0)
const CR = &#039;\r&#039;.charCodeAt(0)
const OPEN_SQUARE = &#039;[&#039;.charCodeAt(0)
const CLOSE_SQUARE = &#039;]&#039;.charCodeAt(0)
const OPEN_PARENTHESES = &#039;(&#039;.charCodeAt(0)
const CLOSE_PARENTHESES = &#039;)&#039;.charCodeAt(0)
const OPEN_CURLY = &#039;{&#039;.charCodeAt(0)
const CLOSE_CURLY = &#039;}&#039;.charCodeAt(0)
const SEMICOLON = &#039;;&#039;.charCodeAt(0)
const ASTERISK = &#039;*&#039;.charCodeAt(0)
const COLON = &#039;:&#039;.charCodeAt(0)
const AT = &#039;@&#039;.charCodeAt(0)

const RE_AT_END = /[\t\n\f\r &quot;#&#039;()/;[\\\]{}]/g
const RE_WORD_END = /[\t\n\f\r !&quot;#&#039;():;@[\\\]{}]|\/(?=\*)/g
const RE_BAD_BRACKET = /.[\r\n&quot;&#039;(/\\]/
const RE_HEX_ESCAPE = /[\da-f]/i

module.exports = function tokenizer(input, options = {}) {
  let css = input.css.valueOf()
  let ignore = options.ignoreErrors

  let code, content, escape, next, quote
  let currentToken, escaped, escapePos, n, prev

  let length = css.length
  let pos = 0
  let buffer = []
  let returned = []

  function position() {
    return pos
  }

  function unclosed(what) {
    throw input.error(&#039;Unclosed &#039; + what, pos)
  }

  function endOfFile() {
    return returned.length === 0 &amp;&amp; pos &gt;= length
  }

  function nextToken(opts) {
    if (returned.length) return returned.pop()
    if (pos &gt;= length) return

    let ignoreUnclosed = opts ? opts.ignoreUnclosed : false

    code = css.charCodeAt(pos)

    switch (code) {
      case NEWLINE:
      case SPACE:
      case TAB:
      case CR:
      case FEED: {
        next = pos
        do {
          next += 1
          code = css.charCodeAt(next)
        } while (
          code === SPACE ||
          code === NEWLINE ||
          code === TAB ||
          code === CR ||
          code === FEED
        )

        currentToken = [&#039;space&#039;, css.slice(pos, next)]
        pos = next - 1
        break
      }

      case OPEN_SQUARE:
      case CLOSE_SQUARE:
      case OPEN_CURLY:
      case CLOSE_CURLY:
      case COLON:
      case SEMICOLON:
      case CLOSE_PARENTHESES: {
        let controlChar = String.fromCharCode(code)
        currentToken = [controlChar, controlChar, pos]
        break
      }

      case OPEN_PARENTHESES: {
        prev = buffer.length ? buffer.pop()[1] : &#039;&#039;
        n = css.charCodeAt(pos + 1)
        if (
          prev === &#039;url&#039; &amp;&amp;
          n !== SINGLE_QUOTE &amp;&amp;
          n !== DOUBLE_QUOTE &amp;&amp;
          n !== SPACE &amp;&amp;
          n !== NEWLINE &amp;&amp;
          n !== TAB &amp;&amp;
          n !== FEED &amp;&amp;
          n !== CR
        ) {
          next = pos
          do {
            escaped = false
            next = css.indexOf(&#039;)&#039;, next + 1)
            if (next === -1) {
              if (ignore || ignoreUnclosed) {
                next = pos
                break
              } else {
                unclosed(&#039;bracket&#039;)
              }
            }
            escapePos = next
            while (css.charCodeAt(escapePos - 1) === BACKSLASH) {
              escapePos -= 1
              escaped = !escaped
            }
          } while (escaped)

          currentToken = [&#039;brackets&#039;, css.slice(pos, next + 1), pos, next]

          pos = next
        } else {
          next = css.indexOf(&#039;)&#039;, pos + 1)
          content = css.slice(pos, next + 1)

          if (next === -1 || RE_BAD_BRACKET.test(content)) {
            currentToken = [&#039;(&#039;, &#039;(&#039;, pos]
          } else {
            currentToken = [&#039;brackets&#039;, content, pos, next]
            pos = next
          }
        }

        break
      }

      case SINGLE_QUOTE:
      case DOUBLE_QUOTE: {
        quote = code === SINGLE_QUOTE ? &quot;&#039;&quot; : &#039;&quot;&#039;
        next = pos
        do {
          escaped = false
          next = css.indexOf(quote, next + 1)
          if (next === -1) {
            if (ignore || ignoreUnclosed) {
              next = pos + 1
              break
            } else {
              unclosed(&#039;string&#039;)
            }
          }
          escapePos = next
          while (css.charCodeAt(escapePos - 1) === BACKSLASH) {
            escapePos -= 1
            escaped = !escaped
          }
        } while (escaped)

        currentToken = [&#039;string&#039;, css.slice(pos, next + 1), pos, next]
        pos = next
        break
      }

      case AT: {
        RE_AT_END.lastIndex = pos + 1
        RE_AT_END.test(css)
        if (RE_AT_END.lastIndex === 0) {
          next = css.length - 1
        } else {
          next = RE_AT_END.lastIndex - 2
        }

        currentToken = [&#039;at-word&#039;, css.slice(pos, next + 1), pos, next]

        pos = next
        break
      }

      case BACKSLASH: {
        next = pos
        escape = true
        while (css.charCodeAt(next + 1) === BACKSLASH) {
          next += 1
          escape = !escape
        }
        code = css.charCodeAt(next + 1)
        if (
          escape &amp;&amp;
          code !== SLASH &amp;&amp;
          code !== SPACE &amp;&amp;
          code !== NEWLINE &amp;&amp;
          code !== TAB &amp;&amp;
          code !== CR &amp;&amp;
          code !== FEED
        ) {
          next += 1
          if (RE_HEX_ESCAPE.test(css.charAt(next))) {
            while (RE_HEX_ESCAPE.test(css.charAt(next + 1))) {
              next += 1
            }
            if (css.charCodeAt(next + 1) === SPACE) {
              next += 1
            }
          }
        }

        currentToken = [&#039;word&#039;, css.slice(pos, next + 1), pos, next]

        pos = next
        break
      }

      default: {
        if (code === SLASH &amp;&amp; css.charCodeAt(pos + 1) === ASTERISK) {
          next = css.indexOf(&#039;*/&#039;, pos + 2) + 1
          if (next === 0) {
            if (ignore || ignoreUnclosed) {
              next = css.length
            } else {
              unclosed(&#039;comment&#039;)
            }
          }

          currentToken = [&#039;comment&#039;, css.slice(pos, next + 1), pos, next]
          pos = next
        } else {
          RE_WORD_END.lastIndex = pos + 1
          RE_WORD_END.test(css)
          if (RE_WORD_END.lastIndex === 0) {
            next = css.length - 1
          } else {
            next = RE_WORD_END.lastIndex - 2
          }

          currentToken = [&#039;word&#039;, css.slice(pos, next + 1), pos, next]
          buffer.push(currentToken)
          pos = next
        }

        break
      }
    }

    pos++
    return currentToken
  }

  function back(token) {
    returned.push(token)
  }

  return {
    back,
    endOfFile,
    nextToken,
    position
  }
}


/***/ }),

/***/ 2739:
/***/ (() =&gt; {

/* (ignored) */

/***/ }),

/***/ 2775:
/***/ ((module) =&gt; {

var x=String;
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}};
module.exports=create();
module.exports.createColors = create;


/***/ }),

/***/ 3122:
/***/ ((module) =&gt; {

&quot;use strict&quot;;
/* eslint-disable no-console */


let printed = {}

module.exports = function warnOnce(message) {
  if (printed[message]) return
  printed[message] = true

  if (typeof console !== &#039;undefined&#039; &amp;&amp; console.warn) {
    console.warn(message)
  }
}


/***/ }),

/***/ 3815:
/***/ ((module) =&gt; {

module.exports = function walk(nodes, cb, bubble) {
  var i, max, node, result;

  for (i = 0, max = nodes.length; i &lt; max; i += 1) {
    node = nodes[i];
    if (!bubble) {
      result = cb(node, i, nodes);
    }

    if (
      result !== false &amp;&amp;
      node.type === &quot;function&quot; &amp;&amp;
      Array.isArray(node.nodes)
    ) {
      walk(node.nodes, cb, bubble);
    }

    if (bubble) {
      cb(node, i, nodes);
    }
  }
};


/***/ }),

/***/ 3937:
/***/ ((module, __unused_webpack_exports, __webpack_require__) =&gt; {

&quot;use strict&quot;;


let AtRule = __webpack_require__(1326)
let Comment = __webpack_require__(6589)
let Declaration = __webpack_require__(1516)
let Root = __webpack_require__(9434)
let Rule = __webpack_require__(4092)
let tokenizer = __webpack_require__(2327)

const SAFE_COMMENT_NEIGHBOR = {
  empty: true,
  space: true
}

function findLastWithPosition(tokens) {
  for (let i = tokens.length - 1; i &gt;= 0; i--) {
    let token = tokens[i]
    let pos = token[3] || token[2]
    if (pos) return pos
  }
}

class Parser {
  constructor(input) {
    this.input = input

    this.root = new Root()
    this.current = this.root
    this.spaces = &#039;&#039;
    this.semicolon = false

    this.createTokenizer()
    this.root.source = { input, start: { column: 1, line: 1, offset: 0 } }
  }

  atrule(token) {
    let node = new AtRule()
    node.name = token[1].slice(1)
    if (node.name === &#039;&#039;) {
      this.unnamedAtrule(node, token)
    }
    this.init(node, token[2])

    let type
    let prev
    let shift
    let last = false
    let open = false
    let params = []
    let brackets = []

    while (!this.tokenizer.endOfFile()) {
      token = this.tokenizer.nextToken()
      type = token[0]

      if (type === &#039;(&#039; || type === &#039;[&#039;) {
        brackets.push(type === &#039;(&#039; ? &#039;)&#039; : &#039;]&#039;)
      } else if (type === &#039;{&#039; &amp;&amp; brackets.length &gt; 0) {
        brackets.push(&#039;}&#039;)
      } else if (type === brackets[brackets.length - 1]) {
        brackets.pop()
      }

      if (brackets.length === 0) {
        if (type === &#039;;&#039;) {
          node.source.end = this.getPosition(token[2])
          node.source.end.offset++
          this.semicolon = true
          break
        } else if (type === &#039;{&#039;) {
          open = true
          break
        } else if (type === &#039;}&#039;) {
          if (params.length &gt; 0) {
            shift = params.length - 1
            prev = params[shift]
            while (prev &amp;&amp; prev[0] === &#039;space&#039;) {
              prev = params[--shift]
            }
            if (prev) {
              node.source.end = this.getPosition(prev[3] || prev[2])
              node.source.end.offset++
            }
          }
          this.end(token)
          break
        } else {
          params.push(token)
        }
      } else {
        params.push(token)
      }

      if (this.tokenizer.endOfFile()) {
        last = true
        break
      }
    }

    node.raws.between = this.spacesAndCommentsFromEnd(params)
    if (params.length) {
      node.raws.afterName = this.spacesAndCommentsFromStart(params)
      this.raw(node, &#039;params&#039;, params)
      if (last) {
        token = params[params.length - 1]
        node.source.end = this.getPosition(token[3] || token[2])
        node.source.end.offset++
        this.spaces = node.raws.between
        node.raws.between = &#039;&#039;
      }
    } else {
      node.raws.afterName = &#039;&#039;
      node.params = &#039;&#039;
    }

    if (open) {
      node.nodes = []
      this.current = node
    }
  }

  checkMissedSemicolon(tokens) {
    let colon = this.colon(tokens)
    if (colon === false) return

    let founded = 0
    let token
    for (let j = colon - 1; j &gt;= 0; j--) {
      token = tokens[j]
      if (token[0] !== &#039;space&#039;) {
        founded += 1
        if (founded === 2) break
      }
    }
    // If the token is a word, e.g. `!important`, `red` or any other valid property&#039;s value.
    // Then we need to return the colon after that word token. [3] is the &quot;end&quot; colon of that word.
    // And because we need it after that one we do +1 to get the next one.
    throw this.input.error(
      &#039;Missed semicolon&#039;,
      token[0] === &#039;word&#039; ? token[3] + 1 : token[2]
    )
  }

  colon(tokens) {
    let brackets = 0
    let prev, token, type
    for (let [i, element] of tokens.entries()) {
      token = element
      type = token[0]

      if (type === &#039;(&#039;) {
        brackets += 1
      }
      if (type === &#039;)&#039;) {
        brackets -= 1
      }
      if (brackets === 0 &amp;&amp; type === &#039;:&#039;) {
        if (!prev) {
          this.doubleColon(token)
        } else if (prev[0] === &#039;word&#039; &amp;&amp; prev[1] === &#039;progid&#039;) {
          continue
        } else {
          return i
        }
      }

      prev = token
    }
    return false
  }

  comment(token) {
    let node = new Comment()
    this.init(node, token[2])
    node.source.end = this.getPosition(token[3] || token[2])
    node.source.end.offset++

    let text = token[1].slice(2, -2)
    if (/^\s*$/.test(text)) {
      node.text = &#039;&#039;
      node.raws.left = text
      node.raws.right = &#039;&#039;
    } else {
      let match = text.match(/^(\s*)([^]*\S)(\s*)$/)
      node.text = match[2]
      node.raws.left = match[1]
      node.raws.right = match[3]
    }
  }

  createTokenizer() {
    this.tokenizer = tokenizer(this.input)
  }

  decl(tokens, customProperty) {
    let node = new Declaration()
    this.init(node, tokens[0][2])

    let last = tokens[tokens.length - 1]
    if (last[0] === &#039;;&#039;) {
      this.semicolon = true
      tokens.pop()
    }

    node.source.end = this.getPosition(
      last[3] || last[2] || findLastWithPosition(tokens)
    )
    node.source.end.offset++

    while (tokens[0][0] !== &#039;word&#039;) {
      if (tokens.length === 1) this.unknownWord(tokens)
      node.raws.before += tokens.shift()[1]
    }
    node.source.start = this.getPosition(tokens[0][2])

    node.prop = &#039;&#039;
    while (tokens.length) {
      let type = tokens[0][0]
      if (type === &#039;:&#039; || type === &#039;space&#039; || type === &#039;comment&#039;) {
        break
      }
      node.prop += tokens.shift()[1]
    }

    node.raws.between = &#039;&#039;

    let token
    while (tokens.length) {
      token = tokens.shift()

      if (token[0] === &#039;:&#039;) {
        node.raws.between += token[1]
        break
      } else {
        if (token[0] === &#039;word&#039; &amp;&amp; /\w/.test(token[1])) {
          this.unknownWord([token])
        }
        node.raws.between += token[1]
      }
    }

    if (node.prop[0] === &#039;_&#039; || node.prop[0] === &#039;*&#039;) {
      node.raws.before += node.prop[0]
      node.prop = node.prop.slice(1)
    }

    let firstSpaces = []
    let next
    while (tokens.length) {
      next = tokens[0][0]
      if (next !== &#039;space&#039; &amp;&amp; next !== &#039;comment&#039;) break
      firstSpaces.push(tokens.shift())
    }

    this.precheckMissedSemicolon(tokens)

    for (let i = tokens.length - 1; i &gt;= 0; i--) {
      token = tokens[i]
      if (token[1].toLowerCase() === &#039;!important&#039;) {
        node.important = true
        let string = this.stringFrom(tokens, i)
        string = this.spacesFromEnd(tokens) + string
        if (string !== &#039; !important&#039;) node.raws.important = string
        break
      } else if (token[1].toLowerCase() === &#039;important&#039;) {
        let cache = tokens.slice(0)
        let str = &#039;&#039;
        for (let j = i; j &gt; 0; j--) {
          let type = cache[j][0]
          if (str.trim().startsWith(&#039;!&#039;) &amp;&amp; type !== &#039;space&#039;) {
            break
          }
          str = cache.pop()[1] + str
        }
        if (str.trim().startsWith(&#039;!&#039;)) {
          node.important = true
          node.raws.important = str
          tokens = cache
        }
      }

      if (token[0] !== &#039;space&#039; &amp;&amp; token[0] !== &#039;comment&#039;) {
        break
      }
    }

    let hasWord = tokens.some(i =&gt; i[0] !== &#039;space&#039; &amp;&amp; i[0] !== &#039;comment&#039;)

    if (hasWord) {
      node.raws.between += firstSpaces.map(i =&gt; i[1]).join(&#039;&#039;)
      firstSpaces = []
    }
    this.raw(node, &#039;value&#039;, firstSpaces.concat(tokens), customProperty)

    if (node.value.includes(&#039;:&#039;) &amp;&amp; !customProperty) {
      this.checkMissedSemicolon(tokens)
    }
  }

  doubleColon(token) {
    throw this.input.error(
      &#039;Double colon&#039;,
      { offset: token[2] },
      { offset: token[2] + token[1].length }
    )
  }

  emptyRule(token) {
    let node = new Rule()
    this.init(node, token[2])
    node.selector = &#039;&#039;
    node.raws.between = &#039;&#039;
    this.current = node
  }

  end(token) {
    if (this.current.nodes &amp;&amp; this.current.nodes.length) {
      this.current.raws.semicolon = this.semicolon
    }
    this.semicolon = false

    this.current.raws.after = (this.current.raws.after || &#039;&#039;) + this.spaces
    this.spaces = &#039;&#039;

    if (this.current.parent) {
      this.current.source.end = this.getPosition(token[2])
      this.current.source.end.offset++
      this.current = this.current.parent
    } else {
      this.unexpectedClose(token)
    }
  }

  endFile() {
    if (this.current.parent) this.unclosedBlock()
    if (this.current.nodes &amp;&amp; this.current.nodes.length) {
      this.current.raws.semicolon = this.semicolon
    }
    this.current.raws.after = (this.current.raws.after || &#039;&#039;) + this.spaces
    this.root.source.end = this.getPosition(this.tokenizer.position())
  }

  freeSemicolon(token) {
    this.spaces += token[1]
    if (this.current.nodes) {
      let prev = this.current.nodes[this.current.nodes.length - 1]
      if (prev &amp;&amp; prev.type === &#039;rule&#039; &amp;&amp; !prev.raws.ownSemicolon) {
        prev.raws.ownSemicolon = this.spaces
        this.spaces = &#039;&#039;
        prev.source.end = this.getPosition(token[2])
        prev.source.end.offset += prev.raws.ownSemicolon.length
      }
    }
  }

  // Helpers

  getPosition(offset) {
    let pos = this.input.fromOffset(offset)
    return {
      column: pos.col,
      line: pos.line,
      offset
    }
  }

  init(node, offset) {
    this.current.push(node)
    node.source = {
      input: this.input,
      start: this.getPosition(offset)
    }
    node.raws.before = this.spaces
    this.spaces = &#039;&#039;
    if (node.type !== &#039;comment&#039;) this.semicolon = false
  }

  other(start) {
    let end = false
    let type = null
    let colon = false
    let bracket = null
    let brackets = []
    let customProperty = start[1].startsWith(&#039;--&#039;)

    let tokens = []
    let token = start
    while (token) {
      type = token[0]
      tokens.push(token)

      if (type === &#039;(&#039; || type === &#039;[&#039;) {
        if (!bracket) bracket = token
        brackets.push(type === &#039;(&#039; ? &#039;)&#039; : &#039;]&#039;)
      } else if (customProperty &amp;&amp; colon &amp;&amp; type === &#039;{&#039;) {
        if (!bracket) bracket = token
        brackets.push(&#039;}&#039;)
      } else if (brackets.length === 0) {
        if (type === &#039;;&#039;) {
          if (colon) {
            this.decl(tokens, customProperty)
            return
          } else {
            break
          }
        } else if (type === &#039;{&#039;) {
          this.rule(tokens)
          return
        } else if (type === &#039;}&#039;) {
          this.tokenizer.back(tokens.pop())
          end = true
          break
        } else if (type === &#039;:&#039;) {
          colon = true
        }
      } else if (type === brackets[brackets.length - 1]) {
        brackets.pop()
        if (brackets.length === 0) bracket = null
      }

      token = this.tokenizer.nextToken()
    }

    if (this.tokenizer.endOfFile()) end = true
    if (brackets.length &gt; 0) this.unclosedBracket(bracket)

    if (end &amp;&amp; colon) {
      if (!customProperty) {
        while (tokens.length) {
          token = tokens[tokens.length - 1][0]
          if (token !== &#039;space&#039; &amp;&amp; token !== &#039;comment&#039;) break
          this.tokenizer.back(tokens.pop())
        }
      }
      this.decl(tokens, customProperty)
    } else {
      this.unknownWord(tokens)
    }
  }

  parse() {
    let token
    while (!this.tokenizer.endOfFile()) {
      token = this.tokenizer.nextToken()

      switch (token[0]) {
        case &#039;space&#039;:
          this.spaces += token[1]
          break

        case &#039;;&#039;:
          this.freeSemicolon(token)
          break

        case &#039;}&#039;:
          this.end(token)
          break

        case &#039;comment&#039;:
          this.comment(token)
          break

        case &#039;at-word&#039;:
          this.atrule(token)
          break

        case &#039;{&#039;:
          this.emptyRule(token)
          break

        default:
          this.other(token)
          break
      }
    }
    this.endFile()
  }

  precheckMissedSemicolon(/* tokens */) {
    // Hook for Safe Parser
  }

  raw(node, prop, tokens, customProperty) {
    let token, type
    let length = tokens.length
    let value = &#039;&#039;
    let clean = true
    let next, prev

    for (let i = 0; i &lt; length; i += 1) {
      token = tokens[i]
      type = token[0]
      if (type === &#039;space&#039; &amp;&amp; i === length - 1 &amp;&amp; !customProperty) {
        clean = false
      } else if (type === &#039;comment&#039;) {
        prev = tokens[i - 1] ? tokens[i - 1][0] : &#039;empty&#039;
        next = tokens[i + 1] ? tokens[i + 1][0] : &#039;empty&#039;
        if (!SAFE_COMMENT_NEIGHBOR[prev] &amp;&amp; !SAFE_COMMENT_NEIGHBOR[next]) {
          if (value.slice(-1) === &#039;,&#039;) {
            clean = false
          } else {
            value += token[1]
          }
        } else {
          clean = false
        }
      } else {
        value += token[1]
      }
    }
    if (!clean) {
      let raw = tokens.reduce((all, i) =&gt; all + i[1], &#039;&#039;)
      node.raws[prop] = { raw, value }
    }
    node[prop] = value
  }

  rule(tokens) {
    tokens.pop()

    let node = new Rule()
    this.init(node, tokens[0][2])

    node.raws.between = this.spacesAndCommentsFromEnd(tokens)
    this.raw(node, &#039;selector&#039;, tokens)
    this.current = node
  }

  spacesAndCommentsFromEnd(tokens) {
    let lastTokenType
    let spaces = &#039;&#039;
    while (tokens.length) {
      lastTokenType = tokens[tokens.length - 1][0]
      if (lastTokenType !== &#039;space&#039; &amp;&amp; lastTokenType !== &#039;comment&#039;) break
      spaces = tokens.pop()[1] + spaces
    }
    return spaces
  }

  // Errors

  spacesAndCommentsFromStart(tokens) {
    let next
    let spaces = &#039;&#039;
    while (tokens.length) {
      next = tokens[0][0]
      if (next !== &#039;space&#039; &amp;&amp; next !== &#039;comment&#039;) break
      spaces += tokens.shift()[1]
    }
    return spaces
  }

  spacesFromEnd(tokens) {
    let lastTokenType
    let spaces = &#039;&#039;
    while (tokens.length) {
      lastTokenType = tokens[tokens.length - 1][0]
      if (lastTokenType !== &#039;space&#039;) break
      spaces = tokens.pop()[1] + spaces
    }
    return spaces
  }

  stringFrom(tokens, from) {
    let result = &#039;&#039;
    for (let i = from; i &lt; tokens.length; i++) {
      result += tokens[i][1]
    }
    tokens.splice(from, tokens.length - from)
    return result
  }

  unclosedBlock() {
    let pos = this.current.source.start
    throw this.input.error(&#039;Unclosed block&#039;, pos.line, pos.column)
  }

  unclosedBracket(bracket) {
    throw this.input.error(
      &#039;Unclosed bracket&#039;,
      { offset: bracket[2] },
      { offset: bracket[2] + 1 }
    )
  }

  unexpectedClose(token) {
    throw this.input.error(
      &#039;Unexpected }&#039;,
      { offset: token[2] },
      { offset: token[2] + 1 }
    )
  }

  unknownWord(tokens) {
    throw this.input.error(
      &#039;Unknown word &#039; + tokens[0][1],
      { offset: tokens[0][2] },
      { offset: tokens[0][2] + tokens[0][1].length }
    )
  }

  unnamedAtrule(node, token) {
    throw this.input.error(
      &#039;At-rule without name&#039;,
      { offset: token[2] },
      { offset: token[2] + token[1].length }
    )
  }
}

module.exports = Parser


/***/ }),

/***/ 4067:
/***/ ((module) =&gt; {

&quot;use strict&quot;;
/**
 * Copyright (c) 2013-present, Facebook, Inc.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */



var ReactPropTypesSecret = &#039;SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED&#039;;

module.exports = ReactPropTypesSecret;


/***/ }),

/***/ 4092:
/***/ ((module, __unused_webpack_exports, __webpack_require__) =&gt; {

&quot;use strict&quot;;


let Container = __webpack_require__(683)
let list = __webpack_require__(7374)

class Rule extends Container {
  get selectors() {
    return list.comma(this.selector)
  }

  set selectors(values) {
    let match = this.selector ? this.selector.match(/,\s*/) : null
    let sep = match ? match[0] : &#039;,&#039; + this.raw(&#039;between&#039;, &#039;beforeOpen&#039;)
    this.selector = values.join(sep)
  }

  constructor(defaults) {
    super(defaults)
    this.type = &#039;rule&#039;
    if (!this.nodes) this.nodes = []
  }
}

module.exports = Rule
Rule.default = Rule

Container.registerRule(Rule)


/***/ }),

/***/ 4132:
/***/ ((__unused_webpack_module, exports, __webpack_require__) =&gt; {

&quot;use strict&quot;;
var __webpack_unused_export__;

__webpack_unused_export__ = true;
var TextareaAutosize_1 = __webpack_require__(4462);
exports.A = TextareaAutosize_1.TextareaAutosize;


/***/ }),

/***/ 4295:
/***/ ((module, __unused_webpack_exports, __webpack_require__) =&gt; {

&quot;use strict&quot;;


let Container = __webpack_require__(683)
let Input = __webpack_require__(5380)
let Parser = __webpack_require__(3937)

function parse(css, opts) {
  let input = new Input(css, opts)
  let parser = new Parser(input)
  try {
    parser.parse()
  } catch (e) {
    if (false) {}
    throw e
  }

  return parser.root
}

module.exports = parse
parse.default = parse

Container.registerParse(parse)


/***/ }),

/***/ 4306:
/***/ (function(module, exports) {

var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*!
	autosize 4.0.4
	license: MIT
	http://www.jacklmoore.com/autosize
*/
(function (global, factory) {
	if (true) {
		!(__WEBPACK_AMD_DEFINE_ARRAY__ = [module, exports], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory),
		__WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === &#039;function&#039; ?
		(__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__),
		__WEBPACK_AMD_DEFINE_RESULT__ !== undefined &amp;&amp; (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
	} else { var mod; }
})(this, function (module, exports) {
	&#039;use strict&#039;;

	var map = typeof Map === &quot;function&quot; ? new Map() : function () {
		var keys = [];
		var values = [];

		return {
			has: function has(key) {
				return keys.indexOf(key) &gt; -1;
			},
			get: function get(key) {
				return values[keys.indexOf(key)];
			},
			set: function set(key, value) {
				if (keys.indexOf(key) === -1) {
					keys.push(key);
					values.push(value);
				}
			},
			delete: function _delete(key) {
				var index = keys.indexOf(key);
				if (index &gt; -1) {
					keys.splice(index, 1);
					values.splice(index, 1);
				}
			}
		};
	}();

	var createEvent = function createEvent(name) {
		return new Event(name, { bubbles: true });
	};
	try {
		new Event(&#039;test&#039;);
	} catch (e) {
		// IE does not support `new Event()`
		createEvent = function createEvent(name) {
			var evt = document.createEvent(&#039;Event&#039;);
			evt.initEvent(name, true, false);
			return evt;
		};
	}

	function assign(ta) {
		if (!ta || !ta.nodeName || ta.nodeName !== &#039;TEXTAREA&#039; || map.has(ta)) return;

		var heightOffset = null;
		var clientWidth = null;
		var cachedHeight = null;

		function init() {
			var style = window.getComputedStyle(ta, null);

			if (style.resize === &#039;vertical&#039;) {
				ta.style.resize = &#039;none&#039;;
			} else if (style.resize === &#039;both&#039;) {
				ta.style.resize = &#039;horizontal&#039;;
			}

			if (style.boxSizing === &#039;content-box&#039;) {
				heightOffset = -(parseFloat(style.paddingTop) + parseFloat(style.paddingBottom));
			} else {
				heightOffset = parseFloat(style.borderTopWidth) + parseFloat(style.borderBottomWidth);
			}
			// Fix when a textarea is not on document body and heightOffset is Not a Number
			if (isNaN(heightOffset)) {
				heightOffset = 0;
			}

			update();
		}

		function changeOverflow(value) {
			{
				// Chrome/Safari-specific fix:
				// When the textarea y-overflow is hidden, Chrome/Safari do not reflow the text to account for the space
				// made available by removing the scrollbar. The following forces the necessary text reflow.
				var width = ta.style.width;
				ta.style.width = &#039;0px&#039;;
				// Force reflow:
				/* jshint ignore:start */
				ta.offsetWidth;
				/* jshint ignore:end */
				ta.style.width = width;
			}

			ta.style.overflowY = value;
		}

		function getParentOverflows(el) {
			var arr = [];

			while (el &amp;&amp; el.parentNode &amp;&amp; el.parentNode instanceof Element) {
				if (el.parentNode.scrollTop) {
					arr.push({
						node: el.parentNode,
						scrollTop: el.parentNode.scrollTop
					});
				}
				el = el.parentNode;
			}

			return arr;
		}

		function resize() {
			if (ta.scrollHeight === 0) {
				// If the scrollHeight is 0, then the element probably has display:none or is detached from the DOM.
				return;
			}

			var overflows = getParentOverflows(ta);
			var docTop = document.documentElement &amp;&amp; document.documentElement.scrollTop; // Needed for Mobile IE (ticket #240)

			ta.style.height = &#039;&#039;;
			ta.style.height = ta.scrollHeight + heightOffset + &#039;px&#039;;

			// used to check if an update is actually necessary on window.resize
			clientWidth = ta.clientWidth;

			// prevents scroll-position jumping
			overflows.forEach(function (el) {
				el.node.scrollTop = el.scrollTop;
			});

			if (docTop) {
				document.documentElement.scrollTop = docTop;
			}
		}

		function update() {
			resize();

			var styleHeight = Math.round(parseFloat(ta.style.height));
			var computed = window.getComputedStyle(ta, null);

			// Using offsetHeight as a replacement for computed.height in IE, because IE does not account use of border-box
			var actualHeight = computed.boxSizing === &#039;content-box&#039; ? Math.round(parseFloat(computed.height)) : ta.offsetHeight;

			// The actual height not matching the style height (set via the resize method) indicates that 
			// the max-height has been exceeded, in which case the overflow should be allowed.
			if (actualHeight &lt; styleHeight) {
				if (computed.overflowY === &#039;hidden&#039;) {
					changeOverflow(&#039;scroll&#039;);
					resize();
					actualHeight = computed.boxSizing === &#039;content-box&#039; ? Math.round(parseFloat(window.getComputedStyle(ta, null).height)) : ta.offsetHeight;
				}
			} else {
				// Normally keep overflow set to hidden, to avoid flash of scrollbar as the textarea expands.
				if (computed.overflowY !== &#039;hidden&#039;) {
					changeOverflow(&#039;hidden&#039;);
					resize();
					actualHeight = computed.boxSizing === &#039;content-box&#039; ? Math.round(parseFloat(window.getComputedStyle(ta, null).height)) : ta.offsetHeight;
				}
			}

			if (cachedHeight !== actualHeight) {
				cachedHeight = actualHeight;
				var evt = createEvent(&#039;autosize:resized&#039;);
				try {
					ta.dispatchEvent(evt);
				} catch (err) {
					// Firefox will throw an error on dispatchEvent for a detached element
					// https://bugzilla.mozilla.org/show_bug.cgi?id=889376
				}
			}
		}

		var pageResize = function pageResize() {
			if (ta.clientWidth !== clientWidth) {
				update();
			}
		};

		var destroy = function (style) {
			window.removeEventListener(&#039;resize&#039;, pageResize, false);
			ta.removeEventListener(&#039;input&#039;, update, false);
			ta.removeEventListener(&#039;keyup&#039;, update, false);
			ta.removeEventListener(&#039;autosize:destroy&#039;, destroy, false);
			ta.removeEventListener(&#039;autosize:update&#039;, update, false);

			Object.keys(style).forEach(function (key) {
				ta.style[key] = style[key];
			});

			map.delete(ta);
		}.bind(ta, {
			height: ta.style.height,
			resize: ta.style.resize,
			overflowY: ta.style.overflowY,
			overflowX: ta.style.overflowX,
			wordWrap: ta.style.wordWrap
		});

		ta.addEventListener(&#039;autosize:destroy&#039;, destroy, false);

		// IE9 does not fire onpropertychange or oninput for deletions,
		// so binding to onkeyup to catch most of those events.
		// There is no way that I know of to detect something like &#039;cut&#039; in IE9.
		if (&#039;onpropertychange&#039; in ta &amp;&amp; &#039;oninput&#039; in ta) {
			ta.addEventListener(&#039;keyup&#039;, update, false);
		}

		window.addEventListener(&#039;resize&#039;, pageResize, false);
		ta.addEventListener(&#039;input&#039;, update, false);
		ta.addEventListener(&#039;autosize:update&#039;, update, false);
		ta.style.overflowX = &#039;hidden&#039;;
		ta.style.wordWrap = &#039;break-word&#039;;

		map.set(ta, {
			destroy: destroy,
			update: update
		});

		init();
	}

	function destroy(ta) {
		var methods = map.get(ta);
		if (methods) {
			methods.destroy();
		}
	}

	function update(ta) {
		var methods = map.get(ta);
		if (methods) {
			methods.update();
		}
	}

	var autosize = null;

	// Do nothing in Node.js environment and IE8 (or lower)
	if (typeof window === &#039;undefined&#039; || typeof window.getComputedStyle !== &#039;function&#039;) {
		autosize = function autosize(el) {
			return el;
		};
		autosize.destroy = function (el) {
			return el;
		};
		autosize.update = function (el) {
			return el;
		};
	} else {
		autosize = function autosize(el, options) {
			if (el) {
				Array.prototype.forEach.call(el.length ? el : [el], function (x) {
					return assign(x, options);
				});
			}
			return el;
		};
		autosize.destroy = function (el) {
			if (el) {
				Array.prototype.forEach.call(el.length ? el : [el], destroy);
			}
			return el;
		};
		autosize.update = function (el) {
			if (el) {
				Array.prototype.forEach.call(el.length ? el : [el], update);
			}
			return el;
		};
	}

	exports.default = autosize;
	module.exports = exports[&#039;default&#039;];
});

/***/ }),

/***/ 4462:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {

&quot;use strict&quot;;

var __extends = (this &amp;&amp; this.__extends) || (function () {
    var extendStatics = Object.setPrototypeOf ||
        ({ __proto__: [] } instanceof Array &amp;&amp; function (d, b) { d.__proto__ = b; }) ||
        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
    return function (d, b) {
        extendStatics(d, b);
        function __() { this.constructor = d; }
        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
    };
})();
var __assign = (this &amp;&amp; this.__assign) || Object.assign || function(t) {
    for (var s, i = 1, n = arguments.length; i &lt; n; i++) {
        s = arguments[i];
        for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
            t[p] = s[p];
    }
    return t;
};
var __rest = (this &amp;&amp; this.__rest) || function (s, e) {
    var t = {};
    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) &amp;&amp; e.indexOf(p) &lt; 0)
        t[p] = s[p];
    if (s != null &amp;&amp; typeof Object.getOwnPropertySymbols === &quot;function&quot;)
        for (var i = 0, p = Object.getOwnPropertySymbols(s); i &lt; p.length; i++) if (e.indexOf(p[i]) &lt; 0)
            t[p[i]] = s[p[i]];
    return t;
};
exports.__esModule = true;
var React = __webpack_require__(1609);
var PropTypes = __webpack_require__(5826);
var autosize = __webpack_require__(4306);
var _getLineHeight = __webpack_require__(461);
var getLineHeight = _getLineHeight;
var RESIZED = &quot;autosize:resized&quot;;
/**
 * A light replacement for built-in textarea component
 * which automaticaly adjusts its height to match the content
 */
var TextareaAutosizeClass = /** @class */ (function (_super) {
    __extends(TextareaAutosizeClass, _super);
    function TextareaAutosizeClass() {
        var _this = _super !== null &amp;&amp; _super.apply(this, arguments) || this;
        _this.state = {
            lineHeight: null
        };
        _this.textarea = null;
        _this.onResize = function (e) {
            if (_this.props.onResize) {
                _this.props.onResize(e);
            }
        };
        _this.updateLineHeight = function () {
            if (_this.textarea) {
                _this.setState({
                    lineHeight: getLineHeight(_this.textarea)
                });
            }
        };
        _this.onChange = function (e) {
            var onChange = _this.props.onChange;
            _this.currentValue = e.currentTarget.value;
            onChange &amp;&amp; onChange(e);
        };
        return _this;
    }
    TextareaAutosizeClass.prototype.componentDidMount = function () {
        var _this = this;
        var _a = this.props, maxRows = _a.maxRows, async = _a.async;
        if (typeof maxRows === &quot;number&quot;) {
            this.updateLineHeight();
        }
        if (typeof maxRows === &quot;number&quot; || async) {
            /*
              the defer is needed to:
                - force &quot;autosize&quot; to activate the scrollbar when this.props.maxRows is passed
                - support StyledComponents (see #71)
            */
            setTimeout(function () { return _this.textarea &amp;&amp; autosize(_this.textarea); });
        }
        else {
            this.textarea &amp;&amp; autosize(this.textarea);
        }
        if (this.textarea) {
            this.textarea.addEventListener(RESIZED, this.onResize);
        }
    };
    TextareaAutosizeClass.prototype.componentWillUnmount = function () {
        if (this.textarea) {
            this.textarea.removeEventListener(RESIZED, this.onResize);
            autosize.destroy(this.textarea);
        }
    };
    TextareaAutosizeClass.prototype.render = function () {
        var _this = this;
        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, [&quot;onResize&quot;, &quot;maxRows&quot;, &quot;onChange&quot;, &quot;style&quot;, &quot;innerRef&quot;, &quot;children&quot;]), lineHeight = _a.state.lineHeight;
        var maxHeight = maxRows &amp;&amp; lineHeight ? lineHeight * maxRows : null;
        return (React.createElement(&quot;textarea&quot;, __assign({}, props, { onChange: this.onChange, style: maxHeight ? __assign({}, style, { maxHeight: maxHeight }) : style, ref: function (element) {
                _this.textarea = element;
                if (typeof _this.props.innerRef === &#039;function&#039;) {
                    _this.props.innerRef(element);
                }
                else if (_this.props.innerRef) {
                    _this.props.innerRef.current = element;
                }
            } }), children));
    };
    TextareaAutosizeClass.prototype.componentDidUpdate = function () {
        this.textarea &amp;&amp; autosize.update(this.textarea);
    };
    TextareaAutosizeClass.defaultProps = {
        rows: 1,
        async: false
    };
    TextareaAutosizeClass.propTypes = {
        rows: PropTypes.number,
        maxRows: PropTypes.number,
        onResize: PropTypes.func,
        innerRef: PropTypes.any,
        async: PropTypes.bool
    };
    return TextareaAutosizeClass;
}(React.Component));
exports.TextareaAutosize = React.forwardRef(function (props, ref) {
    return React.createElement(TextareaAutosizeClass, __assign({}, props, { innerRef: ref }));
});


/***/ }),

/***/ 4725:
/***/ ((module) =&gt; {

function stringifyNode(node, custom) {
  var type = node.type;
  var value = node.value;
  var buf;
  var customResult;

  if (custom &amp;&amp; (customResult = custom(node)) !== undefined) {
    return customResult;
  } else if (type === &quot;word&quot; || type === &quot;space&quot;) {
    return value;
  } else if (type === &quot;string&quot;) {
    buf = node.quote || &quot;&quot;;
    return buf + value + (node.unclosed ? &quot;&quot; : buf);
  } else if (type === &quot;comment&quot;) {
    return &quot;/*&quot; + value + (node.unclosed ? &quot;&quot; : &quot;*/&quot;);
  } else if (type === &quot;div&quot;) {
    return (node.before || &quot;&quot;) + value + (node.after || &quot;&quot;);
  } else if (Array.isArray(node.nodes)) {
    buf = stringify(node.nodes, custom);
    if (type !== &quot;function&quot;) {
      return buf;
    }
    return (
      value +
      &quot;(&quot; +
      (node.before || &quot;&quot;) +
      buf +
      (node.after || &quot;&quot;) +
      (node.unclosed ? &quot;&quot; : &quot;)&quot;)
    );
  }
  return value;
}

function stringify(nodes, custom) {
  var result, i;

  if (Array.isArray(nodes)) {
    result = &quot;&quot;;
    for (i = nodes.length - 1; ~i; i -= 1) {
      result = stringifyNode(nodes[i], custom) + result;
    }
    return result;
  }
  return stringifyNode(nodes, custom);
}

module.exports = stringify;


/***/ }),

/***/ 5042:
/***/ ((module) =&gt; {

// This alphabet uses `A-Za-z0-9_-` symbols.
// The order of characters is optimized for better gzip and brotli compression.
// References to the same file (works both for gzip and brotli):
// `&#039;use`, `andom`, and `rict&#039;`
// References to the brotli default dictionary:
// `-26T`, `1983`, `40px`, `75px`, `bush`, `jack`, `mind`, `very`, and `wolf`
let urlAlphabet =
  &#039;useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict&#039;

let customAlphabet = (alphabet, defaultSize = 21) =&gt; {
  return (size = defaultSize) =&gt; {
    let id = &#039;&#039;
    // A compact alternative for `for (var i = 0; i &lt; step; i++)`.
    let i = size | 0
    while (i--) {
      // `| 0` is more compact and faster than `Math.floor()`.
      id += alphabet[(Math.random() * alphabet.length) | 0]
    }
    return id
  }
}

let nanoid = (size = 21) =&gt; {
  let id = &#039;&#039;
  // A compact alternative for `for (var i = 0; i &lt; step; i++)`.
  let i = size | 0
  while (i--) {
    // `| 0` is more compact and faster than `Math.floor()`.
    id += urlAlphabet[(Math.random() * 64) | 0]
  }
  return id
}

module.exports = { nanoid, customAlphabet }


/***/ }),

/***/ 5215:
/***/ ((module) =&gt; {

&quot;use strict&quot;;


// do not edit .js files directly - edit src/index.jst



module.exports = function equal(a, b) {
  if (a === b) return true;

  if (a &amp;&amp; b &amp;&amp; typeof a == &#039;object&#039; &amp;&amp; typeof b == &#039;object&#039;) {
    if (a.constructor !== b.constructor) return false;

    var length, i, keys;
    if (Array.isArray(a)) {
      length = a.length;
      if (length != b.length) return false;
      for (i = length; i-- !== 0;)
        if (!equal(a[i], b[i])) return false;
      return true;
    }



    if (a.constructor === RegExp) return a.source === b.source &amp;&amp; a.flags === b.flags;
    if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf();
    if (a.toString !== Object.prototype.toString) return a.toString() === b.toString();

    keys = Object.keys(a);
    length = keys.length;
    if (length !== Object.keys(b).length) return false;

    for (i = length; i-- !== 0;)
      if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;

    for (i = length; i-- !== 0;) {
      var key = keys[i];

      if (!equal(a[key], b[key])) return false;
    }

    return true;
  }

  // true if both NaN, false otherwise
  return a!==a &amp;&amp; b!==b;
};


/***/ }),

/***/ 5380:
/***/ ((module, __unused_webpack_exports, __webpack_require__) =&gt; {

&quot;use strict&quot;;


let { nanoid } = __webpack_require__(5042)
let { isAbsolute, resolve } = __webpack_require__(197)
let { SourceMapConsumer, SourceMapGenerator } = __webpack_require__(1866)
let { fileURLToPath, pathToFileURL } = __webpack_require__(2739)

let CssSyntaxError = __webpack_require__(356)
let PreviousMap = __webpack_require__(5696)
let terminalHighlight = __webpack_require__(9746)

let fromOffsetCache = Symbol(&#039;fromOffsetCache&#039;)

let sourceMapAvailable = Boolean(SourceMapConsumer &amp;&amp; SourceMapGenerator)
let pathAvailable = Boolean(resolve &amp;&amp; isAbsolute)

class Input {
  get from() {
    return this.file || this.id
  }

  constructor(css, opts = {}) {
    if (
      css === null ||
      typeof css === &#039;undefined&#039; ||
      (typeof css === &#039;object&#039; &amp;&amp; !css.toString)
    ) {
      throw new Error(`PostCSS received ${css} instead of CSS string`)
    }

    this.css = css.toString()

    if (this.css[0] === &#039;\uFEFF&#039; || this.css[0] === &#039;\uFFFE&#039;) {
      this.hasBOM = true
      this.css = this.css.slice(1)
    } else {
      this.hasBOM = false
    }

    this.document = this.css
    if (opts.document) this.document = opts.document.toString()

    if (opts.from) {
      if (
        !pathAvailable ||
        /^\w+:\/\//.test(opts.from) ||
        isAbsolute(opts.from)
      ) {
        this.file = opts.from
      } else {
        this.file = resolve(opts.from)
      }
    }

    if (pathAvailable &amp;&amp; sourceMapAvailable) {
      let map = new PreviousMap(this.css, opts)
      if (map.text) {
        this.map = map
        let file = map.consumer().file
        if (!this.file &amp;&amp; file) this.file = this.mapResolve(file)
      }
    }

    if (!this.file) {
      this.id = &#039;&lt;input css &#039; + nanoid(6) + &#039;&gt;&#039;
    }
    if (this.map) this.map.file = this.from
  }

  error(message, line, column, opts = {}) {
    let endColumn, endLine, result

    if (line &amp;&amp; typeof line === &#039;object&#039;) {
      let start = line
      let end = column
      if (typeof start.offset === &#039;number&#039;) {
        let pos = this.fromOffset(start.offset)
        line = pos.line
        column = pos.col
      } else {
        line = start.line
        column = start.column
      }
      if (typeof end.offset === &#039;number&#039;) {
        let pos = this.fromOffset(end.offset)
        endLine = pos.line
        endColumn = pos.col
      } else {
        endLine = end.line
        endColumn = end.column
      }
    } else if (!column) {
      let pos = this.fromOffset(line)
      line = pos.line
      column = pos.col
    }

    let origin = this.origin(line, column, endLine, endColumn)
    if (origin) {
      result = new CssSyntaxError(
        message,
        origin.endLine === undefined
          ? origin.line
          : { column: origin.column, line: origin.line },
        origin.endLine === undefined
          ? origin.column
          : { column: origin.endColumn, line: origin.endLine },
        origin.source,
        origin.file,
        opts.plugin
      )
    } else {
      result = new CssSyntaxError(
        message,
        endLine === undefined ? line : { column, line },
        endLine === undefined ? column : { column: endColumn, line: endLine },
        this.css,
        this.file,
        opts.plugin
      )
    }

    result.input = { column, endColumn, endLine, line, source: this.css }
    if (this.file) {
      if (pathToFileURL) {
        result.input.url = pathToFileURL(this.file).toString()
      }
      result.input.file = this.file
    }

    return result
  }

  fromOffset(offset) {
    let lastLine, lineToIndex
    if (!this[fromOffsetCache]) {
      let lines = this.css.split(&#039;\n&#039;)
      lineToIndex = new Array(lines.length)
      let prevIndex = 0

      for (let i = 0, l = lines.length; i &lt; l; i++) {
        lineToIndex[i] = prevIndex
        prevIndex += lines[i].length + 1
      }

      this[fromOffsetCache] = lineToIndex
    } else {
      lineToIndex = this[fromOffsetCache]
    }
    lastLine = lineToIndex[lineToIndex.length - 1]

    let min = 0
    if (offset &gt;= lastLine) {
      min = lineToIndex.length - 1
    } else {
      let max = lineToIndex.length - 2
      let mid
      while (min &lt; max) {
        mid = min + ((max - min) &gt;&gt; 1)
        if (offset &lt; lineToIndex[mid]) {
          max = mid - 1
        } else if (offset &gt;= lineToIndex[mid + 1]) {
          min = mid + 1
        } else {
          min = mid
          break
        }
      }
    }
    return {
      col: offset - lineToIndex[min] + 1,
      line: min + 1
    }
  }

  mapResolve(file) {
    if (/^\w+:\/\//.test(file)) {
      return file
    }
    return resolve(this.map.consumer().sourceRoot || this.map.root || &#039;.&#039;, file)
  }

  origin(line, column, endLine, endColumn) {
    if (!this.map) return false
    let consumer = this.map.consumer()

    let from = consumer.originalPositionFor({ column, line })
    if (!from.source) return false

    let to
    if (typeof endLine === &#039;number&#039;) {
      to = consumer.originalPositionFor({ column: endColumn, line: endLine })
    }

    let fromUrl

    if (isAbsolute(from.source)) {
      fromUrl = pathToFileURL(from.source)
    } else {
      fromUrl = new URL(
        from.source,
        this.map.consumer().sourceRoot || pathToFileURL(this.map.mapFile)
      )
    }

    let result = {
      column: from.column,
      endColumn: to &amp;&amp; to.column,
      endLine: to &amp;&amp; to.line,
      line: from.line,
      url: fromUrl.toString()
    }

    if (fromUrl.protocol === &#039;file:&#039;) {
      if (fileURLToPath) {
        result.file = fileURLToPath(fromUrl)
      } else {
        /* c8 ignore next 2 */
        throw new Error(`file: protocol is not available in this PostCSS build`)
      }
    }

    let source = consumer.sourceContentFor(from.source)
    if (source) result.source = source

    return result
  }

  toJSON() {
    let json = {}
    for (let name of [&#039;hasBOM&#039;, &#039;css&#039;, &#039;file&#039;, &#039;id&#039;]) {
      if (this[name] != null) {
        json[name] = this[name]
      }
    }
    if (this.map) {
      json.map = { ...this.map }
      if (json.map.consumerCache) {
        json.map.consumerCache = undefined
      }
    }
    return json
  }
}

module.exports = Input
Input.default = Input

if (terminalHighlight &amp;&amp; terminalHighlight.registerInput) {
  terminalHighlight.registerInput(Input)
}


/***/ }),

/***/ 5404:
/***/ ((module, __unused_webpack_exports, __webpack_require__) =&gt; {

const CSSValueParser = __webpack_require__(1544)

/**
 * @type {import(&#039;postcss&#039;).PluginCreator}
 */
module.exports = (opts) =&gt; {

  const DEFAULTS = {
    skipHostRelativeUrls: true,
  }
  const config = Object.assign(DEFAULTS, opts)

  return {
    postcssPlugin: &#039;rebaseUrl&#039;,

    Declaration(decl) {
      // The faster way to find Declaration node
      const parsedValue = CSSValueParser(decl.value)

      let valueChanged = false
      parsedValue.walk(node =&gt; {
        if (node.type !== &#039;function&#039; || node.value !== &#039;url&#039;) {
          return
        }

        const urlVal = node.nodes[0].value

        // bases relative URLs with rootUrl
        const basedUrl = new URL(urlVal, opts.rootUrl)

        // skip host-relative, already normalized URLs (e.g. `/images/image.jpg`, without `..`s)
        if ((basedUrl.pathname === urlVal) &amp;&amp; config.skipHostRelativeUrls) {
          return false // skip this value
        }

        node.nodes[0].value = basedUrl.toString()
        valueChanged = true

        return false // do not walk deeper
      })

      if (valueChanged) {
        decl.value = CSSValueParser.stringify(parsedValue)
      }

    }
  }
}

module.exports.postcss = true


/***/ }),

/***/ 5417:
/***/ ((__unused_webpack_module, exports) =&gt; {

&quot;use strict&quot;;
/*istanbul ignore start*/


Object.defineProperty(exports, &quot;__esModule&quot;, ({
  value: true
}));
exports[&quot;default&quot;] = Diff;

/*istanbul ignore end*/
function Diff() {}

Diff.prototype = {
  /*istanbul ignore start*/

  /*istanbul ignore end*/
  diff: function diff(oldString, newString) {
    /*istanbul ignore start*/
    var
    /*istanbul ignore end*/
    options = arguments.length &gt; 2 &amp;&amp; arguments[2] !== undefined ? arguments[2] : {};
    var callback = options.callback;

    if (typeof options === &#039;function&#039;) {
      callback = options;
      options = {};
    }

    this.options = options;
    var self = this;

    function done(value) {
      if (callback) {
        setTimeout(function () {
          callback(undefined, value);
        }, 0);
        return true;
      } else {
        return value;
      }
    } // Allow subclasses to massage the input prior to running


    oldString = this.castInput(oldString);
    newString = this.castInput(newString);
    oldString = this.removeEmpty(this.tokenize(oldString));
    newString = this.removeEmpty(this.tokenize(newString));
    var newLen = newString.length,
        oldLen = oldString.length;
    var editLength = 1;
    var maxEditLength = newLen + oldLen;
    var bestPath = [{
      newPos: -1,
      components: []
    }]; // Seed editLength = 0, i.e. the content starts with the same values

    var oldPos = this.extractCommon(bestPath[0], newString, oldString, 0);

    if (bestPath[0].newPos + 1 &gt;= newLen &amp;&amp; oldPos + 1 &gt;= oldLen) {
      // Identity per the equality and tokenizer
      return done([{
        value: this.join(newString),
        count: newString.length
      }]);
    } // Main worker method. checks all permutations of a given edit length for acceptance.


    function execEditLength() {
      for (var diagonalPath = -1 * editLength; diagonalPath &lt;= editLength; diagonalPath += 2) {
        var basePath =
        /*istanbul ignore start*/
        void 0
        /*istanbul ignore end*/
        ;

        var addPath = bestPath[diagonalPath - 1],
            removePath = bestPath[diagonalPath + 1],
            _oldPos = (removePath ? removePath.newPos : 0) - diagonalPath;

        if (addPath) {
          // No one else is going to attempt to use this value, clear it
          bestPath[diagonalPath - 1] = undefined;
        }

        var canAdd = addPath &amp;&amp; addPath.newPos + 1 &lt; newLen,
            canRemove = removePath &amp;&amp; 0 &lt;= _oldPos &amp;&amp; _oldPos &lt; oldLen;

        if (!canAdd &amp;&amp; !canRemove) {
          // If this path is a terminal then prune
          bestPath[diagonalPath] = undefined;
          continue;
        } // Select the diagonal that we want to branch from. We select the prior
        // path whose position in the new string is the farthest from the origin
        // and does not pass the bounds of the diff graph


        if (!canAdd || canRemove &amp;&amp; addPath.newPos &lt; removePath.newPos) {
          basePath = clonePath(removePath);
          self.pushComponent(basePath.components, undefined, true);
        } else {
          basePath = addPath; // No need to clone, we&#039;ve pulled it from the list

          basePath.newPos++;
          self.pushComponent(basePath.components, true, undefined);
        }

        _oldPos = self.extractCommon(basePath, newString, oldString, diagonalPath); // If we have hit the end of both strings, then we are done

        if (basePath.newPos + 1 &gt;= newLen &amp;&amp; _oldPos + 1 &gt;= oldLen) {
          return done(buildValues(self, basePath.components, newString, oldString, self.useLongestToken));
        } else {
          // Otherwise track this path as a potential candidate and continue.
          bestPath[diagonalPath] = basePath;
        }
      }

      editLength++;
    } // Performs the length of edit iteration. Is a bit fugly as this has to support the
    // sync and async mode which is never fun. Loops over execEditLength until a value
    // is produced.


    if (callback) {
      (function exec() {
        setTimeout(function () {
          // This should not happen, but we want to be safe.

          /* istanbul ignore next */
          if (editLength &gt; maxEditLength) {
            return callback();
          }

          if (!execEditLength()) {
            exec();
          }
        }, 0);
      })();
    } else {
      while (editLength &lt;= maxEditLength) {
        var ret = execEditLength();

        if (ret) {
          return ret;
        }
      }
    }
  },

  /*istanbul ignore start*/

  /*istanbul ignore end*/
  pushComponent: function pushComponent(components, added, removed) {
    var last = components[components.length - 1];

    if (last &amp;&amp; last.added === added &amp;&amp; last.removed === removed) {
      // We need to clone here as the component clone operation is just
      // as shallow array clone
      components[components.length - 1] = {
        count: last.count + 1,
        added: added,
        removed: removed
      };
    } else {
      components.push({
        count: 1,
        added: added,
        removed: removed
      });
    }
  },

  /*istanbul ignore start*/

  /*istanbul ignore end*/
  extractCommon: function extractCommon(basePath, newString, oldString, diagonalPath) {
    var newLen = newString.length,
        oldLen = oldString.length,
        newPos = basePath.newPos,
        oldPos = newPos - diagonalPath,
        commonCount = 0;

    while (newPos + 1 &lt; newLen &amp;&amp; oldPos + 1 &lt; oldLen &amp;&amp; this.equals(newString[newPos + 1], oldString[oldPos + 1])) {
      newPos++;
      oldPos++;
      commonCount++;
    }

    if (commonCount) {
      basePath.components.push({
        count: commonCount
      });
    }

    basePath.newPos = newPos;
    return oldPos;
  },

  /*istanbul ignore start*/

  /*istanbul ignore end*/
  equals: function equals(left, right) {
    if (this.options.comparator) {
      return this.options.comparator(left, right);
    } else {
      return left === right || this.options.ignoreCase &amp;&amp; left.toLowerCase() === right.toLowerCase();
    }
  },

  /*istanbul ignore start*/

  /*istanbul ignore end*/
  removeEmpty: function removeEmpty(array) {
    var ret = [];

    for (var i = 0; i &lt; array.length; i++) {
      if (array[i]) {
        ret.push(array[i]);
      }
    }

    return ret;
  },

  /*istanbul ignore start*/

  /*istanbul ignore end*/
  castInput: function castInput(value) {
    return value;
  },

  /*istanbul ignore start*/

  /*istanbul ignore end*/
  tokenize: function tokenize(value) {
    return value.split(&#039;&#039;);
  },

  /*istanbul ignore start*/

  /*istanbul ignore end*/
  join: function join(chars) {
    return chars.join(&#039;&#039;);
  }
};

function buildValues(diff, components, newString, oldString, useLongestToken) {
  var componentPos = 0,
      componentLen = components.length,
      newPos = 0,
      oldPos = 0;

  for (; componentPos &lt; componentLen; componentPos++) {
    var component = components[componentPos];

    if (!component.removed) {
      if (!component.added &amp;&amp; useLongestToken) {
        var value = newString.slice(newPos, newPos + component.count);
        value = value.map(function (value, i) {
          var oldValue = oldString[oldPos + i];
          return oldValue.length &gt; value.length ? oldValue : value;
        });
        component.value = diff.join(value);
      } else {
        component.value = diff.join(newString.slice(newPos, newPos + component.count));
      }

      newPos += component.count; // Common case

      if (!component.added) {
        oldPos += component.count;
      }
    } else {
      component.value = diff.join(oldString.slice(oldPos, oldPos + component.count));
      oldPos += component.count; // Reverse add and remove so removes are output first to match common convention
      // The diffing algorithm is tied to add then remove output and this is the simplest
      // route to get the desired output with minimal overhead.

      if (componentPos &amp;&amp; components[componentPos - 1].added) {
        var tmp = components[componentPos - 1];
        components[componentPos - 1] = components[componentPos];
        components[componentPos] = tmp;
      }
    }
  } // Special case handle for when one terminal is ignored (i.e. whitespace).
  // For this case we merge the terminal into the prior string and drop the change.
  // This is only available for string mode.


  var lastComponent = components[componentLen - 1];

  if (componentLen &gt; 1 &amp;&amp; typeof lastComponent.value === &#039;string&#039; &amp;&amp; (lastComponent.added || lastComponent.removed) &amp;&amp; diff.equals(&#039;&#039;, lastComponent.value)) {
    components[componentLen - 2].value += lastComponent.value;
    components.pop();
  }

  return components;
}

function clonePath(path) {
  return {
    newPos: path.newPos,
    components: path.components.slice(0)
  };
}


/***/ }),

/***/ 5696:
/***/ ((module, __unused_webpack_exports, __webpack_require__) =&gt; {

&quot;use strict&quot;;


let { existsSync, readFileSync } = __webpack_require__(9977)
let { dirname, join } = __webpack_require__(197)
let { SourceMapConsumer, SourceMapGenerator } = __webpack_require__(1866)

function fromBase64(str) {
  if (Buffer) {
    return Buffer.from(str, &#039;base64&#039;).toString()
  } else {
    /* c8 ignore next 2 */
    return window.atob(str)
  }
}

class PreviousMap {
  constructor(css, opts) {
    if (opts.map === false) return
    this.loadAnnotation(css)
    this.inline = this.startWith(this.annotation, &#039;data:&#039;)

    let prev = opts.map ? opts.map.prev : undefined
    let text = this.loadMap(opts.from, prev)
    if (!this.mapFile &amp;&amp; opts.from) {
      this.mapFile = opts.from
    }
    if (this.mapFile) this.root = dirname(this.mapFile)
    if (text) this.text = text
  }

  consumer() {
    if (!this.consumerCache) {
      this.consumerCache = new SourceMapConsumer(this.text)
    }
    return this.consumerCache
  }

  decodeInline(text) {
    let baseCharsetUri = /^data:application\/json;charset=utf-?8;base64,/
    let baseUri = /^data:application\/json;base64,/
    let charsetUri = /^data:application\/json;charset=utf-?8,/
    let uri = /^data:application\/json,/

    let uriMatch = text.match(charsetUri) || text.match(uri)
    if (uriMatch) {
      return decodeURIComponent(text.substr(uriMatch[0].length))
    }

    let baseUriMatch = text.match(baseCharsetUri) || text.match(baseUri)
    if (baseUriMatch) {
      return fromBase64(text.substr(baseUriMatch[0].length))
    }

    let encoding = text.match(/data:application\/json;([^,]+),/)[1]
    throw new Error(&#039;Unsupported source map encoding &#039; + encoding)
  }

  getAnnotationURL(sourceMapString) {
    return sourceMapString.replace(/^\/\*\s*# sourceMappingURL=/, &#039;&#039;).trim()
  }

  isMap(map) {
    if (typeof map !== &#039;object&#039;) return false
    return (
      typeof map.mappings === &#039;string&#039; ||
      typeof map._mappings === &#039;string&#039; ||
      Array.isArray(map.sections)
    )
  }

  loadAnnotation(css) {
    let comments = css.match(/\/\*\s*# sourceMappingURL=/g)
    if (!comments) return

    // sourceMappingURLs from comments, strings, etc.
    let start = css.lastIndexOf(comments.pop())
    let end = css.indexOf(&#039;*/&#039;, start)

    if (start &gt; -1 &amp;&amp; end &gt; -1) {
      // Locate the last sourceMappingURL to avoid pickin
      this.annotation = this.getAnnotationURL(css.substring(start, end))
    }
  }

  loadFile(path) {
    this.root = dirname(path)
    if (existsSync(path)) {
      this.mapFile = path
      return readFileSync(path, &#039;utf-8&#039;).toString().trim()
    }
  }

  loadMap(file, prev) {
    if (prev === false) return false

    if (prev) {
      if (typeof prev === &#039;string&#039;) {
        return prev
      } else if (typeof prev === &#039;function&#039;) {
        let prevPath = prev(file)
        if (prevPath) {
          let map = this.loadFile(prevPath)
          if (!map) {
            throw new Error(
              &#039;Unable to load previous source map: &#039; + prevPath.toString()
            )
          }
          return map
        }
      } else if (prev instanceof SourceMapConsumer) {
        return SourceMapGenerator.fromSourceMap(prev).toString()
      } else if (prev instanceof SourceMapGenerator) {
        return prev.toString()
      } else if (this.isMap(prev)) {
        return JSON.stringify(prev)
      } else {
        throw new Error(
          &#039;Unsupported previous source map format: &#039; + prev.toString()
        )
      }
    } else if (this.inline) {
      return this.decodeInline(this.annotation)
    } else if (this.annotation) {
      let map = this.annotation
      if (file) map = join(dirname(file), map)
      return this.loadFile(map)
    }
  }

  startWith(string, start) {
    if (!string) return false
    return string.substr(0, start.length) === start
  }

  withContent() {
    return !!(
      this.consumer().sourcesContent &amp;&amp;
      this.consumer().sourcesContent.length &gt; 0
    )
  }
}

module.exports = PreviousMap
PreviousMap.default = PreviousMap


/***/ }),

/***/ 5776:
/***/ ((module) =&gt; {

&quot;use strict&quot;;


class Warning {
  constructor(text, opts = {}) {
    this.type = &#039;warning&#039;
    this.text = text

    if (opts.node &amp;&amp; opts.node.source) {
      let range = opts.node.rangeBy(opts)
      this.line = range.start.line
      this.column = range.start.column
      this.endLine = range.end.line
      this.endColumn = range.end.column
    }

    for (let opt in opts) this[opt] = opts[opt]
  }

  toString() {
    if (this.node) {
      return this.node.error(this.text, {
        index: this.index,
        plugin: this.plugin,
        word: this.word
      }).message
    }

    if (this.plugin) {
      return this.plugin + &#039;: &#039; + this.text
    }

    return this.text
  }
}

module.exports = Warning
Warning.default = Warning


/***/ }),

/***/ 5826:
/***/ ((module, __unused_webpack_exports, __webpack_require__) =&gt; {

/**
 * Copyright (c) 2013-present, Facebook, Inc.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */

if (false) { var throwOnDirectAccess, ReactIs; } else {
  // By explicitly using `prop-types` you are opting into new production behavior.
  // http://fb.me/prop-types-in-prod
  module.exports = __webpack_require__(628)();
}


/***/ }),

/***/ 6109:
/***/ ((module) =&gt; {

// This code has been refactored for 140 bytes
// You can see the original here: https://github.com/twolfson/computedStyle/blob/04cd1da2e30fa45844f95f5cb1ac898e9b9ef050/lib/computedStyle.js
var computedStyle = function (el, prop, getComputedStyle) {
  getComputedStyle = window.getComputedStyle;

  // In one fell swoop
  return (
    // If we have getComputedStyle
    getComputedStyle ?
      // Query it
      // TODO: From CSS-Query notes, we might need (node, null) for FF
      getComputedStyle(el) :

    // Otherwise, we are in IE and use currentStyle
      el.currentStyle
  )[
    // Switch to camelCase for CSSOM
    // DEV: Grabbed from jQuery
    // https://github.com/jquery/jquery/blob/1.9-stable/src/css.js#L191-L194
    // https://github.com/jquery/jquery/blob/1.9-stable/src/core.js#L593-L597
    prop.replace(/-(\w)/gi, function (word, letter) {
      return letter.toUpperCase();
    })
  ];
};

module.exports = computedStyle;


/***/ }),

/***/ 6589:
/***/ ((module, __unused_webpack_exports, __webpack_require__) =&gt; {

&quot;use strict&quot;;


let Node = __webpack_require__(7490)

class Comment extends Node {
  constructor(defaults) {
    super(defaults)
    this.type = &#039;comment&#039;
  }
}

module.exports = Comment
Comment.default = Comment


/***/ }),

/***/ 7191:
/***/ ((module, __unused_webpack_exports, __webpack_require__) =&gt; {

&quot;use strict&quot;;
/**
 * Copyright (c) 2015, Facebook, Inc.
 * All rights reserved.
 *
 * This source code is licensed under the BSD-style license found in the
 * LICENSE file in the root directory of this source tree. An additional grant
 * of patent rights can be found in the PATENTS file in the same directory.
 *
 * @providesModule normalizeWheel
 * @typechecks
 */



var UserAgent_DEPRECATED = __webpack_require__(2213);

var isEventSupported = __webpack_require__(1087);


// Reasonable defaults
var PIXEL_STEP  = 10;
var LINE_HEIGHT = 40;
var PAGE_HEIGHT = 800;

/**
 * Mouse wheel (and 2-finger trackpad) support on the web sucks.  It is
 * complicated, thus this doc is long and (hopefully) detailed enough to answer
 * your questions.
 *
 * If you need to react to the mouse wheel in a predictable way, this code is
 * like your bestest friend. * hugs *
 *
 * As of today, there are 4 DOM event types you can listen to:
 *
 *   &#039;wheel&#039;                -- Chrome(31+), FF(17+), IE(9+)
 *   &#039;mousewheel&#039;           -- Chrome, IE(6+), Opera, Safari
 *   &#039;MozMousePixelScroll&#039;  -- FF(3.5 only!) (2010-2013) -- don&#039;t bother!
 *   &#039;DOMMouseScroll&#039;       -- FF(0.9.7+) since 2003
 *
 * So what to do?  The is the best:
 *
 *   normalizeWheel.getEventType();
 *
 * In your event callback, use this code to get sane interpretation of the
 * deltas.  This code will return an object with properties:
 *
 *   spinX   -- normalized spin speed (use for zoom) - x plane
 *   spinY   -- &quot; - y plane
 *   pixelX  -- normalized distance (to pixels) - x plane
 *   pixelY  -- &quot; - y plane
 *
 * Wheel values are provided by the browser assuming you are using the wheel to
 * scroll a web page by a number of lines or pixels (or pages).  Values can vary
 * significantly on different platforms and browsers, forgetting that you can
 * scroll at different speeds.  Some devices (like trackpads) emit more events
 * at smaller increments with fine granularity, and some emit massive jumps with
 * linear speed or acceleration.
 *
 * This code does its best to normalize the deltas for you:
 *
 *   - spin is trying to normalize how far the wheel was spun (or trackpad
 *     dragged).  This is super useful for zoom support where you want to
 *     throw away the chunky scroll steps on the PC and make those equal to
 *     the slow and smooth tiny steps on the Mac. Key data: This code tries to
 *     resolve a single slow step on a wheel to 1.
 *
 *   - pixel is normalizing the desired scroll delta in pixel units.  You&#039;ll
 *     get the crazy differences between browsers, but at least it&#039;ll be in
 *     pixels!
 *
 *   - positive value indicates scrolling DOWN/RIGHT, negative UP/LEFT.  This
 *     should translate to positive value zooming IN, negative zooming OUT.
 *     This matches the newer &#039;wheel&#039; event.
 *
 * Why are there spinX, spinY (or pixels)?
 *
 *   - spinX is a 2-finger side drag on the trackpad, and a shift + wheel turn
 *     with a mouse.  It results in side-scrolling in the browser by default.
 *
 *   - spinY is what you expect -- it&#039;s the classic axis of a mouse wheel.
 *
 *   - I dropped spinZ/pixelZ.  It is supported by the DOM 3 &#039;wheel&#039; event and
 *     probably is by browsers in conjunction with fancy 3D controllers .. but
 *     you know.
 *
 * Implementation info:
 *
 * Examples of &#039;wheel&#039; event if you scroll slowly (down) by one step with an
 * average mouse:
 *
 *   OS X + Chrome  (mouse)     -    4   pixel delta  (wheelDelta -120)
 *   OS X + Safari  (mouse)     -  N/A   pixel delta  (wheelDelta  -12)
 *   OS X + Firefox (mouse)     -    0.1 line  delta  (wheelDelta  N/A)
 *   Win8 + Chrome  (mouse)     -  100   pixel delta  (wheelDelta -120)
 *   Win8 + Firefox (mouse)     -    3   line  delta  (wheelDelta -120)
 *
 * On the trackpad:
 *
 *   OS X + Chrome  (trackpad)  -    2   pixel delta  (wheelDelta   -6)
 *   OS X + Firefox (trackpad)  -    1   pixel delta  (wheelDelta  N/A)
 *
 * On other/older browsers.. it&#039;s more complicated as there can be multiple and
 * also missing delta values.
 *
 * The &#039;wheel&#039; event is more standard:
 *
 * http://www.w3.org/TR/DOM-Level-3-Events/#events-wheelevents
 *
 * The basics is that it includes a unit, deltaMode (pixels, lines, pages), and
 * deltaX, deltaY and deltaZ.  Some browsers provide other values to maintain
 * backward compatibility with older events.  Those other values help us
 * better normalize spin speed.  Example of what the browsers provide:
 *
 *                          | event.wheelDelta | event.detail
 *        ------------------+------------------+--------------
 *          Safari v5/OS X  |       -120       |       0
 *          Safari v5/Win7  |       -120       |       0
 *         Chrome v17/OS X  |       -120       |       0
 *         Chrome v17/Win7  |       -120       |       0
 *                IE9/Win7  |       -120       |   undefined
 *         Firefox v4/OS X  |     undefined    |       1
 *         Firefox v4/Win7  |     undefined    |       3
 *
 */
function normalizeWheel(/*object*/ event) /*object*/ {
  var sX = 0, sY = 0,       // spinX, spinY
      pX = 0, pY = 0;       // pixelX, pixelY

  // Legacy
  if (&#039;detail&#039;      in event) { sY = event.detail; }
  if (&#039;wheelDelta&#039;  in event) { sY = -event.wheelDelta / 120; }
  if (&#039;wheelDeltaY&#039; in event) { sY = -event.wheelDeltaY / 120; }
  if (&#039;wheelDeltaX&#039; in event) { sX = -event.wheelDeltaX / 120; }

  // side scrolling on FF with DOMMouseScroll
  if ( &#039;axis&#039; in event &amp;&amp; event.axis === event.HORIZONTAL_AXIS ) {
    sX = sY;
    sY = 0;
  }

  pX = sX * PIXEL_STEP;
  pY = sY * PIXEL_STEP;

  if (&#039;deltaY&#039; in event) { pY = event.deltaY; }
  if (&#039;deltaX&#039; in event) { pX = event.deltaX; }

  if ((pX || pY) &amp;&amp; event.deltaMode) {
    if (event.deltaMode == 1) {          // delta in LINE units
      pX *= LINE_HEIGHT;
      pY *= LINE_HEIGHT;
    } else {                             // delta in PAGE units
      pX *= PAGE_HEIGHT;
      pY *= PAGE_HEIGHT;
    }
  }

  // Fall-back if spin cannot be determined
  if (pX &amp;&amp; !sX) { sX = (pX &lt; 1) ? -1 : 1; }
  if (pY &amp;&amp; !sY) { sY = (pY &lt; 1) ? -1 : 1; }

  return { spinX  : sX,
           spinY  : sY,
           pixelX : pX,
           pixelY : pY };
}


/**
 * The best combination if you prefer spinX + spinY normalization.  It favors
 * the older DOMMouseScroll for Firefox, as FF does not include wheelDelta with
 * &#039;wheel&#039; event, making spin speed determination impossible.
 */
normalizeWheel.getEventType = function() /*string*/ {
  return (UserAgent_DEPRECATED.firefox())
           ? &#039;DOMMouseScroll&#039;
           : (isEventSupported(&#039;wheel&#039;))
               ? &#039;wheel&#039;
               : &#039;mousewheel&#039;;
};

module.exports = normalizeWheel;


/***/ }),

/***/ 7374:
/***/ ((module) =&gt; {

&quot;use strict&quot;;


let list = {
  comma(string) {
    return list.split(string, [&#039;,&#039;], true)
  },

  space(string) {
    let spaces = [&#039; &#039;, &#039;\n&#039;, &#039;\t&#039;]
    return list.split(string, spaces)
  },

  split(string, separators, last) {
    let array = []
    let current = &#039;&#039;
    let split = false

    let func = 0
    let inQuote = false
    let prevQuote = &#039;&#039;
    let escape = false

    for (let letter of string) {
      if (escape) {
        escape = false
      } else if (letter === &#039;\\&#039;) {
        escape = true
      } else if (inQuote) {
        if (letter === prevQuote) {
          inQuote = false
        }
      } else if (letter === &#039;&quot;&#039; || letter === &quot;&#039;&quot;) {
        inQuote = true
        prevQuote = letter
      } else if (letter === &#039;(&#039;) {
        func += 1
      } else if (letter === &#039;)&#039;) {
        if (func &gt; 0) func -= 1
      } else if (func === 0) {
        if (separators.includes(letter)) split = true
      }

      if (split) {
        if (current !== &#039;&#039;) array.push(current.trim())
        current = &#039;&#039;
        split = false
      } else {
        current += letter
      }
    }

    if (last || current !== &#039;&#039;) array.push(current.trim())
    return array
  }
}

module.exports = list
list.default = list


/***/ }),

/***/ 7490:
/***/ ((module, __unused_webpack_exports, __webpack_require__) =&gt; {

&quot;use strict&quot;;


let CssSyntaxError = __webpack_require__(356)
let Stringifier = __webpack_require__(346)
let stringify = __webpack_require__(633)
let { isClean, my } = __webpack_require__(1381)

function cloneNode(obj, parent) {
  let cloned = new obj.constructor()

  for (let i in obj) {
    if (!Object.prototype.hasOwnProperty.call(obj, i)) {
      /* c8 ignore next 2 */
      continue
    }
    if (i === &#039;proxyCache&#039;) continue
    let value = obj[i]
    let type = typeof value

    if (i === &#039;parent&#039; &amp;&amp; type === &#039;object&#039;) {
      if (parent) cloned[i] = parent
    } else if (i === &#039;source&#039;) {
      cloned[i] = value
    } else if (Array.isArray(value)) {
      cloned[i] = value.map(j =&gt; cloneNode(j, cloned))
    } else {
      if (type === &#039;object&#039; &amp;&amp; value !== null) value = cloneNode(value)
      cloned[i] = value
    }
  }

  return cloned
}

function sourceOffset(inputCSS, position) {
  // Not all custom syntaxes support `offset` in `source.start` and `source.end`
  if (
    position &amp;&amp;
    typeof position.offset !== &#039;undefined&#039;
  ) {
    return position.offset;
  }

  let column = 1
  let line = 1
  let offset = 0

  for (let i = 0; i &lt; inputCSS.length; i++) {
    if (line === position.line &amp;&amp; column === position.column) {
      offset = i
      break
    }

    if (inputCSS[i] === &#039;\n&#039;) {
      column = 1
      line += 1
    } else {
      column += 1
    }
  }

  return offset
}

class Node {
  get proxyOf() {
    return this
  }

  constructor(defaults = {}) {
    this.raws = {}
    this[isClean] = false
    this[my] = true

    for (let name in defaults) {
      if (name === &#039;nodes&#039;) {
        this.nodes = []
        for (let node of defaults[name]) {
          if (typeof node.clone === &#039;function&#039;) {
            this.append(node.clone())
          } else {
            this.append(node)
          }
        }
      } else {
        this[name] = defaults[name]
      }
    }
  }

  addToError(error) {
    error.postcssNode = this
    if (error.stack &amp;&amp; this.source &amp;&amp; /\n\s{4}at /.test(error.stack)) {
      let s = this.source
      error.stack = error.stack.replace(
        /\n\s{4}at /,
        `$&amp;${s.input.from}:${s.start.line}:${s.start.column}$&amp;`
      )
    }
    return error
  }

  after(add) {
    this.parent.insertAfter(this, add)
    return this
  }

  assign(overrides = {}) {
    for (let name in overrides) {
      this[name] = overrides[name]
    }
    return this
  }

  before(add) {
    this.parent.insertBefore(this, add)
    return this
  }

  cleanRaws(keepBetween) {
    delete this.raws.before
    delete this.raws.after
    if (!keepBetween) delete this.raws.between
  }

  clone(overrides = {}) {
    let cloned = cloneNode(this)
    for (let name in overrides) {
      cloned[name] = overrides[name]
    }
    return cloned
  }

  cloneAfter(overrides = {}) {
    let cloned = this.clone(overrides)
    this.parent.insertAfter(this, cloned)
    return cloned
  }

  cloneBefore(overrides = {}) {
    let cloned = this.clone(overrides)
    this.parent.insertBefore(this, cloned)
    return cloned
  }

  error(message, opts = {}) {
    if (this.source) {
      let { end, start } = this.rangeBy(opts)
      return this.source.input.error(
        message,
        { column: start.column, line: start.line },
        { column: end.column, line: end.line },
        opts
      )
    }
    return new CssSyntaxError(message)
  }

  getProxyProcessor() {
    return {
      get(node, prop) {
        if (prop === &#039;proxyOf&#039;) {
          return node
        } else if (prop === &#039;root&#039;) {
          return () =&gt; node.root().toProxy()
        } else {
          return node[prop]
        }
      },

      set(node, prop, value) {
        if (node[prop] === value) return true
        node[prop] = value
        if (
          prop === &#039;prop&#039; ||
          prop === &#039;value&#039; ||
          prop === &#039;name&#039; ||
          prop === &#039;params&#039; ||
          prop === &#039;important&#039; ||
          /* c8 ignore next */
          prop === &#039;text&#039;
        ) {
          node.markDirty()
        }
        return true
      }
    }
  }

  /* c8 ignore next 3 */
  markClean() {
    this[isClean] = true
  }

  markDirty() {
    if (this[isClean]) {
      this[isClean] = false
      let next = this
      while ((next = next.parent)) {
        next[isClean] = false
      }
    }
  }

  next() {
    if (!this.parent) return undefined
    let index = this.parent.index(this)
    return this.parent.nodes[index + 1]
  }

  positionBy(opts) {
    let pos = this.source.start
    if (opts.index) {
      pos = this.positionInside(opts.index)
    } else if (opts.word) {
      let inputString = (&#039;document&#039; in this.source.input)
        ? this.source.input.document
        : this.source.input.css
      let stringRepresentation = inputString.slice(
        sourceOffset(inputString, this.source.start),
        sourceOffset(inputString, this.source.end)
      )
      let index = stringRepresentation.indexOf(opts.word)
      if (index !== -1) pos = this.positionInside(index)
    }
    return pos
  }

  positionInside(index) {
    let column = this.source.start.column
    let line = this.source.start.line
    let inputString = (&#039;document&#039; in this.source.input)
      ? this.source.input.document
      : this.source.input.css
    let offset = sourceOffset(inputString, this.source.start)
    let end = offset + index

    for (let i = offset; i &lt; end; i++) {
      if (inputString[i] === &#039;\n&#039;) {
        column = 1
        line += 1
      } else {
        column += 1
      }
    }

    return { column, line }
  }

  prev() {
    if (!this.parent) return undefined
    let index = this.parent.index(this)
    return this.parent.nodes[index - 1]
  }

  rangeBy(opts) {
    let start = {
      column: this.source.start.column,
      line: this.source.start.line
    }
    let end = this.source.end
      ? {
          column: this.source.end.column + 1,
          line: this.source.end.line
        }
      : {
          column: start.column + 1,
          line: start.line
        }

    if (opts.word) {
      let inputString = (&#039;document&#039; in this.source.input)
        ? this.source.input.document
        : this.source.input.css
      let stringRepresentation = inputString.slice(
        sourceOffset(inputString, this.source.start),
        sourceOffset(inputString, this.source.end)
      )
      let index = stringRepresentation.indexOf(opts.word)
      if (index !== -1) {
        start = this.positionInside(index)
        end = this.positionInside(
          index + opts.word.length,
        )
      }
    } else {
      if (opts.start) {
        start = {
          column: opts.start.column,
          line: opts.start.line
        }
      } else if (opts.index) {
        start = this.positionInside(opts.index)
      }

      if (opts.end) {
        end = {
          column: opts.end.column,
          line: opts.end.line
        }
      } else if (typeof opts.endIndex === &#039;number&#039;) {
        end = this.positionInside(opts.endIndex)
      } else if (opts.index) {
        end = this.positionInside(opts.index + 1)
      }
    }

    if (
      end.line &lt; start.line ||
      (end.line === start.line &amp;&amp; end.column &lt;= start.column)
    ) {
      end = { column: start.column + 1, line: start.line }
    }

    return { end, start }
  }

  raw(prop, defaultType) {
    let str = new Stringifier()
    return str.raw(this, prop, defaultType)
  }

  remove() {
    if (this.parent) {
      this.parent.removeChild(this)
    }
    this.parent = undefined
    return this
  }

  replaceWith(...nodes) {
    if (this.parent) {
      let bookmark = this
      let foundSelf = false
      for (let node of nodes) {
        if (node === this) {
          foundSelf = true
        } else if (foundSelf) {
          this.parent.insertAfter(bookmark, node)
          bookmark = node
        } else {
          this.parent.insertBefore(bookmark, node)
        }
      }

      if (!foundSelf) {
        this.remove()
      }
    }

    return this
  }

  root() {
    let result = this
    while (result.parent &amp;&amp; result.parent.type !== &#039;document&#039;) {
      result = result.parent
    }
    return result
  }

  toJSON(_, inputs) {
    let fixed = {}
    let emitInputs = inputs == null
    inputs = inputs || new Map()
    let inputsNextIndex = 0

    for (let name in this) {
      if (!Object.prototype.hasOwnProperty.call(this, name)) {
        /* c8 ignore next 2 */
        continue
      }
      if (name === &#039;parent&#039; || name === &#039;proxyCache&#039;) continue
      let value = this[name]

      if (Array.isArray(value)) {
        fixed[name] = value.map(i =&gt; {
          if (typeof i === &#039;object&#039; &amp;&amp; i.toJSON) {
            return i.toJSON(null, inputs)
          } else {
            return i
          }
        })
      } else if (typeof value === &#039;object&#039; &amp;&amp; value.toJSON) {
        fixed[name] = value.toJSON(null, inputs)
      } else if (name === &#039;source&#039;) {
        let inputId = inputs.get(value.input)
        if (inputId == null) {
          inputId = inputsNextIndex
          inputs.set(value.input, inputsNextIndex)
          inputsNextIndex++
        }
        fixed[name] = {
          end: value.end,
          inputId,
          start: value.start
        }
      } else {
        fixed[name] = value
      }
    }

    if (emitInputs) {
      fixed.inputs = [...inputs.keys()].map(input =&gt; input.toJSON())
    }

    return fixed
  }

  toProxy() {
    if (!this.proxyCache) {
      this.proxyCache = new Proxy(this, this.getProxyProcessor())
    }
    return this.proxyCache
  }

  toString(stringifier = stringify) {
    if (stringifier.stringify) stringifier = stringifier.stringify
    let result = &#039;&#039;
    stringifier(this, i =&gt; {
      result += i
    })
    return result
  }

  warn(result, text, opts) {
    let data = { node: this }
    for (let i in opts) data[i] = opts[i]
    return result.warn(text, data)
  }
}

module.exports = Node
Node.default = Node


/***/ }),

/***/ 7520:
/***/ ((module, __unused_webpack_exports, __webpack_require__) =&gt; {

module.exports = __webpack_require__(7191);


/***/ }),

/***/ 7661:
/***/ ((module, __unused_webpack_exports, __webpack_require__) =&gt; {

&quot;use strict&quot;;


let MapGenerator = __webpack_require__(1670)
let parse = __webpack_require__(4295)
const Result = __webpack_require__(9055)
let stringify = __webpack_require__(633)
let warnOnce = __webpack_require__(3122)

class NoWorkResult {
  get content() {
    return this.result.css
  }

  get css() {
    return this.result.css
  }

  get map() {
    return this.result.map
  }

  get messages() {
    return []
  }

  get opts() {
    return this.result.opts
  }

  get processor() {
    return this.result.processor
  }

  get root() {
    if (this._root) {
      return this._root
    }

    let root
    let parser = parse

    try {
      root = parser(this._css, this._opts)
    } catch (error) {
      this.error = error
    }

    if (this.error) {
      throw this.error
    } else {
      this._root = root
      return root
    }
  }

  get [Symbol.toStringTag]() {
    return &#039;NoWorkResult&#039;
  }

  constructor(processor, css, opts) {
    css = css.toString()
    this.stringified = false

    this._processor = processor
    this._css = css
    this._opts = opts
    this._map = undefined
    let root

    let str = stringify
    this.result = new Result(this._processor, root, this._opts)
    this.result.css = css

    let self = this
    Object.defineProperty(this.result, &#039;root&#039;, {
      get() {
        return self.root
      }
    })

    let map = new MapGenerator(str, root, this._opts, css)
    if (map.isMap()) {
      let [generatedCSS, generatedMap] = map.generate()
      if (generatedCSS) {
        this.result.css = generatedCSS
      }
      if (generatedMap) {
        this.result.map = generatedMap
      }
    } else {
      map.clearAnnotation()
      this.result.css = map.css
    }
  }

  async() {
    if (this.error) return Promise.reject(this.error)
    return Promise.resolve(this.result)
  }

  catch(onRejected) {
    return this.async().catch(onRejected)
  }

  finally(onFinally) {
    return this.async().then(onFinally, onFinally)
  }

  sync() {
    if (this.error) throw this.error
    return this.result
  }

  then(onFulfilled, onRejected) {
    if (false) {}

    return this.async().then(onFulfilled, onRejected)
  }

  toString() {
    return this._css
  }

  warnings() {
    return []
  }
}

module.exports = NoWorkResult
NoWorkResult.default = NoWorkResult


/***/ }),

/***/ 7734:
/***/ ((module) =&gt; {

&quot;use strict&quot;;


// do not edit .js files directly - edit src/index.jst


  var envHasBigInt64Array = typeof BigInt64Array !== &#039;undefined&#039;;


module.exports = function equal(a, b) {
  if (a === b) return true;

  if (a &amp;&amp; b &amp;&amp; typeof a == &#039;object&#039; &amp;&amp; typeof b == &#039;object&#039;) {
    if (a.constructor !== b.constructor) return false;

    var length, i, keys;
    if (Array.isArray(a)) {
      length = a.length;
      if (length != b.length) return false;
      for (i = length; i-- !== 0;)
        if (!equal(a[i], b[i])) return false;
      return true;
    }


    if ((a instanceof Map) &amp;&amp; (b instanceof Map)) {
      if (a.size !== b.size) return false;
      for (i of a.entries())
        if (!b.has(i[0])) return false;
      for (i of a.entries())
        if (!equal(i[1], b.get(i[0]))) return false;
      return true;
    }

    if ((a instanceof Set) &amp;&amp; (b instanceof Set)) {
      if (a.size !== b.size) return false;
      for (i of a.entries())
        if (!b.has(i[0])) return false;
      return true;
    }

    if (ArrayBuffer.isView(a) &amp;&amp; ArrayBuffer.isView(b)) {
      length = a.length;
      if (length != b.length) return false;
      for (i = length; i-- !== 0;)
        if (a[i] !== b[i]) return false;
      return true;
    }


    if (a.constructor === RegExp) return a.source === b.source &amp;&amp; a.flags === b.flags;
    if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf();
    if (a.toString !== Object.prototype.toString) return a.toString() === b.toString();

    keys = Object.keys(a);
    length = keys.length;
    if (length !== Object.keys(b).length) return false;

    for (i = length; i-- !== 0;)
      if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;

    for (i = length; i-- !== 0;) {
      var key = keys[i];

      if (!equal(a[key], b[key])) return false;
    }

    return true;
  }

  // true if both NaN, false otherwise
  return a!==a &amp;&amp; b!==b;
};


/***/ }),

/***/ 8021:
/***/ ((__unused_webpack_module, exports, __webpack_require__) =&gt; {

&quot;use strict&quot;;
var __webpack_unused_export__;
/*istanbul ignore start*/


__webpack_unused_export__ = ({
  value: true
});
exports.JJ = diffChars;
__webpack_unused_export__ = void 0;

/*istanbul ignore end*/
var
/*istanbul ignore start*/
_base = _interopRequireDefault(__webpack_require__(5417))
/*istanbul ignore end*/
;

/*istanbul ignore start*/ function _interopRequireDefault(obj) { return obj &amp;&amp; obj.__esModule ? obj : { default: obj }; }

/*istanbul ignore end*/
var characterDiff = new
/*istanbul ignore start*/
_base
/*istanbul ignore end*/
.
/*istanbul ignore start*/
default
/*istanbul ignore end*/
();

/*istanbul ignore start*/
__webpack_unused_export__ = characterDiff;

/*istanbul ignore end*/
function diffChars(oldStr, newStr, options) {
  return characterDiff.diff(oldStr, newStr, options);
}


/***/ }),

/***/ 8202:
/***/ ((module) =&gt; {

&quot;use strict&quot;;
/**
 * Copyright (c) 2015, Facebook, Inc.
 * All rights reserved.
 *
 * This source code is licensed under the BSD-style license found in the
 * LICENSE file in the root directory of this source tree. An additional grant
 * of patent rights can be found in the PATENTS file in the same directory.
 *
 * @providesModule ExecutionEnvironment
 */

/*jslint evil: true */



var canUseDOM = !!(
  typeof window !== &#039;undefined&#039; &amp;&amp;
  window.document &amp;&amp;
  window.document.createElement
);

/**
 * Simple, lightweight module assisting with the detection and context of
 * Worker. Helps avoid circular dependencies and allows code to reason about
 * whether or not they are in a Worker, even if they never include the main
 * `ReactWorker` dependency.
 */
var ExecutionEnvironment = {

  canUseDOM: canUseDOM,

  canUseWorkers: typeof Worker !== &#039;undefined&#039;,

  canUseEventListeners:
    canUseDOM &amp;&amp; !!(window.addEventListener || window.attachEvent),

  canUseViewport: canUseDOM &amp;&amp; !!window.screen,

  isInWorker: !canUseDOM // For now, this is true - might change in the future.

};

module.exports = ExecutionEnvironment;


/***/ }),

/***/ 8491:
/***/ ((module) =&gt; {

var openParentheses = &quot;(&quot;.charCodeAt(0);
var closeParentheses = &quot;)&quot;.charCodeAt(0);
var singleQuote = &quot;&#039;&quot;.charCodeAt(0);
var doubleQuote = &#039;&quot;&#039;.charCodeAt(0);
var backslash = &quot;\\&quot;.charCodeAt(0);
var slash = &quot;/&quot;.charCodeAt(0);
var comma = &quot;,&quot;.charCodeAt(0);
var colon = &quot;:&quot;.charCodeAt(0);
var star = &quot;*&quot;.charCodeAt(0);
var uLower = &quot;u&quot;.charCodeAt(0);
var uUpper = &quot;U&quot;.charCodeAt(0);
var plus = &quot;+&quot;.charCodeAt(0);
var isUnicodeRange = /^[a-f0-9?-]+$/i;

module.exports = function(input) {
  var tokens = [];
  var value = input;

  var next,
    quote,
    prev,
    token,
    escape,
    escapePos,
    whitespacePos,
    parenthesesOpenPos;
  var pos = 0;
  var code = value.charCodeAt(pos);
  var max = value.length;
  var stack = [{ nodes: tokens }];
  var balanced = 0;
  var parent;

  var name = &quot;&quot;;
  var before = &quot;&quot;;
  var after = &quot;&quot;;

  while (pos &lt; max) {
    // Whitespaces
    if (code &lt;= 32) {
      next = pos;
      do {
        next += 1;
        code = value.charCodeAt(next);
      } while (code &lt;= 32);
      token = value.slice(pos, next);

      prev = tokens[tokens.length - 1];
      if (code === closeParentheses &amp;&amp; balanced) {
        after = token;
      } else if (prev &amp;&amp; prev.type === &quot;div&quot;) {
        prev.after = token;
        prev.sourceEndIndex += token.length;
      } else if (
        code === comma ||
        code === colon ||
        (code === slash &amp;&amp;
          value.charCodeAt(next + 1) !== star &amp;&amp;
          (!parent ||
            (parent &amp;&amp; parent.type === &quot;function&quot; &amp;&amp; parent.value !== &quot;calc&quot;)))
      ) {
        before = token;
      } else {
        tokens.push({
          type: &quot;space&quot;,
          sourceIndex: pos,
          sourceEndIndex: next,
          value: token
        });
      }

      pos = next;

      // Quotes
    } else if (code === singleQuote || code === doubleQuote) {
      next = pos;
      quote = code === singleQuote ? &quot;&#039;&quot; : &#039;&quot;&#039;;
      token = {
        type: &quot;string&quot;,
        sourceIndex: pos,
        quote: quote
      };
      do {
        escape = false;
        next = value.indexOf(quote, next + 1);
        if (~next) {
          escapePos = next;
          while (value.charCodeAt(escapePos - 1) === backslash) {
            escapePos -= 1;
            escape = !escape;
          }
        } else {
          value += quote;
          next = value.length - 1;
          token.unclosed = true;
        }
      } while (escape);
      token.value = value.slice(pos + 1, next);
      token.sourceEndIndex = token.unclosed ? next : next + 1;
      tokens.push(token);
      pos = next + 1;
      code = value.charCodeAt(pos);

      // Comments
    } else if (code === slash &amp;&amp; value.charCodeAt(pos + 1) === star) {
      next = value.indexOf(&quot;*/&quot;, pos);

      token = {
        type: &quot;comment&quot;,
        sourceIndex: pos,
        sourceEndIndex: next + 2
      };

      if (next === -1) {
        token.unclosed = true;
        next = value.length;
        token.sourceEndIndex = next;
      }

      token.value = value.slice(pos + 2, next);
      tokens.push(token);

      pos = next + 2;
      code = value.charCodeAt(pos);

      // Operation within calc
    } else if (
      (code === slash || code === star) &amp;&amp;
      parent &amp;&amp;
      parent.type === &quot;function&quot; &amp;&amp;
      parent.value === &quot;calc&quot;
    ) {
      token = value[pos];
      tokens.push({
        type: &quot;word&quot;,
        sourceIndex: pos - before.length,
        sourceEndIndex: pos + token.length,
        value: token
      });
      pos += 1;
      code = value.charCodeAt(pos);

      // Dividers
    } else if (code === slash || code === comma || code === colon) {
      token = value[pos];

      tokens.push({
        type: &quot;div&quot;,
        sourceIndex: pos - before.length,
        sourceEndIndex: pos + token.length,
        value: token,
        before: before,
        after: &quot;&quot;
      });
      before = &quot;&quot;;

      pos += 1;
      code = value.charCodeAt(pos);

      // Open parentheses
    } else if (openParentheses === code) {
      // Whitespaces after open parentheses
      next = pos;
      do {
        next += 1;
        code = value.charCodeAt(next);
      } while (code &lt;= 32);
      parenthesesOpenPos = pos;
      token = {
        type: &quot;function&quot;,
        sourceIndex: pos - name.length,
        value: name,
        before: value.slice(parenthesesOpenPos + 1, next)
      };
      pos = next;

      if (name === &quot;url&quot; &amp;&amp; code !== singleQuote &amp;&amp; code !== doubleQuote) {
        next -= 1;
        do {
          escape = false;
          next = value.indexOf(&quot;)&quot;, next + 1);
          if (~next) {
            escapePos = next;
            while (value.charCodeAt(escapePos - 1) === backslash) {
              escapePos -= 1;
              escape = !escape;
            }
          } else {
            value += &quot;)&quot;;
            next = value.length - 1;
            token.unclosed = true;
          }
        } while (escape);
        // Whitespaces before closed
        whitespacePos = next;
        do {
          whitespacePos -= 1;
          code = value.charCodeAt(whitespacePos);
        } while (code &lt;= 32);
        if (parenthesesOpenPos &lt; whitespacePos) {
          if (pos !== whitespacePos + 1) {
            token.nodes = [
              {
                type: &quot;word&quot;,
                sourceIndex: pos,
                sourceEndIndex: whitespacePos + 1,
                value: value.slice(pos, whitespacePos + 1)
              }
            ];
          } else {
            token.nodes = [];
          }
          if (token.unclosed &amp;&amp; whitespacePos + 1 !== next) {
            token.after = &quot;&quot;;
            token.nodes.push({
              type: &quot;space&quot;,
              sourceIndex: whitespacePos + 1,
              sourceEndIndex: next,
              value: value.slice(whitespacePos + 1, next)
            });
          } else {
            token.after = value.slice(whitespacePos + 1, next);
            token.sourceEndIndex = next;
          }
        } else {
          token.after = &quot;&quot;;
          token.nodes = [];
        }
        pos = next + 1;
        token.sourceEndIndex = token.unclosed ? next : pos;
        code = value.charCodeAt(pos);
        tokens.push(token);
      } else {
        balanced += 1;
        token.after = &quot;&quot;;
        token.sourceEndIndex = pos + 1;
        tokens.push(token);
        stack.push(token);
        tokens = token.nodes = [];
        parent = token;
      }
      name = &quot;&quot;;

      // Close parentheses
    } else if (closeParentheses === code &amp;&amp; balanced) {
      pos += 1;
      code = value.charCodeAt(pos);

      parent.after = after;
      parent.sourceEndIndex += after.length;
      after = &quot;&quot;;
      balanced -= 1;
      stack[stack.length - 1].sourceEndIndex = pos;
      stack.pop();
      parent = stack[balanced];
      tokens = parent.nodes;

      // Words
    } else {
      next = pos;
      do {
        if (code === backslash) {
          next += 1;
        }
        next += 1;
        code = value.charCodeAt(next);
      } while (
        next &lt; max &amp;&amp;
        !(
          code &lt;= 32 ||
          code === singleQuote ||
          code === doubleQuote ||
          code === comma ||
          code === colon ||
          code === slash ||
          code === openParentheses ||
          (code === star &amp;&amp;
            parent &amp;&amp;
            parent.type === &quot;function&quot; &amp;&amp;
            parent.value === &quot;calc&quot;) ||
          (code === slash &amp;&amp;
            parent.type === &quot;function&quot; &amp;&amp;
            parent.value === &quot;calc&quot;) ||
          (code === closeParentheses &amp;&amp; balanced)
        )
      );
      token = value.slice(pos, next);

      if (openParentheses === code) {
        name = token;
      } else if (
        (uLower === token.charCodeAt(0) || uUpper === token.charCodeAt(0)) &amp;&amp;
        plus === token.charCodeAt(1) &amp;&amp;
        isUnicodeRange.test(token.slice(2))
      ) {
        tokens.push({
          type: &quot;unicode-range&quot;,
          sourceIndex: pos,
          sourceEndIndex: next,
          value: token
        });
      } else {
        tokens.push({
          type: &quot;word&quot;,
          sourceIndex: pos,
          sourceEndIndex: next,
          value: token
        });
      }

      pos = next;
    }
  }

  for (pos = stack.length - 1; pos; pos -= 1) {
    stack[pos].unclosed = true;
    stack[pos].sourceEndIndex = value.length;
  }

  return stack[0].nodes;
};


/***/ }),

/***/ 9055:
/***/ ((module, __unused_webpack_exports, __webpack_require__) =&gt; {

&quot;use strict&quot;;


let Warning = __webpack_require__(5776)

class Result {
  get content() {
    return this.css
  }

  constructor(processor, root, opts) {
    this.processor = processor
    this.messages = []
    this.root = root
    this.opts = opts
    this.css = undefined
    this.map = undefined
  }

  toString() {
    return this.css
  }

  warn(text, opts = {}) {
    if (!opts.plugin) {
      if (this.lastPlugin &amp;&amp; this.lastPlugin.postcssPlugin) {
        opts.plugin = this.lastPlugin.postcssPlugin
      }
    }

    let warning = new Warning(text, opts)
    this.messages.push(warning)

    return warning
  }

  warnings() {
    return this.messages.filter(i =&gt; i.type === &#039;warning&#039;)
  }
}

module.exports = Result
Result.default = Result


/***/ }),

/***/ 9434:
/***/ ((module, __unused_webpack_exports, __webpack_require__) =&gt; {

&quot;use strict&quot;;


let Container = __webpack_require__(683)

let LazyResult, Processor

class Root extends Container {
  constructor(defaults) {
    super(defaults)
    this.type = &#039;root&#039;
    if (!this.nodes) this.nodes = []
  }

  normalize(child, sample, type) {
    let nodes = super.normalize(child)

    if (sample) {
      if (type === &#039;prepend&#039;) {
        if (this.nodes.length &gt; 1) {
          sample.raws.before = this.nodes[1].raws.before
        } else {
          delete sample.raws.before
        }
      } else if (this.first !== sample) {
        for (let node of nodes) {
          node.raws.before = sample.raws.before
        }
      }
    }

    return nodes
  }

  removeChild(child, ignore) {
    let index = this.index(child)

    if (!ignore &amp;&amp; index === 0 &amp;&amp; this.nodes.length &gt; 1) {
      this.nodes[1].raws.before = this.nodes[index].raws.before
    }

    return super.removeChild(child)
  }

  toResult(opts = {}) {
    let lazy = new LazyResult(new Processor(), this, opts)
    return lazy.stringify()
  }
}

Root.registerLazyResult = dependant =&gt; {
  LazyResult = dependant
}

Root.registerProcessor = dependant =&gt; {
  Processor = dependant
}

module.exports = Root
Root.default = Root

Container.registerRoot(Root)


/***/ }),

/***/ 9656:
/***/ ((module, __unused_webpack_exports, __webpack_require__) =&gt; {

&quot;use strict&quot;;


let Document = __webpack_require__(271)
let LazyResult = __webpack_require__(448)
let NoWorkResult = __webpack_require__(7661)
let Root = __webpack_require__(9434)

class Processor {
  constructor(plugins = []) {
    this.version = &#039;8.5.3&#039;
    this.plugins = this.normalize(plugins)
  }

  normalize(plugins) {
    let normalized = []
    for (let i of plugins) {
      if (i.postcss === true) {
        i = i()
      } else if (i.postcss) {
        i = i.postcss
      }

      if (typeof i === &#039;object&#039; &amp;&amp; Array.isArray(i.plugins)) {
        normalized = normalized.concat(i.plugins)
      } else if (typeof i === &#039;object&#039; &amp;&amp; i.postcssPlugin) {
        normalized.push(i)
      } else if (typeof i === &#039;function&#039;) {
        normalized.push(i)
      } else if (typeof i === &#039;object&#039; &amp;&amp; (i.parse || i.stringify)) {
        if (false) {}
      } else {
        throw new Error(i + &#039; is not a PostCSS plugin&#039;)
      }
    }
    return normalized
  }

  process(css, opts = {}) {
    if (
      !this.plugins.length &amp;&amp;
      !opts.parser &amp;&amp;
      !opts.stringifier &amp;&amp;
      !opts.syntax
    ) {
      return new NoWorkResult(this, css, opts)
    } else {
      return new LazyResult(this, css, opts)
    }
  }

  use(plugin) {
    this.plugins = this.plugins.concat(this.normalize([plugin]))
    return this
  }
}

module.exports = Processor
Processor.default = Processor

Root.registerProcessor(Processor)
Document.registerProcessor(Processor)


/***/ }),

/***/ 9681:
/***/ ((module) =&gt; {

var characterMap = {
	&quot;�€&quot;: &quot;A&quot;,
	&quot;�&quot;: &quot;A&quot;,
	&quot;�‚&quot;: &quot;A&quot;,
	&quot;�ƒ&quot;: &quot;A&quot;,
	&quot;�„&quot;: &quot;A&quot;,
	&quot;�…&quot;: &quot;A&quot;,
	&quot;Ấ&quot;: &quot;A&quot;,
	&quot;�&quot;: &quot;A&quot;,
	&quot;áş²&quot;: &quot;A&quot;,
	&quot;áş´&quot;: &quot;A&quot;,
	&quot;áşĥ&quot;: &quot;A&quot;,
	&quot;�†&quot;: &quot;AE&quot;,
	&quot;áşĤ&quot;: &quot;A&quot;,
	&quot;áş°&quot;: &quot;A&quot;,
	&quot;Ȃ&quot;: &quot;A&quot;,
	&quot;Ả&quot;: &quot;A&quot;,
	&quot;áş &quot;: &quot;A&quot;,
	&quot;Ẩ&quot;: &quot;A&quot;,
	&quot;Ẫ&quot;: &quot;A&quot;,
	&quot;áşĴ&quot;: &quot;A&quot;,
	&quot;�‡&quot;: &quot;C&quot;,
	&quot;Ḉ&quot;: &quot;C&quot;,
	&quot;�ˆ&quot;: &quot;E&quot;,
	&quot;�‰&quot;: &quot;E&quot;,
	&quot;�Š&quot;: &quot;E&quot;,
	&quot;�‹&quot;: &quot;E&quot;,
	&quot;�&quot;: &quot;E&quot;,
	&quot;Ḗ&quot;: &quot;E&quot;,
	&quot;áğ€&quot;: &quot;E&quot;,
	&quot;Ḕ&quot;: &quot;E&quot;,
	&quot;Ḝ&quot;: &quot;E&quot;,
	&quot;Ȇ&quot;: &quot;E&quot;,
	&quot;áşş&quot;: &quot;E&quot;,
	&quot;áşĵ&quot;: &quot;E&quot;,
	&quot;Ẹ&quot;: &quot;E&quot;,
	&quot;áğ‚&quot;: &quot;E&quot;,
	&quot;áğ„&quot;: &quot;E&quot;,
	&quot;áğ†&quot;: &quot;E&quot;,
	&quot;�Œ&quot;: &quot;I&quot;,
	&quot;�&quot;: &quot;I&quot;,
	&quot;�Ž&quot;: &quot;I&quot;,
	&quot;�&quot;: &quot;I&quot;,
	&quot;�&quot;: &quot;I&quot;,
	&quot;Ȋ&quot;: &quot;I&quot;,
	&quot;áğˆ&quot;: &quot;I&quot;,
	&quot;áğŠ&quot;: &quot;I&quot;,
	&quot;�&quot;: &quot;D&quot;,
	&quot;�‘&quot;: &quot;N&quot;,
	&quot;�’&quot;: &quot;O&quot;,
	&quot;�“&quot;: &quot;O&quot;,
	&quot;�”&quot;: &quot;O&quot;,
	&quot;�•&quot;: &quot;O&quot;,
	&quot;�–&quot;: &quot;O&quot;,
	&quot;�˜&quot;: &quot;O&quot;,
	&quot;áğ&quot;: &quot;O&quot;,
	&quot;áıŒ&quot;: &quot;O&quot;,
	&quot;áı’&quot;: &quot;O&quot;,
	&quot;Ȏ&quot;: &quot;O&quot;,
	&quot;áğŽ&quot;: &quot;O&quot;,
	&quot;áğŒ&quot;: &quot;O&quot;,
	&quot;áğ”&quot;: &quot;O&quot;,
	&quot;áğ–&quot;: &quot;O&quot;,
	&quot;áğ˜&quot;: &quot;O&quot;,
	&quot;áğœ&quot;: &quot;O&quot;,
	&quot;áğž&quot;: &quot;O&quot;,
	&quot;áğ &quot;: &quot;O&quot;,
	&quot;áğš&quot;: &quot;O&quot;,
	&quot;áğ˘&quot;: &quot;O&quot;,
	&quot;�™&quot;: &quot;U&quot;,
	&quot;�š&quot;: &quot;U&quot;,
	&quot;�›&quot;: &quot;U&quot;,
	&quot;�œ&quot;: &quot;U&quot;,
	&quot;áğĤ&quot;: &quot;U&quot;,
	&quot;áğ¤&quot;: &quot;U&quot;,
	&quot;áğĴ&quot;: &quot;U&quot;,
	&quot;áğ�&quot;: &quot;U&quot;,
	&quot;áğ°&quot;: &quot;U&quot;,
	&quot;�&quot;: &quot;Y&quot;,
	&quot;� &quot;: &quot;a&quot;,
	&quot;�Ħ&quot;: &quot;a&quot;,
	&quot;�˘&quot;: &quot;a&quot;,
	&quot;�£&quot;: &quot;a&quot;,
	&quot;�¤&quot;: &quot;a&quot;,
	&quot;��&quot;: &quot;a&quot;,
	&quot;�&quot;: &quot;a&quot;,
	&quot;ắ&quot;: &quot;a&quot;,
	&quot;áş³&quot;: &quot;a&quot;,
	&quot;áşµ&quot;: &quot;a&quot;,
	&quot;áş·&quot;: &quot;a&quot;,
	&quot;�Ĥ&quot;: &quot;ae&quot;,
	&quot;ầ&quot;: &quot;a&quot;,
	&quot;áşħ&quot;: &quot;a&quot;,
	&quot;ȃ&quot;: &quot;a&quot;,
	&quot;áş£&quot;: &quot;a&quot;,
	&quot;áşĦ&quot;: &quot;a&quot;,
	&quot;áşİ&quot;: &quot;a&quot;,
	&quot;áşĞ&quot;: &quot;a&quot;,
	&quot;áş­&quot;: &quot;a&quot;,
	&quot;�§&quot;: &quot;c&quot;,
	&quot;ḉ&quot;: &quot;c&quot;,
	&quot;�¨&quot;: &quot;e&quot;,
	&quot;�İ&quot;: &quot;e&quot;,
	&quot;�Ş&quot;: &quot;e&quot;,
	&quot;�Ğ&quot;: &quot;e&quot;,
	&quot;áşż&quot;: &quot;e&quot;,
	&quot;ḗ&quot;: &quot;e&quot;,
	&quot;áğ&quot;: &quot;e&quot;,
	&quot;ḕ&quot;: &quot;e&quot;,
	&quot;ḝ&quot;: &quot;e&quot;,
	&quot;ȇ&quot;: &quot;e&quot;,
	&quot;áşğ&quot;: &quot;e&quot;,
	&quot;áş½&quot;: &quot;e&quot;,
	&quot;áşı&quot;: &quot;e&quot;,
	&quot;áğƒ&quot;: &quot;e&quot;,
	&quot;áğ…&quot;: &quot;e&quot;,
	&quot;áğ‡&quot;: &quot;e&quot;,
	&quot;�Ĵ&quot;: &quot;i&quot;,
	&quot;�­&quot;: &quot;i&quot;,
	&quot;��&quot;: &quot;i&quot;,
	&quot;�Ż&quot;: &quot;i&quot;,
	&quot;ḯ&quot;: &quot;i&quot;,
	&quot;ȋ&quot;: &quot;i&quot;,
	&quot;áğ‰&quot;: &quot;i&quot;,
	&quot;áğ‹&quot;: &quot;i&quot;,
	&quot;�°&quot;: &quot;d&quot;,
	&quot;�ħ&quot;: &quot;n&quot;,
	&quot;�²&quot;: &quot;o&quot;,
	&quot;�³&quot;: &quot;o&quot;,
	&quot;�´&quot;: &quot;o&quot;,
	&quot;�µ&quot;: &quot;o&quot;,
	&quot;�ĥ&quot;: &quot;o&quot;,
	&quot;�¸&quot;: &quot;o&quot;,
	&quot;áğ‘&quot;: &quot;o&quot;,
	&quot;áı&quot;: &quot;o&quot;,
	&quot;áı“&quot;: &quot;o&quot;,
	&quot;ȏ&quot;: &quot;o&quot;,
	&quot;áğ&quot;: &quot;o&quot;,
	&quot;áğ&quot;: &quot;o&quot;,
	&quot;áğ•&quot;: &quot;o&quot;,
	&quot;áğ—&quot;: &quot;o&quot;,
	&quot;áğ™&quot;: &quot;o&quot;,
	&quot;áğ&quot;: &quot;o&quot;,
	&quot;áğŸ&quot;: &quot;o&quot;,
	&quot;áğĦ&quot;: &quot;o&quot;,
	&quot;áğ›&quot;: &quot;o&quot;,
	&quot;áğ£&quot;: &quot;o&quot;,
	&quot;�ı&quot;: &quot;u&quot;,
	&quot;�ş&quot;: &quot;u&quot;,
	&quot;�ğ&quot;: &quot;u&quot;,
	&quot;�ĵ&quot;: &quot;u&quot;,
	&quot;áğ§&quot;: &quot;u&quot;,
	&quot;áğ�&quot;: &quot;u&quot;,
	&quot;áğ­&quot;: &quot;u&quot;,
	&quot;áğŻ&quot;: &quot;u&quot;,
	&quot;áğħ&quot;: &quot;u&quot;,
	&quot;�½&quot;: &quot;y&quot;,
	&quot;�ż&quot;: &quot;y&quot;,
	&quot;Ā&quot;: &quot;A&quot;,
	&quot;ā&quot;: &quot;a&quot;,
	&quot;Ă&quot;: &quot;A&quot;,
	&quot;ă&quot;: &quot;a&quot;,
	&quot;Ą&quot;: &quot;A&quot;,
	&quot;ą&quot;: &quot;a&quot;,
	&quot;Ć&quot;: &quot;C&quot;,
	&quot;ć&quot;: &quot;c&quot;,
	&quot;Ĉ&quot;: &quot;C&quot;,
	&quot;ĉ&quot;: &quot;c&quot;,
	&quot;Ċ&quot;: &quot;C&quot;,
	&quot;ċ&quot;: &quot;c&quot;,
	&quot;Č&quot;: &quot;C&quot;,
	&quot;č&quot;: &quot;c&quot;,
	&quot;C̆&quot;: &quot;C&quot;,
	&quot;c̆&quot;: &quot;c&quot;,
	&quot;Ď&quot;: &quot;D&quot;,
	&quot;ď&quot;: &quot;d&quot;,
	&quot;Đ&quot;: &quot;D&quot;,
	&quot;đ&quot;: &quot;d&quot;,
	&quot;Ē&quot;: &quot;E&quot;,
	&quot;ē&quot;: &quot;e&quot;,
	&quot;Ĕ&quot;: &quot;E&quot;,
	&quot;ĕ&quot;: &quot;e&quot;,
	&quot;Ė&quot;: &quot;E&quot;,
	&quot;ė&quot;: &quot;e&quot;,
	&quot;Ę&quot;: &quot;E&quot;,
	&quot;ę&quot;: &quot;e&quot;,
	&quot;Ě&quot;: &quot;E&quot;,
	&quot;ě&quot;: &quot;e&quot;,
	&quot;Ĝ&quot;: &quot;G&quot;,
	&quot;Ç´&quot;: &quot;G&quot;,
	&quot;ĝ&quot;: &quot;g&quot;,
	&quot;ǵ&quot;: &quot;g&quot;,
	&quot;Ğ&quot;: &quot;G&quot;,
	&quot;ğ&quot;: &quot;g&quot;,
	&quot;Ä &quot;: &quot;G&quot;,
	&quot;ÄĦ&quot;: &quot;g&quot;,
	&quot;Ģ&quot;: &quot;G&quot;,
	&quot;Ä£&quot;: &quot;g&quot;,
	&quot;Ĥ&quot;: &quot;H&quot;,
	&quot;�&quot;: &quot;h&quot;,
	&quot;ÄĤ&quot;: &quot;H&quot;,
	&quot;ħ&quot;: &quot;h&quot;,
	&quot;Ḫ&quot;: &quot;H&quot;,
	&quot;á¸Ğ&quot;: &quot;h&quot;,
	&quot;Ĩ&quot;: &quot;I&quot;,
	&quot;Äİ&quot;: &quot;i&quot;,
	&quot;ÄŞ&quot;: &quot;I&quot;,
	&quot;ÄĞ&quot;: &quot;i&quot;,
	&quot;ÄĴ&quot;: &quot;I&quot;,
	&quot;Ä­&quot;: &quot;i&quot;,
	&quot;�&quot;: &quot;I&quot;,
	&quot;ÄŻ&quot;: &quot;i&quot;,
	&quot;Ä°&quot;: &quot;I&quot;,
	&quot;Äħ&quot;: &quot;i&quot;,
	&quot;IJ&quot;: &quot;IJ&quot;,
	&quot;ij&quot;: &quot;ij&quot;,
	&quot;Ä´&quot;: &quot;J&quot;,
	&quot;ĵ&quot;: &quot;j&quot;,
	&quot;Äĥ&quot;: &quot;K&quot;,
	&quot;Ä·&quot;: &quot;k&quot;,
	&quot;Ḱ&quot;: &quot;K&quot;,
	&quot;á¸ħ&quot;: &quot;k&quot;,
	&quot;K̆&quot;: &quot;K&quot;,
	&quot;k̆&quot;: &quot;k&quot;,
	&quot;Äı&quot;: &quot;L&quot;,
	&quot;Äş&quot;: &quot;l&quot;,
	&quot;Äğ&quot;: &quot;L&quot;,
	&quot;Äĵ&quot;: &quot;l&quot;,
	&quot;Ľ&quot;: &quot;L&quot;,
	&quot;�&quot;: &quot;l&quot;,
	&quot;Äż&quot;: &quot;L&quot;,
	&quot;Ċ€&quot;: &quot;l&quot;,
	&quot;Ċ&quot;: &quot;l&quot;,
	&quot;Ċ‚&quot;: &quot;l&quot;,
	&quot;�&quot;: &quot;M&quot;,
	&quot;ḿ&quot;: &quot;m&quot;,
	&quot;M̆&quot;: &quot;M&quot;,
	&quot;m̆&quot;: &quot;m&quot;,
	&quot;Ċƒ&quot;: &quot;N&quot;,
	&quot;Ċ„&quot;: &quot;n&quot;,
	&quot;Ċ…&quot;: &quot;N&quot;,
	&quot;Ċ†&quot;: &quot;n&quot;,
	&quot;Ċ‡&quot;: &quot;N&quot;,
	&quot;Ċˆ&quot;: &quot;n&quot;,
	&quot;Ċ‰&quot;: &quot;n&quot;,
	&quot;N̆&quot;: &quot;N&quot;,
	&quot;n̆&quot;: &quot;n&quot;,
	&quot;ĊŒ&quot;: &quot;O&quot;,
	&quot;Ċ&quot;: &quot;o&quot;,
	&quot;ĊŽ&quot;: &quot;O&quot;,
	&quot;Ċ&quot;: &quot;o&quot;,
	&quot;Ċ&quot;: &quot;O&quot;,
	&quot;Ċ‘&quot;: &quot;o&quot;,
	&quot;Ċ’&quot;: &quot;OE&quot;,
	&quot;Ċ“&quot;: &quot;oe&quot;,
	&quot;P̆&quot;: &quot;P&quot;,
	&quot;p̆&quot;: &quot;p&quot;,
	&quot;Ċ”&quot;: &quot;R&quot;,
	&quot;Ċ•&quot;: &quot;r&quot;,
	&quot;Ċ–&quot;: &quot;R&quot;,
	&quot;Ċ—&quot;: &quot;r&quot;,
	&quot;Ċ˜&quot;: &quot;R&quot;,
	&quot;Ċ™&quot;: &quot;r&quot;,
	&quot;R̆&quot;: &quot;R&quot;,
	&quot;r̆&quot;: &quot;r&quot;,
	&quot;Ȓ&quot;: &quot;R&quot;,
	&quot;ȓ&quot;: &quot;r&quot;,
	&quot;Ċš&quot;: &quot;S&quot;,
	&quot;Ċ›&quot;: &quot;s&quot;,
	&quot;Ċœ&quot;: &quot;S&quot;,
	&quot;Ċ&quot;: &quot;s&quot;,
	&quot;Ċž&quot;: &quot;S&quot;,
	&quot;Ș&quot;: &quot;S&quot;,
	&quot;ș&quot;: &quot;s&quot;,
	&quot;ĊŸ&quot;: &quot;s&quot;,
	&quot;Ċ &quot;: &quot;S&quot;,
	&quot;ĊĦ&quot;: &quot;s&quot;,
	&quot;Ċ˘&quot;: &quot;T&quot;,
	&quot;Ċ£&quot;: &quot;t&quot;,
	&quot;ț&quot;: &quot;t&quot;,
	&quot;Ț&quot;: &quot;T&quot;,
	&quot;Ċ¤&quot;: &quot;T&quot;,
	&quot;Ċ�&quot;: &quot;t&quot;,
	&quot;ĊĤ&quot;: &quot;T&quot;,
	&quot;Ċ§&quot;: &quot;t&quot;,
	&quot;T̆&quot;: &quot;T&quot;,
	&quot;t̆&quot;: &quot;t&quot;,
	&quot;Ċ¨&quot;: &quot;U&quot;,
	&quot;Ċİ&quot;: &quot;u&quot;,
	&quot;ĊŞ&quot;: &quot;U&quot;,
	&quot;ĊĞ&quot;: &quot;u&quot;,
	&quot;ĊĴ&quot;: &quot;U&quot;,
	&quot;Ċ­&quot;: &quot;u&quot;,
	&quot;Ċ�&quot;: &quot;U&quot;,
	&quot;ĊŻ&quot;: &quot;u&quot;,
	&quot;Ċ°&quot;: &quot;U&quot;,
	&quot;Ċħ&quot;: &quot;u&quot;,
	&quot;Ċ²&quot;: &quot;U&quot;,
	&quot;Ċ³&quot;: &quot;u&quot;,
	&quot;Ȗ&quot;: &quot;U&quot;,
	&quot;ȗ&quot;: &quot;u&quot;,
	&quot;V̆&quot;: &quot;V&quot;,
	&quot;v̆&quot;: &quot;v&quot;,
	&quot;Ċ´&quot;: &quot;W&quot;,
	&quot;Ċµ&quot;: &quot;w&quot;,
	&quot;Ẃ&quot;: &quot;W&quot;,
	&quot;ẃ&quot;: &quot;w&quot;,
	&quot;X̆&quot;: &quot;X&quot;,
	&quot;x̆&quot;: &quot;x&quot;,
	&quot;Ċĥ&quot;: &quot;Y&quot;,
	&quot;Ċ·&quot;: &quot;y&quot;,
	&quot;Ċ¸&quot;: &quot;Y&quot;,
	&quot;Y̆&quot;: &quot;Y&quot;,
	&quot;y̆&quot;: &quot;y&quot;,
	&quot;Ċı&quot;: &quot;Z&quot;,
	&quot;Ċş&quot;: &quot;z&quot;,
	&quot;Ċğ&quot;: &quot;Z&quot;,
	&quot;Ċĵ&quot;: &quot;z&quot;,
	&quot;Ċ½&quot;: &quot;Z&quot;,
	&quot;Ċ�&quot;: &quot;z&quot;,
	&quot;Ċż&quot;: &quot;s&quot;,
	&quot;Ĉ’&quot;: &quot;f&quot;,
	&quot;Ĉ &quot;: &quot;O&quot;,
	&quot;ĈĦ&quot;: &quot;o&quot;,
	&quot;ĈŻ&quot;: &quot;U&quot;,
	&quot;Ĉ°&quot;: &quot;u&quot;,
	&quot;Ǎ&quot;: &quot;A&quot;,
	&quot;ǎ&quot;: &quot;a&quot;,
	&quot;Ǐ&quot;: &quot;I&quot;,
	&quot;ǐ&quot;: &quot;i&quot;,
	&quot;Ǒ&quot;: &quot;O&quot;,
	&quot;ǒ&quot;: &quot;o&quot;,
	&quot;Ǔ&quot;: &quot;U&quot;,
	&quot;ǔ&quot;: &quot;u&quot;,
	&quot;Ǖ&quot;: &quot;U&quot;,
	&quot;ǖ&quot;: &quot;u&quot;,
	&quot;Ǘ&quot;: &quot;U&quot;,
	&quot;ǘ&quot;: &quot;u&quot;,
	&quot;Ǚ&quot;: &quot;U&quot;,
	&quot;ǚ&quot;: &quot;u&quot;,
	&quot;Ǜ&quot;: &quot;U&quot;,
	&quot;ǜ&quot;: &quot;u&quot;,
	&quot;áğ¨&quot;: &quot;U&quot;,
	&quot;áğİ&quot;: &quot;u&quot;,
	&quot;áı¸&quot;: &quot;U&quot;,
	&quot;áıı&quot;: &quot;u&quot;,
	&quot;Çş&quot;: &quot;A&quot;,
	&quot;Çğ&quot;: &quot;a&quot;,
	&quot;Çĵ&quot;: &quot;AE&quot;,
	&quot;ǽ&quot;: &quot;ae&quot;,
	&quot;�&quot;: &quot;O&quot;,
	&quot;Çż&quot;: &quot;o&quot;,
	&quot;�ž&quot;: &quot;TH&quot;,
	&quot;��&quot;: &quot;th&quot;,
	&quot;áı”&quot;: &quot;P&quot;,
	&quot;áı•&quot;: &quot;p&quot;,
	&quot;áı¤&quot;: &quot;S&quot;,
	&quot;áı�&quot;: &quot;s&quot;,
	&quot;X́&quot;: &quot;X&quot;,
	&quot;x́&quot;: &quot;x&quot;,
	&quot;�ƒ&quot;: &quot;�“&quot;,
	&quot;ѓ&quot;: &quot;�³&quot;,
	&quot;�Œ&quot;: &quot;�š&quot;,
	&quot;ќ&quot;: &quot;�ş&quot;,
	&quot;A̋&quot;: &quot;A&quot;,
	&quot;a̋&quot;: &quot;a&quot;,
	&quot;E̋&quot;: &quot;E&quot;,
	&quot;e̋&quot;: &quot;e&quot;,
	&quot;I̋&quot;: &quot;I&quot;,
	&quot;i̋&quot;: &quot;i&quot;,
	&quot;Ǹ&quot;: &quot;N&quot;,
	&quot;Çı&quot;: &quot;n&quot;,
	&quot;áğ’&quot;: &quot;O&quot;,
	&quot;áğ“&quot;: &quot;o&quot;,
	&quot;áı&quot;: &quot;O&quot;,
	&quot;áı‘&quot;: &quot;o&quot;,
	&quot;áğŞ&quot;: &quot;U&quot;,
	&quot;áğĞ&quot;: &quot;u&quot;,
	&quot;Ẁ&quot;: &quot;W&quot;,
	&quot;ẁ&quot;: &quot;w&quot;,
	&quot;áğ²&quot;: &quot;Y&quot;,
	&quot;áğ³&quot;: &quot;y&quot;,
	&quot;Ȁ&quot;: &quot;A&quot;,
	&quot;ȁ&quot;: &quot;a&quot;,
	&quot;Ȅ&quot;: &quot;E&quot;,
	&quot;ȅ&quot;: &quot;e&quot;,
	&quot;Ȉ&quot;: &quot;I&quot;,
	&quot;ȉ&quot;: &quot;i&quot;,
	&quot;Ȍ&quot;: &quot;O&quot;,
	&quot;ȍ&quot;: &quot;o&quot;,
	&quot;Ȑ&quot;: &quot;R&quot;,
	&quot;ȑ&quot;: &quot;r&quot;,
	&quot;Ȕ&quot;: &quot;U&quot;,
	&quot;ȕ&quot;: &quot;u&quot;,
	&quot;B̌&quot;: &quot;B&quot;,
	&quot;b̌&quot;: &quot;b&quot;,
	&quot;Č̣&quot;: &quot;C&quot;,
	&quot;č̣&quot;: &quot;c&quot;,
	&quot;�ŠÌŒ&quot;: &quot;E&quot;,
	&quot;�ŞÌŒ&quot;: &quot;e&quot;,
	&quot;F̌&quot;: &quot;F&quot;,
	&quot;f̌&quot;: &quot;f&quot;,
	&quot;ÇĤ&quot;: &quot;G&quot;,
	&quot;ǧ&quot;: &quot;g&quot;,
	&quot;Ȟ&quot;: &quot;H&quot;,
	&quot;ȟ&quot;: &quot;h&quot;,
	&quot;J̌&quot;: &quot;J&quot;,
	&quot;Ç°&quot;: &quot;j&quot;,
	&quot;Ǩ&quot;: &quot;K&quot;,
	&quot;Çİ&quot;: &quot;k&quot;,
	&quot;M̌&quot;: &quot;M&quot;,
	&quot;m̌&quot;: &quot;m&quot;,
	&quot;P̌&quot;: &quot;P&quot;,
	&quot;p̌&quot;: &quot;p&quot;,
	&quot;Q̌&quot;: &quot;Q&quot;,
	&quot;q̌&quot;: &quot;q&quot;,
	&quot;Ċ˜Ìİ&quot;: &quot;R&quot;,
	&quot;Ċ™Ìİ&quot;: &quot;r&quot;,
	&quot;áıĤ&quot;: &quot;S&quot;,
	&quot;áı§&quot;: &quot;s&quot;,
	&quot;V̌&quot;: &quot;V&quot;,
	&quot;v̌&quot;: &quot;v&quot;,
	&quot;W̌&quot;: &quot;W&quot;,
	&quot;w̌&quot;: &quot;w&quot;,
	&quot;X̌&quot;: &quot;X&quot;,
	&quot;x̌&quot;: &quot;x&quot;,
	&quot;Y̌&quot;: &quot;Y&quot;,
	&quot;y̌&quot;: &quot;y&quot;,
	&quot;A̧&quot;: &quot;A&quot;,
	&quot;a̧&quot;: &quot;a&quot;,
	&quot;B̧&quot;: &quot;B&quot;,
	&quot;b̧&quot;: &quot;b&quot;,
	&quot;Ḑ&quot;: &quot;D&quot;,
	&quot;ḑ&quot;: &quot;d&quot;,
	&quot;Ȩ&quot;: &quot;E&quot;,
	&quot;Èİ&quot;: &quot;e&quot;,
	&quot;ĈÌ§&quot;: &quot;E&quot;,
	&quot;ɛ̧&quot;: &quot;e&quot;,
	&quot;Ḩ&quot;: &quot;H&quot;,
	&quot;á¸İ&quot;: &quot;h&quot;,
	&quot;I̧&quot;: &quot;I&quot;,
	&quot;i̧&quot;: &quot;i&quot;,
	&quot;Ĉ—̧&quot;: &quot;I&quot;,
	&quot;ɨ̧&quot;: &quot;i&quot;,
	&quot;M̧&quot;: &quot;M&quot;,
	&quot;m̧&quot;: &quot;m&quot;,
	&quot;O̧&quot;: &quot;O&quot;,
	&quot;o̧&quot;: &quot;o&quot;,
	&quot;Q̧&quot;: &quot;Q&quot;,
	&quot;q̧&quot;: &quot;q&quot;,
	&quot;U̧&quot;: &quot;U&quot;,
	&quot;u̧&quot;: &quot;u&quot;,
	&quot;X̧&quot;: &quot;X&quot;,
	&quot;x̧&quot;: &quot;x&quot;,
	&quot;Z̧&quot;: &quot;Z&quot;,
	&quot;z̧&quot;: &quot;z&quot;,
	&quot;�ı&quot;:&quot;�¸&quot;,
	&quot;�™&quot;:&quot;�˜&quot;,
	&quot;ё&quot;:&quot;�µ&quot;,
	&quot;�&quot;:&quot;�•&quot;,
};

var chars = Object.keys(characterMap).join(&#039;|&#039;);
var allAccents = new RegExp(chars, &#039;g&#039;);
var firstAccent = new RegExp(chars, &#039;&#039;);

function matcher(match) {
	return characterMap[match];
}

var removeAccents = function(string) {
	return string.replace(allAccents, matcher);
};

var hasAccents = function(string) {
	return !!string.match(firstAccent);
};

module.exports = removeAccents;
module.exports.has = hasAccents;
module.exports.remove = removeAccents;


/***/ }),

/***/ 9746:
/***/ (() =&gt; {

/* (ignored) */

/***/ }),

/***/ 9977:
/***/ (() =&gt; {

/* (ignored) */

/***/ })

/******/ 	});
/************************************************************************/
/******/ 	// The module cache
/******/ 	var __webpack_module_cache__ = {};
/******/ 	
/******/ 	// The require function
/******/ 	function __webpack_require__(moduleId) {
/******/ 		// Check if module is in cache
/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
/******/ 		if (cachedModule !== undefined) {
/******/ 			return cachedModule.exports;
/******/ 		}
/******/ 		// Create a new module (and put it into the cache)
/******/ 		var module = __webpack_module_cache__[moduleId] = {
/******/ 			// no module.id needed
/******/ 			// no module.loaded needed
/******/ 			exports: {}
/******/ 		};
/******/ 	
/******/ 		// Execute the module function
/******/ 		__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/ 	
/******/ 		// Return the exports of the module
/******/ 		return module.exports;
/******/ 	}
/******/ 	
/************************************************************************/
/******/ 	/* webpack/runtime/compat get default export */
/******/ 	(() =&gt; {
/******/ 		// getDefaultExport function for compatibility with non-harmony modules
/******/ 		__webpack_require__.n = (module) =&gt; {
/******/ 			var getter = module &amp;&amp; module.__esModule ?
/******/ 				() =&gt; (module[&#039;default&#039;]) :
/******/ 				() =&gt; (module);
/******/ 			__webpack_require__.d(getter, { a: getter });
/******/ 			return getter;
/******/ 		};
/******/ 	})();
/******/ 	
/******/ 	/* webpack/runtime/define property getters */
/******/ 	(() =&gt; {
/******/ 		// define getter functions for harmony exports
/******/ 		__webpack_require__.d = (exports, definition) =&gt; {
/******/ 			for(var key in definition) {
/******/ 				if(__webpack_require__.o(definition, key) &amp;&amp; !__webpack_require__.o(exports, key)) {
/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
/******/ 				}
/******/ 			}
/******/ 		};
/******/ 	})();
/******/ 	
/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
/******/ 	(() =&gt; {
/******/ 		__webpack_require__.o = (obj, prop) =&gt; (Object.prototype.hasOwnProperty.call(obj, prop))
/******/ 	})();
/******/ 	
/******/ 	/* webpack/runtime/make namespace object */
/******/ 	(() =&gt; {
/******/ 		// define __esModule on exports
/******/ 		__webpack_require__.r = (exports) =&gt; {
/******/ 			if(typeof Symbol !== &#039;undefined&#039; &amp;&amp; Symbol.toStringTag) {
/******/ 				Object.defineProperty(exports, Symbol.toStringTag, { value: &#039;Module&#039; });
/******/ 			}
/******/ 			Object.defineProperty(exports, &#039;__esModule&#039;, { value: true });
/******/ 		};
/******/ 	})();
/******/ 	
/************************************************************************/
var __webpack_exports__ = {};
// This entry needs to be wrapped in an IIFE because it needs to be in strict mode.
(() =&gt; {
&quot;use strict&quot;;
// ESM COMPAT FLAG
__webpack_require__.r(__webpack_exports__);

// EXPORTS
__webpack_require__.d(__webpack_exports__, {
  AlignmentControl: () =&gt; (/* reexport */ AlignmentControl),
  AlignmentToolbar: () =&gt; (/* reexport */ AlignmentToolbar),
  Autocomplete: () =&gt; (/* reexport */ autocomplete),
  BlockAlignmentControl: () =&gt; (/* reexport */ BlockAlignmentControl),
  BlockAlignmentToolbar: () =&gt; (/* reexport */ BlockAlignmentToolbar),
  BlockBreadcrumb: () =&gt; (/* reexport */ block_breadcrumb),
  BlockCanvas: () =&gt; (/* reexport */ block_canvas),
  BlockColorsStyleSelector: () =&gt; (/* reexport */ color_style_selector),
  BlockContextProvider: () =&gt; (/* reexport */ BlockContextProvider),
  BlockControls: () =&gt; (/* reexport */ block_controls),
  BlockEdit: () =&gt; (/* reexport */ BlockEdit),
  BlockEditorKeyboardShortcuts: () =&gt; (/* reexport */ keyboard_shortcuts),
  BlockEditorProvider: () =&gt; (/* reexport */ components_provider),
  BlockFormatControls: () =&gt; (/* reexport */ BlockFormatControls),
  BlockIcon: () =&gt; (/* reexport */ block_icon),
  BlockInspector: () =&gt; (/* reexport */ block_inspector),
  BlockList: () =&gt; (/* reexport */ BlockList),
  BlockMover: () =&gt; (/* reexport */ block_mover),
  BlockNavigationDropdown: () =&gt; (/* reexport */ dropdown),
  BlockPopover: () =&gt; (/* reexport */ block_popover),
  BlockPreview: () =&gt; (/* reexport */ block_preview),
  BlockSelectionClearer: () =&gt; (/* reexport */ BlockSelectionClearer),
  BlockSettingsMenu: () =&gt; (/* reexport */ block_settings_menu),
  BlockSettingsMenuControls: () =&gt; (/* reexport */ block_settings_menu_controls),
  BlockStyles: () =&gt; (/* reexport */ block_styles),
  BlockTitle: () =&gt; (/* reexport */ BlockTitle),
  BlockToolbar: () =&gt; (/* reexport */ BlockToolbar),
  BlockTools: () =&gt; (/* reexport */ BlockTools),
  BlockVerticalAlignmentControl: () =&gt; (/* reexport */ BlockVerticalAlignmentControl),
  BlockVerticalAlignmentToolbar: () =&gt; (/* reexport */ BlockVerticalAlignmentToolbar),
  ButtonBlockAppender: () =&gt; (/* reexport */ button_block_appender),
  ButtonBlockerAppender: () =&gt; (/* reexport */ ButtonBlockerAppender),
  ColorPalette: () =&gt; (/* reexport */ color_palette),
  ColorPaletteControl: () =&gt; (/* reexport */ ColorPaletteControl),
  ContrastChecker: () =&gt; (/* reexport */ contrast_checker),
  CopyHandler: () =&gt; (/* reexport */ CopyHandler),
  DefaultBlockAppender: () =&gt; (/* reexport */ DefaultBlockAppender),
  FontSizePicker: () =&gt; (/* reexport */ font_size_picker),
  HeadingLevelDropdown: () =&gt; (/* reexport */ HeadingLevelDropdown),
  HeightControl: () =&gt; (/* reexport */ HeightControl),
  InnerBlocks: () =&gt; (/* reexport */ inner_blocks),
  Inserter: () =&gt; (/* reexport */ inserter),
  InspectorAdvancedControls: () =&gt; (/* reexport */ InspectorAdvancedControls),
  InspectorControls: () =&gt; (/* reexport */ inspector_controls),
  JustifyContentControl: () =&gt; (/* reexport */ JustifyContentControl),
  JustifyToolbar: () =&gt; (/* reexport */ JustifyToolbar),
  LineHeightControl: () =&gt; (/* reexport */ line_height_control),
  LinkControl: () =&gt; (/* reexport */ link_control),
  MediaPlaceholder: () =&gt; (/* reexport */ media_placeholder),
  MediaReplaceFlow: () =&gt; (/* reexport */ media_replace_flow),
  MediaUpload: () =&gt; (/* reexport */ media_upload),
  MediaUploadCheck: () =&gt; (/* reexport */ check),
  MultiSelectScrollIntoView: () =&gt; (/* reexport */ MultiSelectScrollIntoView),
  NavigableToolbar: () =&gt; (/* reexport */ NavigableToolbar),
  ObserveTyping: () =&gt; (/* reexport */ observe_typing),
  PanelColorSettings: () =&gt; (/* reexport */ panel_color_settings),
  PlainText: () =&gt; (/* reexport */ plain_text),
  RecursionProvider: () =&gt; (/* reexport */ RecursionProvider),
  RichText: () =&gt; (/* reexport */ rich_text),
  RichTextShortcut: () =&gt; (/* reexport */ RichTextShortcut),
  RichTextToolbarButton: () =&gt; (/* reexport */ RichTextToolbarButton),
  SETTINGS_DEFAULTS: () =&gt; (/* reexport */ SETTINGS_DEFAULTS),
  SkipToSelectedBlock: () =&gt; (/* reexport */ SkipToSelectedBlock),
  ToolSelector: () =&gt; (/* reexport */ tool_selector),
  Typewriter: () =&gt; (/* reexport */ typewriter),
  URLInput: () =&gt; (/* reexport */ url_input),
  URLInputButton: () =&gt; (/* reexport */ url_input_button),
  URLPopover: () =&gt; (/* reexport */ url_popover),
  Warning: () =&gt; (/* reexport */ warning),
  WritingFlow: () =&gt; (/* reexport */ writing_flow),
  __experimentalBlockAlignmentMatrixControl: () =&gt; (/* reexport */ block_alignment_matrix_control),
  __experimentalBlockFullHeightAligmentControl: () =&gt; (/* reexport */ block_full_height_alignment_control),
  __experimentalBlockPatternSetup: () =&gt; (/* reexport */ block_pattern_setup),
  __experimentalBlockPatternsList: () =&gt; (/* reexport */ block_patterns_list),
  __experimentalBlockVariationPicker: () =&gt; (/* reexport */ block_variation_picker),
  __experimentalBlockVariationTransforms: () =&gt; (/* reexport */ block_variation_transforms),
  __experimentalBorderRadiusControl: () =&gt; (/* reexport */ BorderRadiusControl),
  __experimentalColorGradientControl: () =&gt; (/* reexport */ control),
  __experimentalColorGradientSettingsDropdown: () =&gt; (/* reexport */ ColorGradientSettingsDropdown),
  __experimentalDateFormatPicker: () =&gt; (/* reexport */ DateFormatPicker),
  __experimentalDuotoneControl: () =&gt; (/* reexport */ duotone_control),
  __experimentalFontAppearanceControl: () =&gt; (/* reexport */ FontAppearanceControl),
  __experimentalFontFamilyControl: () =&gt; (/* reexport */ FontFamilyControl),
  __experimentalGetBorderClassesAndStyles: () =&gt; (/* reexport */ getBorderClassesAndStyles),
  __experimentalGetColorClassesAndStyles: () =&gt; (/* reexport */ getColorClassesAndStyles),
  __experimentalGetElementClassName: () =&gt; (/* reexport */ __experimentalGetElementClassName),
  __experimentalGetGapCSSValue: () =&gt; (/* reexport */ getGapCSSValue),
  __experimentalGetGradientClass: () =&gt; (/* reexport */ __experimentalGetGradientClass),
  __experimentalGetGradientObjectByGradientValue: () =&gt; (/* reexport */ __experimentalGetGradientObjectByGradientValue),
  __experimentalGetShadowClassesAndStyles: () =&gt; (/* reexport */ getShadowClassesAndStyles),
  __experimentalGetSpacingClassesAndStyles: () =&gt; (/* reexport */ getSpacingClassesAndStyles),
  __experimentalImageEditor: () =&gt; (/* reexport */ ImageEditor),
  __experimentalImageSizeControl: () =&gt; (/* reexport */ ImageSizeControl),
  __experimentalImageURLInputUI: () =&gt; (/* reexport */ ImageURLInputUI),
  __experimentalInspectorPopoverHeader: () =&gt; (/* reexport */ InspectorPopoverHeader),
  __experimentalLetterSpacingControl: () =&gt; (/* reexport */ LetterSpacingControl),
  __experimentalLibrary: () =&gt; (/* reexport */ library),
  __experimentalLinkControl: () =&gt; (/* reexport */ DeprecatedExperimentalLinkControl),
  __experimentalLinkControlSearchInput: () =&gt; (/* reexport */ __experimentalLinkControlSearchInput),
  __experimentalLinkControlSearchItem: () =&gt; (/* reexport */ __experimentalLinkControlSearchItem),
  __experimentalLinkControlSearchResults: () =&gt; (/* reexport */ __experimentalLinkControlSearchResults),
  __experimentalListView: () =&gt; (/* reexport */ components_list_view),
  __experimentalPanelColorGradientSettings: () =&gt; (/* reexport */ panel_color_gradient_settings),
  __experimentalPreviewOptions: () =&gt; (/* reexport */ PreviewOptions),
  __experimentalPublishDateTimePicker: () =&gt; (/* reexport */ publish_date_time_picker),
  __experimentalRecursionProvider: () =&gt; (/* reexport */ DeprecatedExperimentalRecursionProvider),
  __experimentalResponsiveBlockControl: () =&gt; (/* reexport */ responsive_block_control),
  __experimentalSpacingSizesControl: () =&gt; (/* reexport */ SpacingSizesControl),
  __experimentalTextDecorationControl: () =&gt; (/* reexport */ TextDecorationControl),
  __experimentalTextTransformControl: () =&gt; (/* reexport */ TextTransformControl),
  __experimentalUnitControl: () =&gt; (/* reexport */ UnitControl),
  __experimentalUseBlockOverlayActive: () =&gt; (/* reexport */ useBlockOverlayActive),
  __experimentalUseBlockPreview: () =&gt; (/* reexport */ useBlockPreview),
  __experimentalUseBorderProps: () =&gt; (/* reexport */ useBorderProps),
  __experimentalUseColorProps: () =&gt; (/* reexport */ useColorProps),
  __experimentalUseCustomSides: () =&gt; (/* reexport */ useCustomSides),
  __experimentalUseGradient: () =&gt; (/* reexport */ __experimentalUseGradient),
  __experimentalUseHasRecursion: () =&gt; (/* reexport */ DeprecatedExperimentalUseHasRecursion),
  __experimentalUseMultipleOriginColorsAndGradients: () =&gt; (/* reexport */ useMultipleOriginColorsAndGradients),
  __experimentalUseResizeCanvas: () =&gt; (/* reexport */ useResizeCanvas),
  __experimentalWritingModeControl: () =&gt; (/* reexport */ WritingModeControl),
  __unstableBlockNameContext: () =&gt; (/* reexport */ block_name_context),
  __unstableBlockSettingsMenuFirstItem: () =&gt; (/* reexport */ block_settings_menu_first_item),
  __unstableBlockToolbarLastItem: () =&gt; (/* reexport */ block_toolbar_last_item),
  __unstableEditorStyles: () =&gt; (/* reexport */ editor_styles),
  __unstableIframe: () =&gt; (/* reexport */ iframe),
  __unstableInserterMenuExtension: () =&gt; (/* reexport */ inserter_menu_extension),
  __unstableRichTextInputEvent: () =&gt; (/* reexport */ __unstableRichTextInputEvent),
  __unstableUseBlockSelectionClearer: () =&gt; (/* reexport */ useBlockSelectionClearer),
  __unstableUseClipboardHandler: () =&gt; (/* reexport */ __unstableUseClipboardHandler),
  __unstableUseMouseMoveTypingReset: () =&gt; (/* reexport */ useMouseMoveTypingReset),
  __unstableUseTypewriter: () =&gt; (/* reexport */ useTypewriter),
  __unstableUseTypingObserver: () =&gt; (/* reexport */ useTypingObserver),
  createCustomColorsHOC: () =&gt; (/* reexport */ createCustomColorsHOC),
  getColorClassName: () =&gt; (/* reexport */ getColorClassName),
  getColorObjectByAttributeValues: () =&gt; (/* reexport */ getColorObjectByAttributeValues),
  getColorObjectByColorValue: () =&gt; (/* reexport */ getColorObjectByColorValue),
  getComputedFluidTypographyValue: () =&gt; (/* reexport */ getComputedFluidTypographyValue),
  getCustomValueFromPreset: () =&gt; (/* reexport */ getCustomValueFromPreset),
  getFontSize: () =&gt; (/* reexport */ utils_getFontSize),
  getFontSizeClass: () =&gt; (/* reexport */ getFontSizeClass),
  getFontSizeObjectByValue: () =&gt; (/* reexport */ utils_getFontSizeObjectByValue),
  getGradientSlugByValue: () =&gt; (/* reexport */ getGradientSlugByValue),
  getGradientValueBySlug: () =&gt; (/* reexport */ getGradientValueBySlug),
  getPxFromCssUnit: () =&gt; (/* reexport */ get_px_from_css_unit),
  getSpacingPresetCssVar: () =&gt; (/* reexport */ getSpacingPresetCssVar),
  getTypographyClassesAndStyles: () =&gt; (/* reexport */ getTypographyClassesAndStyles),
  isValueSpacingPreset: () =&gt; (/* reexport */ isValueSpacingPreset),
  privateApis: () =&gt; (/* reexport */ privateApis),
  store: () =&gt; (/* reexport */ store),
  storeConfig: () =&gt; (/* reexport */ storeConfig),
  transformStyles: () =&gt; (/* reexport */ transform_styles),
  useBlockBindingsUtils: () =&gt; (/* reexport */ useBlockBindingsUtils),
  useBlockCommands: () =&gt; (/* reexport */ useBlockCommands),
  useBlockDisplayInformation: () =&gt; (/* reexport */ useBlockDisplayInformation),
  useBlockEditContext: () =&gt; (/* reexport */ useBlockEditContext),
  useBlockEditingMode: () =&gt; (/* reexport */ useBlockEditingMode),
  useBlockProps: () =&gt; (/* reexport */ use_block_props_useBlockProps),
  useCachedTruthy: () =&gt; (/* reexport */ useCachedTruthy),
  useHasRecursion: () =&gt; (/* reexport */ useHasRecursion),
  useInnerBlocksProps: () =&gt; (/* reexport */ useInnerBlocksProps),
  useSetting: () =&gt; (/* reexport */ useSetting),
  useSettings: () =&gt; (/* reexport */ use_settings_useSettings),
  useStyleOverride: () =&gt; (/* reexport */ useStyleOverride),
  withColorContext: () =&gt; (/* reexport */ with_color_context),
  withColors: () =&gt; (/* reexport */ withColors),
  withFontSizes: () =&gt; (/* reexport */ with_font_sizes)
});

// NAMESPACE OBJECT: ./node_modules/@wordpress/block-editor/build-module/store/private-selectors.js
var private_selectors_namespaceObject = {};
__webpack_require__.r(private_selectors_namespaceObject);
__webpack_require__.d(private_selectors_namespaceObject, {
  getAllPatterns: () =&gt; (getAllPatterns),
  getBlockRemovalRules: () =&gt; (getBlockRemovalRules),
  getBlockSettings: () =&gt; (getBlockSettings),
  getBlockStyles: () =&gt; (getBlockStyles),
  getBlockWithoutAttributes: () =&gt; (getBlockWithoutAttributes),
  getClosestAllowedInsertionPoint: () =&gt; (getClosestAllowedInsertionPoint),
  getClosestAllowedInsertionPointForPattern: () =&gt; (getClosestAllowedInsertionPointForPattern),
  getContentLockingParent: () =&gt; (getContentLockingParent),
  getEnabledBlockParents: () =&gt; (getEnabledBlockParents),
  getEnabledClientIdsTree: () =&gt; (getEnabledClientIdsTree),
  getExpandedBlock: () =&gt; (getExpandedBlock),
  getInserterMediaCategories: () =&gt; (getInserterMediaCategories),
  getInsertionPoint: () =&gt; (getInsertionPoint),
  getLastFocus: () =&gt; (getLastFocus),
  getLastInsertedBlocksClientIds: () =&gt; (getLastInsertedBlocksClientIds),
  getOpenedBlockSettingsMenu: () =&gt; (getOpenedBlockSettingsMenu),
  getParentSectionBlock: () =&gt; (getParentSectionBlock),
  getPatternBySlug: () =&gt; (getPatternBySlug),
  getRegisteredInserterMediaCategories: () =&gt; (getRegisteredInserterMediaCategories),
  getRemovalPromptData: () =&gt; (getRemovalPromptData),
  getReusableBlocks: () =&gt; (getReusableBlocks),
  getSectionRootClientId: () =&gt; (getSectionRootClientId),
  getStyleOverrides: () =&gt; (getStyleOverrides),
  getTemporarilyEditingAsBlocks: () =&gt; (getTemporarilyEditingAsBlocks),
  getTemporarilyEditingFocusModeToRevert: () =&gt; (getTemporarilyEditingFocusModeToRevert),
  getZoomLevel: () =&gt; (getZoomLevel),
  hasAllowedPatterns: () =&gt; (hasAllowedPatterns),
  isBlockInterfaceHidden: () =&gt; (private_selectors_isBlockInterfaceHidden),
  isBlockSubtreeDisabled: () =&gt; (isBlockSubtreeDisabled),
  isDragging: () =&gt; (private_selectors_isDragging),
  isSectionBlock: () =&gt; (isSectionBlock),
  isZoomOut: () =&gt; (isZoomOut)
});

// NAMESPACE OBJECT: ./node_modules/@wordpress/block-editor/build-module/store/selectors.js
var selectors_namespaceObject = {};
__webpack_require__.r(selectors_namespaceObject);
__webpack_require__.d(selectors_namespaceObject, {
  __experimentalGetActiveBlockIdByBlockNames: () =&gt; (__experimentalGetActiveBlockIdByBlockNames),
  __experimentalGetAllowedBlocks: () =&gt; (__experimentalGetAllowedBlocks),
  __experimentalGetAllowedPatterns: () =&gt; (__experimentalGetAllowedPatterns),
  __experimentalGetBlockListSettingsForBlocks: () =&gt; (__experimentalGetBlockListSettingsForBlocks),
  __experimentalGetDirectInsertBlock: () =&gt; (__experimentalGetDirectInsertBlock),
  __experimentalGetGlobalBlocksByName: () =&gt; (__experimentalGetGlobalBlocksByName),
  __experimentalGetLastBlockAttributeChanges: () =&gt; (__experimentalGetLastBlockAttributeChanges),
  __experimentalGetParsedPattern: () =&gt; (__experimentalGetParsedPattern),
  __experimentalGetPatternTransformItems: () =&gt; (__experimentalGetPatternTransformItems),
  __experimentalGetPatternsByBlockTypes: () =&gt; (__experimentalGetPatternsByBlockTypes),
  __experimentalGetReusableBlockTitle: () =&gt; (__experimentalGetReusableBlockTitle),
  __unstableGetBlockWithoutInnerBlocks: () =&gt; (__unstableGetBlockWithoutInnerBlocks),
  __unstableGetClientIdWithClientIdsTree: () =&gt; (__unstableGetClientIdWithClientIdsTree),
  __unstableGetClientIdsTree: () =&gt; (__unstableGetClientIdsTree),
  __unstableGetContentLockingParent: () =&gt; (__unstableGetContentLockingParent),
  __unstableGetEditorMode: () =&gt; (__unstableGetEditorMode),
  __unstableGetSelectedBlocksWithPartialSelection: () =&gt; (__unstableGetSelectedBlocksWithPartialSelection),
  __unstableGetTemporarilyEditingAsBlocks: () =&gt; (__unstableGetTemporarilyEditingAsBlocks),
  __unstableGetTemporarilyEditingFocusModeToRevert: () =&gt; (__unstableGetTemporarilyEditingFocusModeToRevert),
  __unstableGetVisibleBlocks: () =&gt; (__unstableGetVisibleBlocks),
  __unstableHasActiveBlockOverlayActive: () =&gt; (__unstableHasActiveBlockOverlayActive),
  __unstableIsFullySelected: () =&gt; (__unstableIsFullySelected),
  __unstableIsLastBlockChangeIgnored: () =&gt; (__unstableIsLastBlockChangeIgnored),
  __unstableIsSelectionCollapsed: () =&gt; (__unstableIsSelectionCollapsed),
  __unstableIsSelectionMergeable: () =&gt; (__unstableIsSelectionMergeable),
  __unstableIsWithinBlockOverlay: () =&gt; (__unstableIsWithinBlockOverlay),
  __unstableSelectionHasUnmergeableBlock: () =&gt; (__unstableSelectionHasUnmergeableBlock),
  areInnerBlocksControlled: () =&gt; (areInnerBlocksControlled),
  canEditBlock: () =&gt; (canEditBlock),
  canInsertBlockType: () =&gt; (canInsertBlockType),
  canInsertBlocks: () =&gt; (canInsertBlocks),
  canLockBlockType: () =&gt; (canLockBlockType),
  canMoveBlock: () =&gt; (canMoveBlock),
  canMoveBlocks: () =&gt; (canMoveBlocks),
  canRemoveBlock: () =&gt; (canRemoveBlock),
  canRemoveBlocks: () =&gt; (canRemoveBlocks),
  didAutomaticChange: () =&gt; (didAutomaticChange),
  getAdjacentBlockClientId: () =&gt; (getAdjacentBlockClientId),
  getAllowedBlocks: () =&gt; (getAllowedBlocks),
  getBlock: () =&gt; (getBlock),
  getBlockAttributes: () =&gt; (getBlockAttributes),
  getBlockCount: () =&gt; (getBlockCount),
  getBlockEditingMode: () =&gt; (getBlockEditingMode),
  getBlockHierarchyRootClientId: () =&gt; (getBlockHierarchyRootClientId),
  getBlockIndex: () =&gt; (getBlockIndex),
  getBlockInsertionPoint: () =&gt; (getBlockInsertionPoint),
  getBlockListSettings: () =&gt; (getBlockListSettings),
  getBlockMode: () =&gt; (getBlockMode),
  getBlockName: () =&gt; (getBlockName),
  getBlockNamesByClientId: () =&gt; (getBlockNamesByClientId),
  getBlockOrder: () =&gt; (getBlockOrder),
  getBlockParents: () =&gt; (getBlockParents),
  getBlockParentsByBlockName: () =&gt; (getBlockParentsByBlockName),
  getBlockRootClientId: () =&gt; (getBlockRootClientId),
  getBlockSelectionEnd: () =&gt; (getBlockSelectionEnd),
  getBlockSelectionStart: () =&gt; (getBlockSelectionStart),
  getBlockTransformItems: () =&gt; (getBlockTransformItems),
  getBlocks: () =&gt; (getBlocks),
  getBlocksByClientId: () =&gt; (getBlocksByClientId),
  getBlocksByName: () =&gt; (getBlocksByName),
  getClientIdsOfDescendants: () =&gt; (getClientIdsOfDescendants),
  getClientIdsWithDescendants: () =&gt; (getClientIdsWithDescendants),
  getDirectInsertBlock: () =&gt; (getDirectInsertBlock),
  getDraggedBlockClientIds: () =&gt; (getDraggedBlockClientIds),
  getFirstMultiSelectedBlockClientId: () =&gt; (getFirstMultiSelectedBlockClientId),
  getGlobalBlockCount: () =&gt; (getGlobalBlockCount),
  getHoveredBlockClientId: () =&gt; (getHoveredBlockClientId),
  getInserterItems: () =&gt; (getInserterItems),
  getLastMultiSelectedBlockClientId: () =&gt; (getLastMultiSelectedBlockClientId),
  getLowestCommonAncestorWithSelectedBlock: () =&gt; (getLowestCommonAncestorWithSelectedBlock),
  getMultiSelectedBlockClientIds: () =&gt; (getMultiSelectedBlockClientIds),
  getMultiSelectedBlocks: () =&gt; (getMultiSelectedBlocks),
  getMultiSelectedBlocksEndClientId: () =&gt; (getMultiSelectedBlocksEndClientId),
  getMultiSelectedBlocksStartClientId: () =&gt; (getMultiSelectedBlocksStartClientId),
  getNextBlockClientId: () =&gt; (getNextBlockClientId),
  getPatternsByBlockTypes: () =&gt; (getPatternsByBlockTypes),
  getPreviousBlockClientId: () =&gt; (getPreviousBlockClientId),
  getSelectedBlock: () =&gt; (getSelectedBlock),
  getSelectedBlockClientId: () =&gt; (getSelectedBlockClientId),
  getSelectedBlockClientIds: () =&gt; (getSelectedBlockClientIds),
  getSelectedBlockCount: () =&gt; (getSelectedBlockCount),
  getSelectedBlocksInitialCaretPosition: () =&gt; (getSelectedBlocksInitialCaretPosition),
  getSelectionEnd: () =&gt; (getSelectionEnd),
  getSelectionStart: () =&gt; (getSelectionStart),
  getSettings: () =&gt; (getSettings),
  getTemplate: () =&gt; (getTemplate),
  getTemplateLock: () =&gt; (getTemplateLock),
  hasBlockMovingClientId: () =&gt; (hasBlockMovingClientId),
  hasDraggedInnerBlock: () =&gt; (hasDraggedInnerBlock),
  hasInserterItems: () =&gt; (hasInserterItems),
  hasMultiSelection: () =&gt; (hasMultiSelection),
  hasSelectedBlock: () =&gt; (hasSelectedBlock),
  hasSelectedInnerBlock: () =&gt; (hasSelectedInnerBlock),
  isAncestorBeingDragged: () =&gt; (isAncestorBeingDragged),
  isAncestorMultiSelected: () =&gt; (isAncestorMultiSelected),
  isBlockBeingDragged: () =&gt; (isBlockBeingDragged),
  isBlockHighlighted: () =&gt; (isBlockHighlighted),
  isBlockInsertionPointVisible: () =&gt; (isBlockInsertionPointVisible),
  isBlockMultiSelected: () =&gt; (isBlockMultiSelected),
  isBlockSelected: () =&gt; (isBlockSelected),
  isBlockValid: () =&gt; (isBlockValid),
  isBlockVisible: () =&gt; (isBlockVisible),
  isBlockWithinSelection: () =&gt; (isBlockWithinSelection),
  isCaretWithinFormattedText: () =&gt; (isCaretWithinFormattedText),
  isDraggingBlocks: () =&gt; (isDraggingBlocks),
  isFirstMultiSelectedBlock: () =&gt; (isFirstMultiSelectedBlock),
  isGroupable: () =&gt; (isGroupable),
  isLastBlockChangePersistent: () =&gt; (isLastBlockChangePersistent),
  isMultiSelecting: () =&gt; (selectors_isMultiSelecting),
  isNavigationMode: () =&gt; (isNavigationMode),
  isSelectionEnabled: () =&gt; (selectors_isSelectionEnabled),
  isTyping: () =&gt; (selectors_isTyping),
  isUngroupable: () =&gt; (isUngroupable),
  isValidTemplate: () =&gt; (isValidTemplate),
  wasBlockJustInserted: () =&gt; (wasBlockJustInserted)
});

// NAMESPACE OBJECT: ./node_modules/@wordpress/block-editor/build-module/store/private-actions.js
var private_actions_namespaceObject = {};
__webpack_require__.r(private_actions_namespaceObject);
__webpack_require__.d(private_actions_namespaceObject, {
  __experimentalUpdateSettings: () =&gt; (__experimentalUpdateSettings),
  clearBlockRemovalPrompt: () =&gt; (clearBlockRemovalPrompt),
  deleteStyleOverride: () =&gt; (deleteStyleOverride),
  ensureDefaultBlock: () =&gt; (ensureDefaultBlock),
  expandBlock: () =&gt; (expandBlock),
  hideBlockInterface: () =&gt; (hideBlockInterface),
  modifyContentLockBlock: () =&gt; (modifyContentLockBlock),
  privateRemoveBlocks: () =&gt; (privateRemoveBlocks),
  resetZoomLevel: () =&gt; (resetZoomLevel),
  setBlockRemovalRules: () =&gt; (setBlockRemovalRules),
  setInsertionPoint: () =&gt; (setInsertionPoint),
  setLastFocus: () =&gt; (setLastFocus),
  setOpenedBlockSettingsMenu: () =&gt; (setOpenedBlockSettingsMenu),
  setStyleOverride: () =&gt; (setStyleOverride),
  setZoomLevel: () =&gt; (setZoomLevel),
  showBlockInterface: () =&gt; (showBlockInterface),
  startDragging: () =&gt; (startDragging),
  stopDragging: () =&gt; (stopDragging),
  stopEditingAsBlocks: () =&gt; (stopEditingAsBlocks)
});

// NAMESPACE OBJECT: ./node_modules/@wordpress/block-editor/build-module/store/actions.js
var actions_namespaceObject = {};
__webpack_require__.r(actions_namespaceObject);
__webpack_require__.d(actions_namespaceObject, {
  __unstableDeleteSelection: () =&gt; (__unstableDeleteSelection),
  __unstableExpandSelection: () =&gt; (__unstableExpandSelection),
  __unstableMarkAutomaticChange: () =&gt; (__unstableMarkAutomaticChange),
  __unstableMarkLastChangeAsPersistent: () =&gt; (__unstableMarkLastChangeAsPersistent),
  __unstableMarkNextChangeAsNotPersistent: () =&gt; (__unstableMarkNextChangeAsNotPersistent),
  __unstableSaveReusableBlock: () =&gt; (__unstableSaveReusableBlock),
  __unstableSetEditorMode: () =&gt; (__unstableSetEditorMode),
  __unstableSetTemporarilyEditingAsBlocks: () =&gt; (__unstableSetTemporarilyEditingAsBlocks),
  __unstableSplitSelection: () =&gt; (__unstableSplitSelection),
  clearSelectedBlock: () =&gt; (clearSelectedBlock),
  duplicateBlocks: () =&gt; (duplicateBlocks),
  enterFormattedText: () =&gt; (enterFormattedText),
  exitFormattedText: () =&gt; (exitFormattedText),
  flashBlock: () =&gt; (flashBlock),
  hideInsertionPoint: () =&gt; (hideInsertionPoint),
  hoverBlock: () =&gt; (hoverBlock),
  insertAfterBlock: () =&gt; (insertAfterBlock),
  insertBeforeBlock: () =&gt; (insertBeforeBlock),
  insertBlock: () =&gt; (insertBlock),
  insertBlocks: () =&gt; (insertBlocks),
  insertDefaultBlock: () =&gt; (insertDefaultBlock),
  mergeBlocks: () =&gt; (mergeBlocks),
  moveBlockToPosition: () =&gt; (moveBlockToPosition),
  moveBlocksDown: () =&gt; (moveBlocksDown),
  moveBlocksToPosition: () =&gt; (moveBlocksToPosition),
  moveBlocksUp: () =&gt; (moveBlocksUp),
  multiSelect: () =&gt; (multiSelect),
  receiveBlocks: () =&gt; (receiveBlocks),
  registerInserterMediaCategory: () =&gt; (registerInserterMediaCategory),
  removeBlock: () =&gt; (removeBlock),
  removeBlocks: () =&gt; (removeBlocks),
  replaceBlock: () =&gt; (replaceBlock),
  replaceBlocks: () =&gt; (replaceBlocks),
  replaceInnerBlocks: () =&gt; (replaceInnerBlocks),
  resetBlocks: () =&gt; (resetBlocks),
  resetSelection: () =&gt; (resetSelection),
  selectBlock: () =&gt; (selectBlock),
  selectNextBlock: () =&gt; (selectNextBlock),
  selectPreviousBlock: () =&gt; (selectPreviousBlock),
  selectionChange: () =&gt; (selectionChange),
  setBlockEditingMode: () =&gt; (setBlockEditingMode),
  setBlockMovingClientId: () =&gt; (setBlockMovingClientId),
  setBlockVisibility: () =&gt; (setBlockVisibility),
  setHasControlledInnerBlocks: () =&gt; (setHasControlledInnerBlocks),
  setNavigationMode: () =&gt; (setNavigationMode),
  setTemplateValidity: () =&gt; (setTemplateValidity),
  showInsertionPoint: () =&gt; (showInsertionPoint),
  startDraggingBlocks: () =&gt; (startDraggingBlocks),
  startMultiSelect: () =&gt; (startMultiSelect),
  startTyping: () =&gt; (startTyping),
  stopDraggingBlocks: () =&gt; (stopDraggingBlocks),
  stopMultiSelect: () =&gt; (stopMultiSelect),
  stopTyping: () =&gt; (stopTyping),
  synchronizeTemplate: () =&gt; (synchronizeTemplate),
  toggleBlockHighlight: () =&gt; (toggleBlockHighlight),
  toggleBlockMode: () =&gt; (toggleBlockMode),
  toggleSelection: () =&gt; (toggleSelection),
  unsetBlockEditingMode: () =&gt; (unsetBlockEditingMode),
  updateBlock: () =&gt; (updateBlock),
  updateBlockAttributes: () =&gt; (updateBlockAttributes),
  updateBlockListSettings: () =&gt; (updateBlockListSettings),
  updateSettings: () =&gt; (updateSettings),
  validateBlocksToTemplate: () =&gt; (validateBlocksToTemplate)
});

// NAMESPACE OBJECT: ./node_modules/@wordpress/upload-media/build-module/store/selectors.js
var store_selectors_namespaceObject = {};
__webpack_require__.r(store_selectors_namespaceObject);
__webpack_require__.d(store_selectors_namespaceObject, {
  getItems: () =&gt; (getItems),
  getSettings: () =&gt; (selectors_getSettings),
  isUploading: () =&gt; (isUploading),
  isUploadingById: () =&gt; (isUploadingById),
  isUploadingByUrl: () =&gt; (isUploadingByUrl)
});

// NAMESPACE OBJECT: ./node_modules/@wordpress/upload-media/build-module/store/private-selectors.js
var store_private_selectors_namespaceObject = {};
__webpack_require__.r(store_private_selectors_namespaceObject);
__webpack_require__.d(store_private_selectors_namespaceObject, {
  getAllItems: () =&gt; (getAllItems),
  getBlobUrls: () =&gt; (getBlobUrls),
  getItem: () =&gt; (getItem),
  getPausedUploadForPost: () =&gt; (getPausedUploadForPost),
  isBatchUploaded: () =&gt; (isBatchUploaded),
  isPaused: () =&gt; (isPaused),
  isUploadingToPost: () =&gt; (isUploadingToPost)
});

// NAMESPACE OBJECT: ./node_modules/@wordpress/upload-media/build-module/store/actions.js
var store_actions_namespaceObject = {};
__webpack_require__.r(store_actions_namespaceObject);
__webpack_require__.d(store_actions_namespaceObject, {
  addItems: () =&gt; (addItems),
  cancelItem: () =&gt; (cancelItem)
});

// NAMESPACE OBJECT: ./node_modules/@wordpress/upload-media/build-module/store/private-actions.js
var store_private_actions_namespaceObject = {};
__webpack_require__.r(store_private_actions_namespaceObject);
__webpack_require__.d(store_private_actions_namespaceObject, {
  addItem: () =&gt; (addItem),
  finishOperation: () =&gt; (finishOperation),
  pauseQueue: () =&gt; (pauseQueue),
  prepareItem: () =&gt; (prepareItem),
  processItem: () =&gt; (processItem),
  removeItem: () =&gt; (removeItem),
  resumeQueue: () =&gt; (resumeQueue),
  revokeBlobUrls: () =&gt; (revokeBlobUrls),
  updateSettings: () =&gt; (private_actions_updateSettings),
  uploadItem: () =&gt; (uploadItem)
});

// NAMESPACE OBJECT: ./node_modules/@wordpress/block-editor/build-module/components/global-styles/index.js
var global_styles_namespaceObject = {};
__webpack_require__.r(global_styles_namespaceObject);
__webpack_require__.d(global_styles_namespaceObject, {
  AdvancedPanel: () =&gt; (AdvancedPanel),
  BackgroundPanel: () =&gt; (background_panel_BackgroundImagePanel),
  BorderPanel: () =&gt; (BorderPanel),
  ColorPanel: () =&gt; (ColorPanel),
  DimensionsPanel: () =&gt; (DimensionsPanel),
  FiltersPanel: () =&gt; (FiltersPanel),
  GlobalStylesContext: () =&gt; (GlobalStylesContext),
  ImageSettingsPanel: () =&gt; (ImageSettingsPanel),
  TypographyPanel: () =&gt; (TypographyPanel),
  areGlobalStyleConfigsEqual: () =&gt; (areGlobalStyleConfigsEqual),
  getBlockCSSSelector: () =&gt; (getBlockCSSSelector),
  getBlockSelectors: () =&gt; (getBlockSelectors),
  getGlobalStylesChanges: () =&gt; (getGlobalStylesChanges),
  getLayoutStyles: () =&gt; (getLayoutStyles),
  toStyles: () =&gt; (toStyles),
  useGlobalSetting: () =&gt; (useGlobalSetting),
  useGlobalStyle: () =&gt; (useGlobalStyle),
  useGlobalStylesOutput: () =&gt; (useGlobalStylesOutput),
  useGlobalStylesOutputWithConfig: () =&gt; (useGlobalStylesOutputWithConfig),
  useGlobalStylesReset: () =&gt; (useGlobalStylesReset),
  useHasBackgroundPanel: () =&gt; (useHasBackgroundPanel),
  useHasBorderPanel: () =&gt; (useHasBorderPanel),
  useHasBorderPanelControls: () =&gt; (useHasBorderPanelControls),
  useHasColorPanel: () =&gt; (useHasColorPanel),
  useHasDimensionsPanel: () =&gt; (useHasDimensionsPanel),
  useHasFiltersPanel: () =&gt; (useHasFiltersPanel),
  useHasImageSettingsPanel: () =&gt; (useHasImageSettingsPanel),
  useHasTypographyPanel: () =&gt; (useHasTypographyPanel),
  useSettingsForBlockElement: () =&gt; (useSettingsForBlockElement)
});

;// external [&quot;wp&quot;,&quot;blocks&quot;]
const external_wp_blocks_namespaceObject = window[&quot;wp&quot;][&quot;blocks&quot;];
;// external [&quot;wp&quot;,&quot;element&quot;]
const external_wp_element_namespaceObject = window[&quot;wp&quot;][&quot;element&quot;];
;// external [&quot;wp&quot;,&quot;data&quot;]
const external_wp_data_namespaceObject = window[&quot;wp&quot;][&quot;data&quot;];
;// external [&quot;wp&quot;,&quot;compose&quot;]
const external_wp_compose_namespaceObject = window[&quot;wp&quot;][&quot;compose&quot;];
;// external [&quot;wp&quot;,&quot;hooks&quot;]
const external_wp_hooks_namespaceObject = window[&quot;wp&quot;][&quot;hooks&quot;];
;// ./node_modules/@wordpress/block-editor/build-module/components/block-edit/context.js
/**
 * WordPress dependencies
 */

const mayDisplayControlsKey = Symbol(&#039;mayDisplayControls&#039;);
const mayDisplayParentControlsKey = Symbol(&#039;mayDisplayParentControls&#039;);
const blockEditingModeKey = Symbol(&#039;blockEditingMode&#039;);
const blockBindingsKey = Symbol(&#039;blockBindings&#039;);
const isPreviewModeKey = Symbol(&#039;isPreviewMode&#039;);
const DEFAULT_BLOCK_EDIT_CONTEXT = {
  name: &#039;&#039;,
  isSelected: false
};
const Context = (0,external_wp_element_namespaceObject.createContext)(DEFAULT_BLOCK_EDIT_CONTEXT);
const {
  Provider
} = Context;


/**
 * A hook that returns the block edit context.
 *
 * @return {Object} Block edit context
 */
function useBlockEditContext() {
  return (0,external_wp_element_namespaceObject.useContext)(Context);
}

;// external [&quot;wp&quot;,&quot;deprecated&quot;]
const external_wp_deprecated_namespaceObject = window[&quot;wp&quot;][&quot;deprecated&quot;];
var external_wp_deprecated_default = /*#__PURE__*/__webpack_require__.n(external_wp_deprecated_namespaceObject);
// EXTERNAL MODULE: ./node_modules/fast-deep-equal/es6/index.js
var es6 = __webpack_require__(7734);
var es6_default = /*#__PURE__*/__webpack_require__.n(es6);
;// external [&quot;wp&quot;,&quot;i18n&quot;]
const external_wp_i18n_namespaceObject = window[&quot;wp&quot;][&quot;i18n&quot;];
;// ./node_modules/@wordpress/block-editor/build-module/store/defaults.js
/**
 * WordPress dependencies
 */

const PREFERENCES_DEFAULTS = {
  insertUsage: {}
};

/**
 * The default editor settings
 *
 * @typedef {Object} SETTINGS_DEFAULT
 * @property {boolean}       alignWide                              Enable/Disable Wide/Full Alignments
 * @property {boolean}       supportsLayout                         Enable/disable layouts support in container blocks.
 * @property {boolean}       imageEditing                           Image Editing settings set to false to disable.
 * @property {Array}         imageSizes                             Available image sizes
 * @property {number}        maxWidth                               Max width to constraint resizing
 * @property {boolean|Array} allowedBlockTypes                      Allowed block types
 * @property {boolean}       hasFixedToolbar                        Whether or not the editor toolbar is fixed
 * @property {boolean}       distractionFree                        Whether or not the editor UI is distraction free
 * @property {boolean}       focusMode                              Whether the focus mode is enabled or not
 * @property {Array}         styles                                 Editor Styles
 * @property {boolean}       keepCaretInsideBlock                   Whether caret should move between blocks in edit mode
 * @property {string}        bodyPlaceholder                        Empty post placeholder
 * @property {string}        titlePlaceholder                       Empty title placeholder
 * @property {boolean}       canLockBlocks                          Whether the user can manage Block Lock state
 * @property {boolean}       codeEditingEnabled                     Whether or not the user can switch to the code editor
 * @property {boolean}       generateAnchors                        Enable/Disable auto anchor generation for Heading blocks
 * @property {boolean}       enableOpenverseMediaCategory           Enable/Disable the Openverse media category in the inserter.
 * @property {boolean}       clearBlockSelection                    Whether the block editor should clear selection on mousedown when a block is not clicked.
 * @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.
 * @property {boolean}       __experimentalBlockDirectory           Whether the user has enabled the Block Directory
 * @property {Array}         __experimentalBlockPatterns            Array of objects representing the block patterns
 * @property {Array}         __experimentalBlockPatternCategories   Array of objects representing the block pattern categories
 */
const SETTINGS_DEFAULTS = {
  alignWide: false,
  supportsLayout: true,
  // colors setting is not used anymore now defaults are passed from theme.json on the server and core has its own defaults.
  // The setting is only kept for backward compatibility purposes.
  colors: [{
    name: (0,external_wp_i18n_namespaceObject.__)(&#039;Black&#039;),
    slug: &#039;black&#039;,
    color: &#039;#000000&#039;
  }, {
    name: (0,external_wp_i18n_namespaceObject.__)(&#039;Cyan bluish gray&#039;),
    slug: &#039;cyan-bluish-gray&#039;,
    color: &#039;#abb8c3&#039;
  }, {
    name: (0,external_wp_i18n_namespaceObject.__)(&#039;White&#039;),
    slug: &#039;white&#039;,
    color: &#039;#ffffff&#039;
  }, {
    name: (0,external_wp_i18n_namespaceObject.__)(&#039;Pale pink&#039;),
    slug: &#039;pale-pink&#039;,
    color: &#039;#f78da7&#039;
  }, {
    name: (0,external_wp_i18n_namespaceObject.__)(&#039;Vivid red&#039;),
    slug: &#039;vivid-red&#039;,
    color: &#039;#cf2e2e&#039;
  }, {
    name: (0,external_wp_i18n_namespaceObject.__)(&#039;Luminous vivid orange&#039;),
    slug: &#039;luminous-vivid-orange&#039;,
    color: &#039;#ff6900&#039;
  }, {
    name: (0,external_wp_i18n_namespaceObject.__)(&#039;Luminous vivid amber&#039;),
    slug: &#039;luminous-vivid-amber&#039;,
    color: &#039;#fcb900&#039;
  }, {
    name: (0,external_wp_i18n_namespaceObject.__)(&#039;Light green cyan&#039;),
    slug: &#039;light-green-cyan&#039;,
    color: &#039;#7bdcb5&#039;
  }, {
    name: (0,external_wp_i18n_namespaceObject.__)(&#039;Vivid green cyan&#039;),
    slug: &#039;vivid-green-cyan&#039;,
    color: &#039;#00d084&#039;
  }, {
    name: (0,external_wp_i18n_namespaceObject.__)(&#039;Pale cyan blue&#039;),
    slug: &#039;pale-cyan-blue&#039;,
    color: &#039;#8ed1fc&#039;
  }, {
    name: (0,external_wp_i18n_namespaceObject.__)(&#039;Vivid cyan blue&#039;),
    slug: &#039;vivid-cyan-blue&#039;,
    color: &#039;#0693e3&#039;
  }, {
    name: (0,external_wp_i18n_namespaceObject.__)(&#039;Vivid purple&#039;),
    slug: &#039;vivid-purple&#039;,
    color: &#039;#9b51e0&#039;
  }],
  // fontSizes setting is not used anymore now defaults are passed from theme.json on the server and core has its own defaults.
  // The setting is only kept for backward compatibility purposes.
  fontSizes: [{
    name: (0,external_wp_i18n_namespaceObject._x)(&#039;Small&#039;, &#039;font size name&#039;),
    size: 13,
    slug: &#039;small&#039;
  }, {
    name: (0,external_wp_i18n_namespaceObject._x)(&#039;Normal&#039;, &#039;font size name&#039;),
    size: 16,
    slug: &#039;normal&#039;
  }, {
    name: (0,external_wp_i18n_namespaceObject._x)(&#039;Medium&#039;, &#039;font size name&#039;),
    size: 20,
    slug: &#039;medium&#039;
  }, {
    name: (0,external_wp_i18n_namespaceObject._x)(&#039;Large&#039;, &#039;font size name&#039;),
    size: 36,
    slug: &#039;large&#039;
  }, {
    name: (0,external_wp_i18n_namespaceObject._x)(&#039;Huge&#039;, &#039;font size name&#039;),
    size: 42,
    slug: &#039;huge&#039;
  }],
  // Image default size slug.
  imageDefaultSize: &#039;large&#039;,
  imageSizes: [{
    slug: &#039;thumbnail&#039;,
    name: (0,external_wp_i18n_namespaceObject.__)(&#039;Thumbnail&#039;)
  }, {
    slug: &#039;medium&#039;,
    name: (0,external_wp_i18n_namespaceObject.__)(&#039;Medium&#039;)
  }, {
    slug: &#039;large&#039;,
    name: (0,external_wp_i18n_namespaceObject.__)(&#039;Large&#039;)
  }, {
    slug: &#039;full&#039;,
    name: (0,external_wp_i18n_namespaceObject.__)(&#039;Full Size&#039;)
  }],
  // Allow plugin to disable Image Editor if need be.
  imageEditing: true,
  // This is current max width of the block inner area
  // It&#039;s used to constraint image resizing and this value could be overridden later by themes
  maxWidth: 580,
  // Allowed block types for the editor, defaulting to true (all supported).
  allowedBlockTypes: true,
  // Maximum upload size in bytes allowed for the site.
  maxUploadFileSize: 0,
  // List of allowed mime types and file extensions.
  allowedMimeTypes: null,
  // Allows to disable block locking interface.
  canLockBlocks: true,
  // Allows to disable Openverse media category in the inserter.
  enableOpenverseMediaCategory: true,
  clearBlockSelection: true,
  __experimentalCanUserUseUnfilteredHTML: false,
  __experimentalBlockDirectory: false,
  __mobileEnablePageTemplates: false,
  __experimentalBlockPatterns: [],
  __experimentalBlockPatternCategories: [],
  isPreviewMode: false,
  // These settings will be completely revamped in the future.
  // The goal is to evolve this into an API which will instruct
  // the block inspector to animate transitions between what it
  // displays based on the relationship between the selected block
  // and its parent, and only enable it if the parent is controlling
  // its children blocks.
  blockInspectorAnimation: {
    animationParent: &#039;core/navigation&#039;,
    &#039;core/navigation&#039;: {
      enterDirection: &#039;leftToRight&#039;
    },
    &#039;core/navigation-submenu&#039;: {
      enterDirection: &#039;rightToLeft&#039;
    },
    &#039;core/navigation-link&#039;: {
      enterDirection: &#039;rightToLeft&#039;
    },
    &#039;core/search&#039;: {
      enterDirection: &#039;rightToLeft&#039;
    },
    &#039;core/social-links&#039;: {
      enterDirection: &#039;rightToLeft&#039;
    },
    &#039;core/page-list&#039;: {
      enterDirection: &#039;rightToLeft&#039;
    },
    &#039;core/spacer&#039;: {
      enterDirection: &#039;rightToLeft&#039;
    },
    &#039;core/home-link&#039;: {
      enterDirection: &#039;rightToLeft&#039;
    },
    &#039;core/site-title&#039;: {
      enterDirection: &#039;rightToLeft&#039;
    },
    &#039;core/site-logo&#039;: {
      enterDirection: &#039;rightToLeft&#039;
    }
  },
  generateAnchors: false,
  // gradients setting is not used anymore now defaults are passed from theme.json on the server and core has its own defaults.
  // The setting is only kept for backward compatibility purposes.
  gradients: [{
    name: (0,external_wp_i18n_namespaceObject.__)(&#039;Vivid cyan blue to vivid purple&#039;),
    gradient: &#039;linear-gradient(135deg,rgba(6,147,227,1) 0%,rgb(155,81,224) 100%)&#039;,
    slug: &#039;vivid-cyan-blue-to-vivid-purple&#039;
  }, {
    name: (0,external_wp_i18n_namespaceObject.__)(&#039;Light green cyan to vivid green cyan&#039;),
    gradient: &#039;linear-gradient(135deg,rgb(122,220,180) 0%,rgb(0,208,130) 100%)&#039;,
    slug: &#039;light-green-cyan-to-vivid-green-cyan&#039;
  }, {
    name: (0,external_wp_i18n_namespaceObject.__)(&#039;Luminous vivid amber to luminous vivid orange&#039;),
    gradient: &#039;linear-gradient(135deg,rgba(252,185,0,1) 0%,rgba(255,105,0,1) 100%)&#039;,
    slug: &#039;luminous-vivid-amber-to-luminous-vivid-orange&#039;
  }, {
    name: (0,external_wp_i18n_namespaceObject.__)(&#039;Luminous vivid orange to vivid red&#039;),
    gradient: &#039;linear-gradient(135deg,rgba(255,105,0,1) 0%,rgb(207,46,46) 100%)&#039;,
    slug: &#039;luminous-vivid-orange-to-vivid-red&#039;
  }, {
    name: (0,external_wp_i18n_namespaceObject.__)(&#039;Very light gray to cyan bluish gray&#039;),
    gradient: &#039;linear-gradient(135deg,rgb(238,238,238) 0%,rgb(169,184,195) 100%)&#039;,
    slug: &#039;very-light-gray-to-cyan-bluish-gray&#039;
  }, {
    name: (0,external_wp_i18n_namespaceObject.__)(&#039;Cool to warm spectrum&#039;),
    gradient: &#039;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%)&#039;,
    slug: &#039;cool-to-warm-spectrum&#039;
  }, {
    name: (0,external_wp_i18n_namespaceObject.__)(&#039;Blush light purple&#039;),
    gradient: &#039;linear-gradient(135deg,rgb(255,206,236) 0%,rgb(152,150,240) 100%)&#039;,
    slug: &#039;blush-light-purple&#039;
  }, {
    name: (0,external_wp_i18n_namespaceObject.__)(&#039;Blush bordeaux&#039;),
    gradient: &#039;linear-gradient(135deg,rgb(254,205,165) 0%,rgb(254,45,45) 50%,rgb(107,0,62) 100%)&#039;,
    slug: &#039;blush-bordeaux&#039;
  }, {
    name: (0,external_wp_i18n_namespaceObject.__)(&#039;Luminous dusk&#039;),
    gradient: &#039;linear-gradient(135deg,rgb(255,203,112) 0%,rgb(199,81,192) 50%,rgb(65,88,208) 100%)&#039;,
    slug: &#039;luminous-dusk&#039;
  }, {
    name: (0,external_wp_i18n_namespaceObject.__)(&#039;Pale ocean&#039;),
    gradient: &#039;linear-gradient(135deg,rgb(255,245,203) 0%,rgb(182,227,212) 50%,rgb(51,167,181) 100%)&#039;,
    slug: &#039;pale-ocean&#039;
  }, {
    name: (0,external_wp_i18n_namespaceObject.__)(&#039;Electric grass&#039;),
    gradient: &#039;linear-gradient(135deg,rgb(202,248,128) 0%,rgb(113,206,126) 100%)&#039;,
    slug: &#039;electric-grass&#039;
  }, {
    name: (0,external_wp_i18n_namespaceObject.__)(&#039;Midnight&#039;),
    gradient: &#039;linear-gradient(135deg,rgb(2,3,129) 0%,rgb(40,116,252) 100%)&#039;,
    slug: &#039;midnight&#039;
  }],
  __unstableResolvedAssets: {
    styles: [],
    scripts: []
  }
};

;// ./node_modules/@wordpress/block-editor/build-module/store/array.js
/**
 * Insert one or multiple elements into a given position of an array.
 *
 * @param {Array}  array    Source array.
 * @param {*}      elements Elements to insert.
 * @param {number} index    Insert Position.
 *
 * @return {Array} Result.
 */
function insertAt(array, elements, index) {
  return [...array.slice(0, index), ...(Array.isArray(elements) ? elements : [elements]), ...array.slice(index)];
}

/**
 * Moves an element in an array.
 *
 * @param {Array}  array Source array.
 * @param {number} from  Source index.
 * @param {number} to    Destination index.
 * @param {number} count Number of elements to move.
 *
 * @return {Array} Result.
 */
function moveTo(array, from, to, count = 1) {
  const withoutMovedElements = [...array];
  withoutMovedElements.splice(from, count);
  return insertAt(withoutMovedElements, array.slice(from, from + count), to);
}

;// ./node_modules/@wordpress/block-editor/build-module/store/private-keys.js
const globalStylesDataKey = Symbol(&#039;globalStylesDataKey&#039;);
const globalStylesLinksDataKey = Symbol(&#039;globalStylesLinks&#039;);
const selectBlockPatternsKey = Symbol(&#039;selectBlockPatternsKey&#039;);
const reusableBlocksSelectKey = Symbol(&#039;reusableBlocksSelect&#039;);
const sectionRootClientIdKey = Symbol(&#039;sectionRootClientIdKey&#039;);

;// external [&quot;wp&quot;,&quot;privateApis&quot;]
const external_wp_privateApis_namespaceObject = window[&quot;wp&quot;][&quot;privateApis&quot;];
;// ./node_modules/@wordpress/block-editor/build-module/lock-unlock.js
/**
 * WordPress dependencies
 */

const {
  lock,
  unlock
} = (0,external_wp_privateApis_namespaceObject.__dangerousOptInToUnstableAPIsOnlyForCoreModules)(&#039;I acknowledge private features are not for use in themes or plugins and doing so will break in the next version of WordPress.&#039;, &#039;@wordpress/block-editor&#039;);

;// ./node_modules/@wordpress/block-editor/build-module/store/reducer.js
/**
 * External dependencies
 */


/**
 * WordPress dependencies
 */





/**
 * Internal dependencies
 */




const {
  isContentBlock
} = unlock(external_wp_blocks_namespaceObject.privateApis);
const identity = x =&gt; x;

/**
 * Given an array of blocks, returns an object where each key is a nesting
 * context, the value of which is an array of block client IDs existing within
 * that nesting context.
 *
 * @param {Array}   blocks       Blocks to map.
 * @param {?string} rootClientId Assumed root client ID.
 *
 * @return {Object} Block order map object.
 */
function mapBlockOrder(blocks, rootClientId = &#039;&#039;) {
  const result = new Map();
  const current = [];
  result.set(rootClientId, current);
  blocks.forEach(block =&gt; {
    const {
      clientId,
      innerBlocks
    } = block;
    current.push(clientId);
    mapBlockOrder(innerBlocks, clientId).forEach((order, subClientId) =&gt; {
      result.set(subClientId, order);
    });
  });
  return result;
}

/**
 * Given an array of blocks, returns an object where each key contains
 * the clientId of the block and the value is the parent of the block.
 *
 * @param {Array}   blocks       Blocks to map.
 * @param {?string} rootClientId Assumed root client ID.
 *
 * @return {Object} Block order map object.
 */
function mapBlockParents(blocks, rootClientId = &#039;&#039;) {
  const result = [];
  const stack = [[rootClientId, blocks]];
  while (stack.length) {
    const [parent, currentBlocks] = stack.shift();
    currentBlocks.forEach(({
      innerBlocks,
      ...block
    }) =&gt; {
      result.push([block.clientId, parent]);
      if (innerBlocks?.length) {
        stack.push([block.clientId, innerBlocks]);
      }
    });
  }
  return result;
}

/**
 * Helper method to iterate through all blocks, recursing into inner blocks,
 * applying a transformation function to each one.
 * Returns a flattened object with the transformed blocks.
 *
 * @param {Array}    blocks    Blocks to flatten.
 * @param {Function} transform Transforming function to be applied to each block.
 *
 * @return {Array} Flattened object.
 */
function flattenBlocks(blocks, transform = identity) {
  const result = [];
  const stack = [...blocks];
  while (stack.length) {
    const {
      innerBlocks,
      ...block
    } = stack.shift();
    stack.push(...innerBlocks);
    result.push([block.clientId, transform(block)]);
  }
  return result;
}
function getFlattenedClientIds(blocks) {
  const result = {};
  const stack = [...blocks];
  while (stack.length) {
    const {
      innerBlocks,
      ...block
    } = stack.shift();
    stack.push(...innerBlocks);
    result[block.clientId] = true;
  }
  return result;
}

/**
 * Given an array of blocks, returns an object containing all blocks, without
 * attributes, recursing into inner blocks. Keys correspond to the block client
 * ID, the value of which is the attributes object.
 *
 * @param {Array} blocks Blocks to flatten.
 *
 * @return {Array} Flattened block attributes object.
 */
function getFlattenedBlocksWithoutAttributes(blocks) {
  return flattenBlocks(blocks, block =&gt; {
    const {
      attributes,
      ...restBlock
    } = block;
    return restBlock;
  });
}

/**
 * Given an array of blocks, returns an object containing all block attributes,
 * recursing into inner blocks. Keys correspond to the block client ID, the
 * value of which is the attributes object.
 *
 * @param {Array} blocks Blocks to flatten.
 *
 * @return {Array} Flattened block attributes object.
 */
function getFlattenedBlockAttributes(blocks) {
  return flattenBlocks(blocks, block =&gt; block.attributes);
}

/**
 * Returns true if the two object arguments have the same keys, or false
 * otherwise.
 *
 * @param {Object} a First object.
 * @param {Object} b Second object.
 *
 * @return {boolean} Whether the two objects have the same keys.
 */
function hasSameKeys(a, b) {
  return es6_default()(Object.keys(a), Object.keys(b));
}

/**
 * Returns true if, given the currently dispatching action and the previously
 * dispatched action, the two actions are updating the same block attribute, or
 * false otherwise.
 *
 * @param {Object} action     Currently dispatching action.
 * @param {Object} lastAction Previously dispatched action.
 *
 * @return {boolean} Whether actions are updating the same block attribute.
 */
function isUpdatingSameBlockAttribute(action, lastAction) {
  return action.type === &#039;UPDATE_BLOCK_ATTRIBUTES&#039; &amp;&amp; lastAction !== undefined &amp;&amp; lastAction.type === &#039;UPDATE_BLOCK_ATTRIBUTES&#039; &amp;&amp; es6_default()(action.clientIds, lastAction.clientIds) &amp;&amp; hasSameKeys(action.attributes, lastAction.attributes);
}
function updateBlockTreeForBlocks(state, blocks) {
  const treeToUpdate = state.tree;
  const stack = [...blocks];
  const flattenedBlocks = [...blocks];
  while (stack.length) {
    const block = stack.shift();
    stack.push(...block.innerBlocks);
    flattenedBlocks.push(...block.innerBlocks);
  }
  // Create objects before mutating them, that way it&#039;s always defined.
  for (const block of flattenedBlocks) {
    treeToUpdate.set(block.clientId, {});
  }
  for (const block of flattenedBlocks) {
    treeToUpdate.set(block.clientId, Object.assign(treeToUpdate.get(block.clientId), {
      ...state.byClientId.get(block.clientId),
      attributes: state.attributes.get(block.clientId),
      innerBlocks: block.innerBlocks.map(subBlock =&gt; treeToUpdate.get(subBlock.clientId))
    }));
  }
}
function updateParentInnerBlocksInTree(state, updatedClientIds, updateChildrenOfUpdatedClientIds = false) {
  const treeToUpdate = state.tree;
  const uncontrolledParents = new Set([]);
  const controlledParents = new Set();
  for (const clientId of updatedClientIds) {
    let current = updateChildrenOfUpdatedClientIds ? clientId : state.parents.get(clientId);
    do {
      if (state.controlledInnerBlocks[current]) {
        // Should stop on controlled blocks.
        // If we reach a controlled parent, break out of the loop.
        controlledParents.add(current);
        break;
      } else {
        // Else continue traversing up through parents.
        uncontrolledParents.add(current);
        current = state.parents.get(current);
      }
    } while (current !== undefined);
  }

  // To make sure the order of assignments doesn&#039;t matter,
  // we first create empty objects and mutates the inner blocks later.
  for (const clientId of uncontrolledParents) {
    treeToUpdate.set(clientId, {
      ...treeToUpdate.get(clientId)
    });
  }
  for (const clientId of uncontrolledParents) {
    treeToUpdate.get(clientId).innerBlocks = (state.order.get(clientId) || []).map(subClientId =&gt; treeToUpdate.get(subClientId));
  }

  // Controlled parent blocks, need a dedicated key for their inner blocks
  // to be used when doing getBlocks( controlledBlockClientId ).
  for (const clientId of controlledParents) {
    treeToUpdate.set(&#039;controlled||&#039; + clientId, {
      innerBlocks: (state.order.get(clientId) || []).map(subClientId =&gt; treeToUpdate.get(subClientId))
    });
  }
}

/**
 * Higher-order reducer intended to compute full block objects key for each block in the post.
 * This is a denormalization to optimize the performance of the getBlock selectors and avoid
 * recomputing the block objects and avoid heavy memoization.
 *
 * @param {Function} reducer Original reducer function.
 *
 * @return {Function} Enhanced reducer function.
 */
const withBlockTree = reducer =&gt; (state = {}, action) =&gt; {
  const newState = reducer(state, action);
  if (newState === state) {
    return state;
  }
  newState.tree = state.tree ? state.tree : new Map();
  switch (action.type) {
    case &#039;RECEIVE_BLOCKS&#039;:
    case &#039;INSERT_BLOCKS&#039;:
      {
        newState.tree = new Map(newState.tree);
        updateBlockTreeForBlocks(newState, action.blocks);
        updateParentInnerBlocksInTree(newState, action.rootClientId ? [action.rootClientId] : [&#039;&#039;], true);
        break;
      }
    case &#039;UPDATE_BLOCK&#039;:
      newState.tree = new Map(newState.tree);
      newState.tree.set(action.clientId, {
        ...newState.tree.get(action.clientId),
        ...newState.byClientId.get(action.clientId),
        attributes: newState.attributes.get(action.clientId)
      });
      updateParentInnerBlocksInTree(newState, [action.clientId], false);
      break;
    case &#039;SYNC_DERIVED_BLOCK_ATTRIBUTES&#039;:
    case &#039;UPDATE_BLOCK_ATTRIBUTES&#039;:
      {
        newState.tree = new Map(newState.tree);
        action.clientIds.forEach(clientId =&gt; {
          newState.tree.set(clientId, {
            ...newState.tree.get(clientId),
            attributes: newState.attributes.get(clientId)
          });
        });
        updateParentInnerBlocksInTree(newState, action.clientIds, false);
        break;
      }
    case &#039;REPLACE_BLOCKS_AUGMENTED_WITH_CHILDREN&#039;:
      {
        const inserterClientIds = getFlattenedClientIds(action.blocks);
        newState.tree = new Map(newState.tree);
        action.replacedClientIds.forEach(clientId =&gt; {
          newState.tree.delete(clientId);
          // Controlled inner blocks are only removed
          // if the block doesn&#039;t move to another position
          // otherwise their content will be lost.
          if (!inserterClientIds[clientId]) {
            newState.tree.delete(&#039;controlled||&#039; + clientId);
          }
        });
        updateBlockTreeForBlocks(newState, action.blocks);
        updateParentInnerBlocksInTree(newState, action.blocks.map(b =&gt; b.clientId), false);

        // If there are no replaced blocks, it means we&#039;re removing blocks so we need to update their parent.
        const parentsOfRemovedBlocks = [];
        for (const clientId of action.clientIds) {
          const parentId = state.parents.get(clientId);
          if (parentId !== undefined &amp;&amp; (parentId === &#039;&#039; || newState.byClientId.get(parentId))) {
            parentsOfRemovedBlocks.push(parentId);
          }
        }
        updateParentInnerBlocksInTree(newState, parentsOfRemovedBlocks, true);
        break;
      }
    case &#039;REMOVE_BLOCKS_AUGMENTED_WITH_CHILDREN&#039;:
      const parentsOfRemovedBlocks = [];
      for (const clientId of action.clientIds) {
        const parentId = state.parents.get(clientId);
        if (parentId !== undefined &amp;&amp; (parentId === &#039;&#039; || newState.byClientId.get(parentId))) {
          parentsOfRemovedBlocks.push(parentId);
        }
      }
      newState.tree = new Map(newState.tree);
      action.removedClientIds.forEach(clientId =&gt; {
        newState.tree.delete(clientId);
        newState.tree.delete(&#039;controlled||&#039; + clientId);
      });
      updateParentInnerBlocksInTree(newState, parentsOfRemovedBlocks, true);
      break;
    case &#039;MOVE_BLOCKS_TO_POSITION&#039;:
      {
        const updatedBlockUids = [];
        if (action.fromRootClientId) {
          updatedBlockUids.push(action.fromRootClientId);
        } else {
          updatedBlockUids.push(&#039;&#039;);
        }
        if (action.toRootClientId) {
          updatedBlockUids.push(action.toRootClientId);
        }
        newState.tree = new Map(newState.tree);
        updateParentInnerBlocksInTree(newState, updatedBlockUids, true);
        break;
      }
    case &#039;MOVE_BLOCKS_UP&#039;:
    case &#039;MOVE_BLOCKS_DOWN&#039;:
      {
        const updatedBlockUids = [action.rootClientId ? action.rootClientId : &#039;&#039;];
        newState.tree = new Map(newState.tree);
        updateParentInnerBlocksInTree(newState, updatedBlockUids, true);
        break;
      }
    case &#039;SAVE_REUSABLE_BLOCK_SUCCESS&#039;:
      {
        const updatedBlockUids = [];
        newState.attributes.forEach((attributes, clientId) =&gt; {
          if (newState.byClientId.get(clientId).name === &#039;core/block&#039; &amp;&amp; attributes.ref === action.updatedId) {
            updatedBlockUids.push(clientId);
          }
        });
        newState.tree = new Map(newState.tree);
        updatedBlockUids.forEach(clientId =&gt; {
          newState.tree.set(clientId, {
            ...newState.byClientId.get(clientId),
            attributes: newState.attributes.get(clientId),
            innerBlocks: newState.tree.get(clientId).innerBlocks
          });
        });
        updateParentInnerBlocksInTree(newState, updatedBlockUids, false);
      }
  }
  return newState;
};

/**
 * Higher-order reducer intended to augment the blocks reducer, assigning an
 * `isPersistentChange` property value corresponding to whether a change in
 * state can be considered as persistent. All changes are considered persistent
 * except when updating the same block attribute as in the previous action.
 *
 * @param {Function} reducer Original reducer function.
 *
 * @return {Function} Enhanced reducer function.
 */
function withPersistentBlockChange(reducer) {
  let lastAction;
  let markNextChangeAsNotPersistent = false;
  let explicitPersistent;
  return (state, action) =&gt; {
    let nextState = reducer(state, action);
    let nextIsPersistentChange;
    if (action.type === &#039;SET_EXPLICIT_PERSISTENT&#039;) {
      var _state$isPersistentCh;
      explicitPersistent = action.isPersistentChange;
      nextIsPersistentChange = (_state$isPersistentCh = state.isPersistentChange) !== null &amp;&amp; _state$isPersistentCh !== void 0 ? _state$isPersistentCh : true;
    }
    if (explicitPersistent !== undefined) {
      nextIsPersistentChange = explicitPersistent;
      return nextIsPersistentChange === nextState.isPersistentChange ? nextState : {
        ...nextState,
        isPersistentChange: nextIsPersistentChange
      };
    }
    const isExplicitPersistentChange = action.type === &#039;MARK_LAST_CHANGE_AS_PERSISTENT&#039; || markNextChangeAsNotPersistent;

    // Defer to previous state value (or default) unless changing or
    // explicitly marking as persistent.
    if (state === nextState &amp;&amp; !isExplicitPersistentChange) {
      var _state$isPersistentCh2;
      markNextChangeAsNotPersistent = action.type === &#039;MARK_NEXT_CHANGE_AS_NOT_PERSISTENT&#039;;
      nextIsPersistentChange = (_state$isPersistentCh2 = state?.isPersistentChange) !== null &amp;&amp; _state$isPersistentCh2 !== void 0 ? _state$isPersistentCh2 : true;
      if (state.isPersistentChange === nextIsPersistentChange) {
        return state;
      }
      return {
        ...nextState,
        isPersistentChange: nextIsPersistentChange
      };
    }
    nextState = {
      ...nextState,
      isPersistentChange: isExplicitPersistentChange ? !markNextChangeAsNotPersistent : !isUpdatingSameBlockAttribute(action, lastAction)
    };

    // In comparing against the previous action, consider only those which
    // would have qualified as one which would have been ignored or not
    // have resulted in a changed state.
    lastAction = action;
    markNextChangeAsNotPersistent = action.type === &#039;MARK_NEXT_CHANGE_AS_NOT_PERSISTENT&#039;;
    return nextState;
  };
}

/**
 * Higher-order reducer intended to augment the blocks reducer, assigning an
 * `isIgnoredChange` property value corresponding to whether a change in state
 * can be considered as ignored. A change is considered ignored when the result
 * of an action not incurred by direct user interaction.
 *
 * @param {Function} reducer Original reducer function.
 *
 * @return {Function} Enhanced reducer function.
 */
function withIgnoredBlockChange(reducer) {
  /**
   * Set of action types for which a blocks state change should be ignored.
   *
   * @type {Set}
   */
  const IGNORED_ACTION_TYPES = new Set([&#039;RECEIVE_BLOCKS&#039;]);
  return (state, action) =&gt; {
    const nextState = reducer(state, action);
    if (nextState !== state) {
      nextState.isIgnoredChange = IGNORED_ACTION_TYPES.has(action.type);
    }
    return nextState;
  };
}

/**
 * Higher-order reducer targeting the combined blocks reducer, augmenting
 * block client IDs in remove action to include cascade of inner blocks.
 *
 * @param {Function} reducer Original reducer function.
 *
 * @return {Function} Enhanced reducer function.
 */
const withInnerBlocksRemoveCascade = reducer =&gt; (state, action) =&gt; {
  // Gets all children which need to be removed.
  const getAllChildren = clientIds =&gt; {
    let result = clientIds;
    for (let i = 0; i &lt; result.length; i++) {
      if (!state.order.get(result[i]) || action.keepControlledInnerBlocks &amp;&amp; action.keepControlledInnerBlocks[result[i]]) {
        continue;
      }
      if (result === clientIds) {
        result = [...result];
      }
      result.push(...state.order.get(result[i]));
    }
    return result;
  };
  if (state) {
    switch (action.type) {
      case &#039;REMOVE_BLOCKS&#039;:
        action = {
          ...action,
          type: &#039;REMOVE_BLOCKS_AUGMENTED_WITH_CHILDREN&#039;,
          removedClientIds: getAllChildren(action.clientIds)
        };
        break;
      case &#039;REPLACE_BLOCKS&#039;:
        action = {
          ...action,
          type: &#039;REPLACE_BLOCKS_AUGMENTED_WITH_CHILDREN&#039;,
          replacedClientIds: getAllChildren(action.clientIds)
        };
        break;
    }
  }
  return reducer(state, action);
};

/**
 * Higher-order reducer which targets the combined blocks reducer and handles
 * the `RESET_BLOCKS` action. When dispatched, this action will replace all
 * blocks that exist in the post, leaving blocks that exist only in state (e.g.
 * reusable blocks and blocks controlled by inner blocks controllers) alone.
 *
 * @param {Function} reducer Original reducer function.
 *
 * @return {Function} Enhanced reducer function.
 */
const withBlockReset = reducer =&gt; (state, action) =&gt; {
  if (action.type === &#039;RESET_BLOCKS&#039;) {
    const newState = {
      ...state,
      byClientId: new Map(getFlattenedBlocksWithoutAttributes(action.blocks)),
      attributes: new Map(getFlattenedBlockAttributes(action.blocks)),
      order: mapBlockOrder(action.blocks),
      parents: new Map(mapBlockParents(action.blocks)),
      controlledInnerBlocks: {}
    };
    newState.tree = new Map(state?.tree);
    updateBlockTreeForBlocks(newState, action.blocks);
    newState.tree.set(&#039;&#039;, {
      innerBlocks: action.blocks.map(subBlock =&gt; newState.tree.get(subBlock.clientId))
    });
    return newState;
  }
  return reducer(state, action);
};

/**
 * Higher-order reducer which targets the combined blocks reducer and handles
 * the `REPLACE_INNER_BLOCKS` action. When dispatched, this action the state
 * should become equivalent to the execution of a `REMOVE_BLOCKS` action
 * containing all the child&#039;s of the root block followed by the execution of
 * `INSERT_BLOCKS` with the new blocks.
 *
 * @param {Function} reducer Original reducer function.
 *
 * @return {Function} Enhanced reducer function.
 */
const withReplaceInnerBlocks = reducer =&gt; (state, action) =&gt; {
  if (action.type !== &#039;REPLACE_INNER_BLOCKS&#039;) {
    return reducer(state, action);
  }

  // Finds every nested inner block controller. We must check the action blocks
  // and not just the block parent state because some inner block controllers
  // should be deleted if specified, whereas others should not be deleted. If
  // a controlled should not be deleted, then we need to avoid deleting its
  // inner blocks from the block state because its inner blocks will not be
  // attached to the block in the action.
  const nestedControllers = {};
  if (Object.keys(state.controlledInnerBlocks).length) {
    const stack = [...action.blocks];
    while (stack.length) {
      const {
        innerBlocks,
        ...block
      } = stack.shift();
      stack.push(...innerBlocks);
      if (!!state.controlledInnerBlocks[block.clientId]) {
        nestedControllers[block.clientId] = true;
      }
    }
  }

  // The `keepControlledInnerBlocks` prop will keep the inner blocks of the
  // marked block in the block state so that they can be reattached to the
  // marked block when we re-insert everything a few lines below.
  let stateAfterBlocksRemoval = state;
  if (state.order.get(action.rootClientId)) {
    stateAfterBlocksRemoval = reducer(stateAfterBlocksRemoval, {
      type: &#039;REMOVE_BLOCKS&#039;,
      keepControlledInnerBlocks: nestedControllers,
      clientIds: state.order.get(action.rootClientId)
    });
  }
  let stateAfterInsert = stateAfterBlocksRemoval;
  if (action.blocks.length) {
    stateAfterInsert = reducer(stateAfterInsert, {
      ...action,
      type: &#039;INSERT_BLOCKS&#039;,
      index: 0
    });

    // We need to re-attach the controlled inner blocks to the blocks tree and
    // preserve their block order. Otherwise, an inner block controller&#039;s blocks
    // will be deleted entirely from its entity.
    const stateAfterInsertOrder = new Map(stateAfterInsert.order);
    Object.keys(nestedControllers).forEach(key =&gt; {
      if (state.order.get(key)) {
        stateAfterInsertOrder.set(key, state.order.get(key));
      }
    });
    stateAfterInsert.order = stateAfterInsertOrder;
    stateAfterInsert.tree = new Map(stateAfterInsert.tree);
    Object.keys(nestedControllers).forEach(_key =&gt; {
      const key = `controlled||${_key}`;
      if (state.tree.has(key)) {
        stateAfterInsert.tree.set(key, state.tree.get(key));
      }
    });
  }
  return stateAfterInsert;
};

/**
 * Higher-order reducer which targets the combined blocks reducer and handles
 * the `SAVE_REUSABLE_BLOCK_SUCCESS` action. This action can&#039;t be handled by
 * regular reducers and needs a higher-order reducer since it needs access to
 * both `byClientId` and `attributes` simultaneously.
 *
 * @param {Function} reducer Original reducer function.
 *
 * @return {Function} Enhanced reducer function.
 */
const withSaveReusableBlock = reducer =&gt; (state, action) =&gt; {
  if (state &amp;&amp; action.type === &#039;SAVE_REUSABLE_BLOCK_SUCCESS&#039;) {
    const {
      id,
      updatedId
    } = action;

    // If a temporary reusable block is saved, we swap the temporary id with the final one.
    if (id === updatedId) {
      return state;
    }
    state = {
      ...state
    };
    state.attributes = new Map(state.attributes);
    state.attributes.forEach((attributes, clientId) =&gt; {
      const {
        name
      } = state.byClientId.get(clientId);
      if (name === &#039;core/block&#039; &amp;&amp; attributes.ref === id) {
        state.attributes.set(clientId, {
          ...attributes,
          ref: updatedId
        });
      }
    });
  }
  return reducer(state, action);
};
/**
 * Higher-order reducer which removes blocks from state when switching parent block controlled state.
 *
 * @param {Function} reducer Original reducer function.
 *
 * @return {Function} Enhanced reducer function.
 */
const withResetControlledBlocks = reducer =&gt; (state, action) =&gt; {
  if (action.type === &#039;SET_HAS_CONTROLLED_INNER_BLOCKS&#039;) {
    // when switching a block from controlled to uncontrolled or inverse,
    // we need to remove its content first.
    const tempState = reducer(state, {
      type: &#039;REPLACE_INNER_BLOCKS&#039;,
      rootClientId: action.clientId,
      blocks: []
    });
    return reducer(tempState, action);
  }
  return reducer(state, action);
};

/**
 * Reducer returning the blocks state.
 *
 * @param {Object} state  Current state.
 * @param {Object} action Dispatched action.
 *
 * @return {Object} Updated state.
 */
const blocks = (0,external_wp_compose_namespaceObject.pipe)(external_wp_data_namespaceObject.combineReducers, withSaveReusableBlock,
// Needs to be before withBlockCache.
withBlockTree,
// Needs to be before withInnerBlocksRemoveCascade.
withInnerBlocksRemoveCascade, withReplaceInnerBlocks,
// Needs to be after withInnerBlocksRemoveCascade.
withBlockReset, withPersistentBlockChange, withIgnoredBlockChange, withResetControlledBlocks)({
  // The state is using a Map instead of a plain object for performance reasons.
  // You can run the &quot;./test/performance.js&quot; unit test to check the impact
  // code changes can have on this reducer.
  byClientId(state = new Map(), action) {
    switch (action.type) {
      case &#039;RECEIVE_BLOCKS&#039;:
      case &#039;INSERT_BLOCKS&#039;:
        {
          const newState = new Map(state);
          getFlattenedBlocksWithoutAttributes(action.blocks).forEach(([key, value]) =&gt; {
            newState.set(key, value);
          });
          return newState;
        }
      case &#039;UPDATE_BLOCK&#039;:
        {
          // Ignore updates if block isn&#039;t known.
          if (!state.has(action.clientId)) {
            return state;
          }

          // Do nothing if only attributes change.
          const {
            attributes,
            ...changes
          } = action.updates;
          if (Object.values(changes).length === 0) {
            return state;
          }
          const newState = new Map(state);
          newState.set(action.clientId, {
            ...state.get(action.clientId),
            ...changes
          });
          return newState;
        }
      case &#039;REPLACE_BLOCKS_AUGMENTED_WITH_CHILDREN&#039;:
        {
          if (!action.blocks) {
            return state;
          }
          const newState = new Map(state);
          action.replacedClientIds.forEach(clientId =&gt; {
            newState.delete(clientId);
          });
          getFlattenedBlocksWithoutAttributes(action.blocks).forEach(([key, value]) =&gt; {
            newState.set(key, value);
          });
          return newState;
        }
      case &#039;REMOVE_BLOCKS_AUGMENTED_WITH_CHILDREN&#039;:
        {
          const newState = new Map(state);
          action.removedClientIds.forEach(clientId =&gt; {
            newState.delete(clientId);
          });
          return newState;
        }
    }
    return state;
  },
  // The state is using a Map instead of a plain object for performance reasons.
  // You can run the &quot;./test/performance.js&quot; unit test to check the impact
  // code changes can have on this reducer.
  attributes(state = new Map(), action) {
    switch (action.type) {
      case &#039;RECEIVE_BLOCKS&#039;:
      case &#039;INSERT_BLOCKS&#039;:
        {
          const newState = new Map(state);
          getFlattenedBlockAttributes(action.blocks).forEach(([key, value]) =&gt; {
            newState.set(key, value);
          });
          return newState;
        }
      case &#039;UPDATE_BLOCK&#039;:
        {
          // Ignore updates if block isn&#039;t known or there are no attribute changes.
          if (!state.get(action.clientId) || !action.updates.attributes) {
            return state;
          }
          const newState = new Map(state);
          newState.set(action.clientId, {
            ...state.get(action.clientId),
            ...action.updates.attributes
          });
          return newState;
        }
      case &#039;SYNC_DERIVED_BLOCK_ATTRIBUTES&#039;:
      case &#039;UPDATE_BLOCK_ATTRIBUTES&#039;:
        {
          // Avoid a state change if none of the block IDs are known.
          if (action.clientIds.every(id =&gt; !state.get(id))) {
            return state;
          }
          let hasChange = false;
          const newState = new Map(state);
          for (const clientId of action.clientIds) {
            var _action$attributes;
            const updatedAttributeEntries = Object.entries(action.uniqueByBlock ? action.attributes[clientId] : (_action$attributes = action.attributes) !== null &amp;&amp; _action$attributes !== void 0 ? _action$attributes : {});
            if (updatedAttributeEntries.length === 0) {
              continue;
            }
            let hasUpdatedAttributes = false;
            const existingAttributes = state.get(clientId);
            const newAttributes = {};
            updatedAttributeEntries.forEach(([key, value]) =&gt; {
              if (existingAttributes[key] !== value) {
                hasUpdatedAttributes = true;
                newAttributes[key] = value;
              }
            });
            hasChange = hasChange || hasUpdatedAttributes;
            if (hasUpdatedAttributes) {
              newState.set(clientId, {
                ...existingAttributes,
                ...newAttributes
              });
            }
          }
          return hasChange ? newState : state;
        }
      case &#039;REPLACE_BLOCKS_AUGMENTED_WITH_CHILDREN&#039;:
        {
          if (!action.blocks) {
            return state;
          }
          const newState = new Map(state);
          action.replacedClientIds.forEach(clientId =&gt; {
            newState.delete(clientId);
          });
          getFlattenedBlockAttributes(action.blocks).forEach(([key, value]) =&gt; {
            newState.set(key, value);
          });
          return newState;
        }
      case &#039;REMOVE_BLOCKS_AUGMENTED_WITH_CHILDREN&#039;:
        {
          const newState = new Map(state);
          action.removedClientIds.forEach(clientId =&gt; {
            newState.delete(clientId);
          });
          return newState;
        }
    }
    return state;
  },
  // The state is using a Map instead of a plain object for performance reasons.
  // You can run the &quot;./test/performance.js&quot; unit test to check the impact
  // code changes can have on this reducer.
  order(state = new Map(), action) {
    switch (action.type) {
      case &#039;RECEIVE_BLOCKS&#039;:
        {
          var _state$get;
          const blockOrder = mapBlockOrder(action.blocks);
          const newState = new Map(state);
          blockOrder.forEach((order, clientId) =&gt; {
            if (clientId !== &#039;&#039;) {
              newState.set(clientId, order);
            }
          });
          newState.set(&#039;&#039;, ((_state$get = state.get(&#039;&#039;)) !== null &amp;&amp; _state$get !== void 0 ? _state$get : []).concat(blockOrder[&#039;&#039;]));
          return newState;
        }
      case &#039;INSERT_BLOCKS&#039;:
        {
          const {
            rootClientId = &#039;&#039;
          } = action;
          const subState = state.get(rootClientId) || [];
          const mappedBlocks = mapBlockOrder(action.blocks, rootClientId);
          const {
            index = subState.length
          } = action;
          const newState = new Map(state);
          mappedBlocks.forEach((order, clientId) =&gt; {
            newState.set(clientId, order);
          });
          newState.set(rootClientId, insertAt(subState, mappedBlocks.get(rootClientId), index));
          return newState;
        }
      case &#039;MOVE_BLOCKS_TO_POSITION&#039;:
        {
          var _state$get$filter;
          const {
            fromRootClientId = &#039;&#039;,
            toRootClientId = &#039;&#039;,
            clientIds
          } = action;
          const {
            index = state.get(toRootClientId).length
          } = action;

          // Moving inside the same parent block.
          if (fromRootClientId === toRootClientId) {
            const subState = state.get(toRootClientId);
            const fromIndex = subState.indexOf(clientIds[0]);
            const newState = new Map(state);
            newState.set(toRootClientId, moveTo(state.get(toRootClientId), fromIndex, index, clientIds.length));
            return newState;
          }

          // Moving from a parent block to another.
          const newState = new Map(state);
          newState.set(fromRootClientId, (_state$get$filter = state.get(fromRootClientId)?.filter(id =&gt; !clientIds.includes(id))) !== null &amp;&amp; _state$get$filter !== void 0 ? _state$get$filter : []);
          newState.set(toRootClientId, insertAt(state.get(toRootClientId), clientIds, index));
          return newState;
        }
      case &#039;MOVE_BLOCKS_UP&#039;:
        {
          const {
            clientIds,
            rootClientId = &#039;&#039;
          } = action;
          const firstClientId = clientIds[0];
          const subState = state.get(rootClientId);
          if (!subState.length || firstClientId === subState[0]) {
            return state;
          }
          const firstIndex = subState.indexOf(firstClientId);
          const newState = new Map(state);
          newState.set(rootClientId, moveTo(subState, firstIndex, firstIndex - 1, clientIds.length));
          return newState;
        }
      case &#039;MOVE_BLOCKS_DOWN&#039;:
        {
          const {
            clientIds,
            rootClientId = &#039;&#039;
          } = action;
          const firstClientId = clientIds[0];
          const lastClientId = clientIds[clientIds.length - 1];
          const subState = state.get(rootClientId);
          if (!subState.length || lastClientId === subState[subState.length - 1]) {
            return state;
          }
          const firstIndex = subState.indexOf(firstClientId);
          const newState = new Map(state);
          newState.set(rootClientId, moveTo(subState, firstIndex, firstIndex + 1, clientIds.length));
          return newState;
        }
      case &#039;REPLACE_BLOCKS_AUGMENTED_WITH_CHILDREN&#039;:
        {
          const {
            clientIds
          } = action;
          if (!action.blocks) {
            return state;
          }
          const mappedBlocks = mapBlockOrder(action.blocks);
          const newState = new Map(state);
          action.replacedClientIds.forEach(clientId =&gt; {
            newState.delete(clientId);
          });
          mappedBlocks.forEach((order, clientId) =&gt; {
            if (clientId !== &#039;&#039;) {
              newState.set(clientId, order);
            }
          });
          newState.forEach((order, clientId) =&gt; {
            const newSubOrder = Object.values(order).reduce((result, subClientId) =&gt; {
              if (subClientId === clientIds[0]) {
                return [...result, ...mappedBlocks.get(&#039;&#039;)];
              }
              if (clientIds.indexOf(subClientId) === -1) {
                result.push(subClientId);
              }
              return result;
            }, []);
            newState.set(clientId, newSubOrder);
          });
          return newState;
        }
      case &#039;REMOVE_BLOCKS_AUGMENTED_WITH_CHILDREN&#039;:
        {
          const newState = new Map(state);
          // Remove inner block ordering for removed blocks.
          action.removedClientIds.forEach(clientId =&gt; {
            newState.delete(clientId);
          });
          newState.forEach((order, clientId) =&gt; {
            var _order$filter;
            const newSubOrder = (_order$filter = order?.filter(id =&gt; !action.removedClientIds.includes(id))) !== null &amp;&amp; _order$filter !== void 0 ? _order$filter : [];
            if (newSubOrder.length !== order.length) {
              newState.set(clientId, newSubOrder);
            }
          });
          return newState;
        }
    }
    return state;
  },
  // While technically redundant data as the inverse of `order`, it serves as
  // an optimization for the selectors which derive the ancestry of a block.
  parents(state = new Map(), action) {
    switch (action.type) {
      case &#039;RECEIVE_BLOCKS&#039;:
        {
          const newState = new Map(state);
          mapBlockParents(action.blocks).forEach(([key, value]) =&gt; {
            newState.set(key, value);
          });
          return newState;
        }
      case &#039;INSERT_BLOCKS&#039;:
        {
          const newState = new Map(state);
          mapBlockParents(action.blocks, action.rootClientId || &#039;&#039;).forEach(([key, value]) =&gt; {
            newState.set(key, value);
          });
          return newState;
        }
      case &#039;MOVE_BLOCKS_TO_POSITION&#039;:
        {
          const newState = new Map(state);
          action.clientIds.forEach(id =&gt; {
            newState.set(id, action.toRootClientId || &#039;&#039;);
          });
          return newState;
        }
      case &#039;REPLACE_BLOCKS_AUGMENTED_WITH_CHILDREN&#039;:
        {
          const newState = new Map(state);
          action.replacedClientIds.forEach(clientId =&gt; {
            newState.delete(clientId);
          });
          mapBlockParents(action.blocks, state.get(action.clientIds[0])).forEach(([key, value]) =&gt; {
            newState.set(key, value);
          });
          return newState;
        }
      case &#039;REMOVE_BLOCKS_AUGMENTED_WITH_CHILDREN&#039;:
        {
          const newState = new Map(state);
          action.removedClientIds.forEach(clientId =&gt; {
            newState.delete(clientId);
          });
          return newState;
        }
    }
    return state;
  },
  controlledInnerBlocks(state = {}, {
    type,
    clientId,
    hasControlledInnerBlocks
  }) {
    if (type === &#039;SET_HAS_CONTROLLED_INNER_BLOCKS&#039;) {
      return {
        ...state,
        [clientId]: hasControlledInnerBlocks
      };
    }
    return state;
  }
});

/**
 * Reducer returning visibility status of block interface.
 *
 * @param {boolean} state  Current state.
 * @param {Object}  action Dispatched action.
 *
 * @return {boolean} Updated state.
 */
function isBlockInterfaceHidden(state = false, action) {
  switch (action.type) {
    case &#039;HIDE_BLOCK_INTERFACE&#039;:
      return true;
    case &#039;SHOW_BLOCK_INTERFACE&#039;:
      return false;
  }
  return state;
}

/**
 * Reducer returning typing state.
 *
 * @param {boolean} state  Current state.
 * @param {Object}  action Dispatched action.
 *
 * @return {boolean} Updated state.
 */
function isTyping(state = false, action) {
  switch (action.type) {
    case &#039;START_TYPING&#039;:
      return true;
    case &#039;STOP_TYPING&#039;:
      return false;
  }
  return state;
}

/**
 * Reducer returning dragging state. It is possible for a user to be dragging
 * data from outside of the editor, so this state is separate from `draggedBlocks`.
 *
 * @param {boolean} state  Current state.
 * @param {Object}  action Dispatched action.
 *
 * @return {boolean} Updated state.
 */
function isDragging(state = false, action) {
  switch (action.type) {
    case &#039;START_DRAGGING&#039;:
      return true;
    case &#039;STOP_DRAGGING&#039;:
      return false;
  }
  return state;
}

/**
 * Reducer returning dragged block client id.
 *
 * @param {string[]} state  Current state.
 * @param {Object}   action Dispatched action.
 *
 * @return {string[]} Updated state.
 */
function draggedBlocks(state = [], action) {
  switch (action.type) {
    case &#039;START_DRAGGING_BLOCKS&#039;:
      return action.clientIds;
    case &#039;STOP_DRAGGING_BLOCKS&#039;:
      return [];
  }
  return state;
}

/**
 * Reducer tracking the visible blocks.
 *
 * @param {Record&lt;string,boolean&gt;} state  Current state.
 * @param {Object}                 action Dispatched action.
 *
 * @return {Record&lt;string,boolean&gt;} Block visibility.
 */
function blockVisibility(state = {}, action) {
  if (action.type === &#039;SET_BLOCK_VISIBILITY&#039;) {
    return {
      ...state,
      ...action.updates
    };
  }
  return state;
}

/**
 * Internal helper reducer for selectionStart and selectionEnd. Can hold a block
 * selection, represented by an object with property clientId.
 *
 * @param {Object} state  Current state.
 * @param {Object} action Dispatched action.
 *
 * @return {Object} Updated state.
 */
function selectionHelper(state = {}, action) {
  switch (action.type) {
    case &#039;CLEAR_SELECTED_BLOCK&#039;:
      {
        if (state.clientId) {
          return {};
        }
        return state;
      }
    case &#039;SELECT_BLOCK&#039;:
      if (action.clientId === state.clientId) {
        return state;
      }
      return {
        clientId: action.clientId
      };
    case &#039;REPLACE_INNER_BLOCKS&#039;:
    case &#039;INSERT_BLOCKS&#039;:
      {
        if (!action.updateSelection || !action.blocks.length) {
          return state;
        }
        return {
          clientId: action.blocks[0].clientId
        };
      }
    case &#039;REMOVE_BLOCKS&#039;:
      if (!action.clientIds || !action.clientIds.length || action.clientIds.indexOf(state.clientId) === -1) {
        return state;
      }
      return {};
    case &#039;REPLACE_BLOCKS&#039;:
      {
        if (action.clientIds.indexOf(state.clientId) === -1) {
          return state;
        }
        const blockToSelect = action.blocks[action.indexToSelect] || action.blocks[action.blocks.length - 1];
        if (!blockToSelect) {
          return {};
        }
        if (blockToSelect.clientId === state.clientId) {
          return state;
        }
        return {
          clientId: blockToSelect.clientId
        };
      }
  }
  return state;
}

/**
 * Reducer returning the selection state.
 *
 * @param {boolean} state  Current state.
 * @param {Object}  action Dispatched action.
 *
 * @return {boolean} Updated state.
 */
function selection(state = {}, action) {
  switch (action.type) {
    case &#039;SELECTION_CHANGE&#039;:
      if (action.clientId) {
        return {
          selectionStart: {
            clientId: action.clientId,
            attributeKey: action.attributeKey,
            offset: action.startOffset
          },
          selectionEnd: {
            clientId: action.clientId,
            attributeKey: action.attributeKey,
            offset: action.endOffset
          }
        };
      }
      return {
        selectionStart: action.start || state.selectionStart,
        selectionEnd: action.end || state.selectionEnd
      };
    case &#039;RESET_SELECTION&#039;:
      const {
        selectionStart,
        selectionEnd
      } = action;
      return {
        selectionStart,
        selectionEnd
      };
    case &#039;MULTI_SELECT&#039;:
      const {
        start,
        end
      } = action;
      if (start === state.selectionStart?.clientId &amp;&amp; end === state.selectionEnd?.clientId) {
        return state;
      }
      return {
        selectionStart: {
          clientId: start
        },
        selectionEnd: {
          clientId: end
        }
      };
    case &#039;RESET_BLOCKS&#039;:
      const startClientId = state?.selectionStart?.clientId;
      const endClientId = state?.selectionEnd?.clientId;

      // Do nothing if there&#039;s no selected block.
      if (!startClientId &amp;&amp; !endClientId) {
        return state;
      }

      // If the start of the selection won&#039;t exist after reset, remove selection.
      if (!action.blocks.some(block =&gt; block.clientId === startClientId)) {
        return {
          selectionStart: {},
          selectionEnd: {}
        };
      }

      // If the end of the selection won&#039;t exist after reset, collapse selection.
      if (!action.blocks.some(block =&gt; block.clientId === endClientId)) {
        return {
          ...state,
          selectionEnd: state.selectionStart
        };
      }
  }
  const selectionStart = selectionHelper(state.selectionStart, action);
  const selectionEnd = selectionHelper(state.selectionEnd, action);
  if (selectionStart === state.selectionStart &amp;&amp; selectionEnd === state.selectionEnd) {
    return state;
  }
  return {
    selectionStart,
    selectionEnd
  };
}

/**
 * Reducer returning whether the user is multi-selecting.
 *
 * @param {boolean} state  Current state.
 * @param {Object}  action Dispatched action.
 *
 * @return {boolean} Updated state.
 */
function isMultiSelecting(state = false, action) {
  switch (action.type) {
    case &#039;START_MULTI_SELECT&#039;:
      return true;
    case &#039;STOP_MULTI_SELECT&#039;:
      return false;
  }
  return state;
}

/**
 * Reducer returning whether selection is enabled.
 *
 * @param {boolean} state  Current state.
 * @param {Object}  action Dispatched action.
 *
 * @return {boolean} Updated state.
 */
function isSelectionEnabled(state = true, action) {
  switch (action.type) {
    case &#039;TOGGLE_SELECTION&#039;:
      return action.isSelectionEnabled;
  }
  return state;
}

/**
 * Reducer returning the data needed to display a prompt when certain blocks
 * are removed, or `false` if no such prompt is requested.
 *
 * @param {boolean} state  Current state.
 * @param {Object}  action Dispatched action.
 *
 * @return {Object|false} Data for removal prompt display, if any.
 */
function removalPromptData(state = false, action) {
  switch (action.type) {
    case &#039;DISPLAY_BLOCK_REMOVAL_PROMPT&#039;:
      const {
        clientIds,
        selectPrevious,
        message
      } = action;
      return {
        clientIds,
        selectPrevious,
        message
      };
    case &#039;CLEAR_BLOCK_REMOVAL_PROMPT&#039;:
      return false;
  }
  return state;
}

/**
 * Reducer returning any rules that a block editor may provide in order to
 * prevent a user from accidentally removing certain blocks. These rules are
 * then used to display a confirmation prompt to the user. For instance, in the
 * Site Editor, the Query Loop block is important enough to warrant such
 * confirmation.
 *
 * The data is a record whose keys are block types (e.g. &#039;core/query&#039;) and
 * whose values are the explanation to be shown to users (e.g. &#039;Query Loop
 * displays a list of posts or pages.&#039;).
 *
 * @param {boolean} state  Current state.
 * @param {Object}  action Dispatched action.
 *
 * @return {Record&lt;string,string&gt;} Updated state.
 */
function blockRemovalRules(state = false, action) {
  switch (action.type) {
    case &#039;SET_BLOCK_REMOVAL_RULES&#039;:
      return action.rules;
  }
  return state;
}

/**
 * Reducer returning the initial block selection.
 *
 * Currently this in only used to restore the selection after block deletion and
 * pasting new content.This reducer should eventually be removed in favour of setting
 * selection directly.
 *
 * @param {boolean} state  Current state.
 * @param {Object}  action Dispatched action.
 *
 * @return {number|null} Initial position: 0, -1 or null.
 */
function initialPosition(state = null, action) {
  if (action.type === &#039;REPLACE_BLOCKS&#039; &amp;&amp; action.initialPosition !== undefined) {
    return action.initialPosition;
  } else if ([&#039;MULTI_SELECT&#039;, &#039;SELECT_BLOCK&#039;, &#039;RESET_SELECTION&#039;, &#039;INSERT_BLOCKS&#039;, &#039;REPLACE_INNER_BLOCKS&#039;].includes(action.type)) {
    return action.initialPosition;
  }
  return state;
}
function blocksMode(state = {}, action) {
  if (action.type === &#039;TOGGLE_BLOCK_MODE&#039;) {
    const {
      clientId
    } = action;
    return {
      ...state,
      [clientId]: state[clientId] &amp;&amp; state[clientId] === &#039;html&#039; ? &#039;visual&#039; : &#039;html&#039;
    };
  }
  return state;
}

/**
 * Reducer returning the block insertion point visibility, either null if there
 * is not an explicit insertion point assigned, or an object of its `index` and
 * `rootClientId`.
 *
 * @param {Object} state  Current state.
 * @param {Object} action Dispatched action.
 *
 * @return {Object} Updated state.
 */
function insertionCue(state = null, action) {
  switch (action.type) {
    case &#039;SHOW_INSERTION_POINT&#039;:
      {
        const {
          rootClientId,
          index,
          __unstableWithInserter,
          operation,
          nearestSide
        } = action;
        const nextState = {
          rootClientId,
          index,
          __unstableWithInserter,
          operation,
          nearestSide
        };

        // Bail out updates if the states are the same.
        return es6_default()(state, nextState) ? state : nextState;
      }
    case &#039;HIDE_INSERTION_POINT&#039;:
      return null;
  }
  return state;
}

/**
 * Reducer returning whether the post blocks match the defined template or not.
 *
 * @param {Object} state  Current state.
 * @param {Object} action Dispatched action.
 *
 * @return {boolean} Updated state.
 */
function template(state = {
  isValid: true
}, action) {
  switch (action.type) {
    case &#039;SET_TEMPLATE_VALIDITY&#039;:
      return {
        ...state,
        isValid: action.isValid
      };
  }
  return state;
}

/**
 * Reducer returning the editor setting.
 *
 * @param {Object} state  Current state.
 * @param {Object} action Dispatched action.
 *
 * @return {Object} Updated state.
 */
function settings(state = SETTINGS_DEFAULTS, action) {
  switch (action.type) {
    case &#039;UPDATE_SETTINGS&#039;:
      {
        const updatedSettings = action.reset ? {
          ...SETTINGS_DEFAULTS,
          ...action.settings
        } : {
          ...state,
          ...action.settings
        };
        Object.defineProperty(updatedSettings, &#039;__unstableIsPreviewMode&#039;, {
          get() {
            external_wp_deprecated_default()(&#039;__unstableIsPreviewMode&#039;, {
              since: &#039;6.8&#039;,
              alternative: &#039;isPreviewMode&#039;
            });
            return this.isPreviewMode;
          }
        });
        return updatedSettings;
      }
  }
  return state;
}

/**
 * Reducer returning the user preferences.
 *
 * @param {Object} state  Current state.
 * @param {Object} action Dispatched action.
 *
 * @return {string} Updated state.
 */
function preferences(state = PREFERENCES_DEFAULTS, action) {
  switch (action.type) {
    case &#039;INSERT_BLOCKS&#039;:
    case &#039;REPLACE_BLOCKS&#039;:
      {
        const nextInsertUsage = action.blocks.reduce((prevUsage, block) =&gt; {
          const {
            attributes,
            name: blockName
          } = block;
          let id = blockName;
          // If a block variation match is found change the name to be the same with the
          // one that is used for block variations in the Inserter (`getItemFromVariation`).
          const match = (0,external_wp_data_namespaceObject.select)(external_wp_blocks_namespaceObject.store).getActiveBlockVariation(blockName, attributes);
          if (match?.name) {
            id += &#039;/&#039; + match.name;
          }
          if (blockName === &#039;core/block&#039;) {
            id += &#039;/&#039; + attributes.ref;
          }
          return {
            ...prevUsage,
            [id]: {
              time: action.time,
              count: prevUsage[id] ? prevUsage[id].count + 1 : 1
            }
          };
        }, state.insertUsage);
        return {
          ...state,
          insertUsage: nextInsertUsage
        };
      }
  }
  return state;
}

/**
 * Reducer returning an object where each key is a block client ID, its value
 * representing the settings for its nested blocks.
 *
 * @param {Object} state  Current state.
 * @param {Object} action Dispatched action.
 *
 * @return {Object} Updated state.
 */
const blockListSettings = (state = {}, action) =&gt; {
  switch (action.type) {
    // Even if the replaced blocks have the same client ID, our logic
    // should correct the state.
    case &#039;REPLACE_BLOCKS&#039;:
    case &#039;REMOVE_BLOCKS&#039;:
      {
        return Object.fromEntries(Object.entries(state).filter(([id]) =&gt; !action.clientIds.includes(id)));
      }
    case &#039;UPDATE_BLOCK_LIST_SETTINGS&#039;:
      {
        const updates = typeof action.clientId === &#039;string&#039; ? {
          [action.clientId]: action.settings
        } : action.clientId;

        // Remove settings that are the same as the current state.
        for (const clientId in updates) {
          if (!updates[clientId]) {
            if (!state[clientId]) {
              delete updates[clientId];
            }
          } else if (es6_default()(state[clientId], updates[clientId])) {
            delete updates[clientId];
          }
        }
        if (Object.keys(updates).length === 0) {
          return state;
        }
        const merged = {
          ...state,
          ...updates
        };
        for (const clientId in updates) {
          if (!updates[clientId]) {
            delete merged[clientId];
          }
        }
        return merged;
      }
  }
  return state;
};

/**
 * Reducer return an updated state representing the most recent block attribute
 * update. The state is structured as an object where the keys represent the
 * client IDs of blocks, the values a subset of attributes from the most recent
 * block update. The state is always reset to null if the last action is
 * anything other than an attributes update.
 *
 * @param {Object&lt;string,Object&gt;} state  Current state.
 * @param {Object}                action Action object.
 *
 * @return {[string,Object]} Updated state.
 */
function lastBlockAttributesChange(state = null, action) {
  switch (action.type) {
    case &#039;UPDATE_BLOCK&#039;:
      if (!action.updates.attributes) {
        break;
      }
      return {
        [action.clientId]: action.updates.attributes
      };
    case &#039;UPDATE_BLOCK_ATTRIBUTES&#039;:
      return action.clientIds.reduce((accumulator, id) =&gt; ({
        ...accumulator,
        [id]: action.uniqueByBlock ? action.attributes[id] : action.attributes
      }), {});
  }
  return state;
}

/**
 * Reducer returning current highlighted block.
 *
 * @param {boolean} state  Current highlighted block.
 * @param {Object}  action Dispatched action.
 *
 * @return {string} Updated state.
 */
function highlightedBlock(state, action) {
  switch (action.type) {
    case &#039;TOGGLE_BLOCK_HIGHLIGHT&#039;:
      const {
        clientId,
        isHighlighted
      } = action;
      if (isHighlighted) {
        return clientId;
      } else if (state === clientId) {
        return null;
      }
      return state;
    case &#039;SELECT_BLOCK&#039;:
      if (action.clientId !== state) {
        return null;
      }
  }
  return state;
}

/**
 * Reducer returning current expanded block in the list view.
 *
 * @param {string|null} state  Current expanded block.
 * @param {Object}      action Dispatched action.
 *
 * @return {string|null} Updated state.
 */
function expandedBlock(state = null, action) {
  switch (action.type) {
    case &#039;SET_BLOCK_EXPANDED_IN_LIST_VIEW&#039;:
      return action.clientId;
    case &#039;SELECT_BLOCK&#039;:
      if (action.clientId !== state) {
        return null;
      }
  }
  return state;
}

/**
 * Reducer returning the block insertion event list state.
 *
 * @param {Object} state  Current state.
 * @param {Object} action Dispatched action.
 *
 * @return {Object} Updated state.
 */
function lastBlockInserted(state = {}, action) {
  switch (action.type) {
    case &#039;INSERT_BLOCKS&#039;:
    case &#039;REPLACE_BLOCKS&#039;:
      if (!action.blocks.length) {
        return state;
      }
      const clientIds = action.blocks.map(block =&gt; {
        return block.clientId;
      });
      const source = action.meta?.source;
      return {
        clientIds,
        source
      };
    case &#039;RESET_BLOCKS&#039;:
      return {};
  }
  return state;
}

/**
 * Reducer returning the block that is eding temporarily edited as blocks.
 *
 * @param {Object} state  Current state.
 * @param {Object} action Dispatched action.
 *
 * @return {Object} Updated state.
 */
function temporarilyEditingAsBlocks(state = &#039;&#039;, action) {
  if (action.type === &#039;SET_TEMPORARILY_EDITING_AS_BLOCKS&#039;) {
    return action.temporarilyEditingAsBlocks;
  }
  return state;
}

/**
 * Reducer returning the focus mode that should be used when temporarily edit as blocks finishes.
 *
 * @param {Object} state  Current state.
 * @param {Object} action Dispatched action.
 *
 * @return {Object} Updated state.
 */
function temporarilyEditingFocusModeRevert(state = &#039;&#039;, action) {
  if (action.type === &#039;SET_TEMPORARILY_EDITING_AS_BLOCKS&#039;) {
    return action.focusModeToRevert;
  }
  return state;
}

/**
 * Reducer returning a map of block client IDs to block editing modes.
 *
 * @param {Map}    state  Current state.
 * @param {Object} action Dispatched action.
 *
 * @return {Map} Updated state.
 */
function blockEditingModes(state = new Map(), action) {
  switch (action.type) {
    case &#039;SET_BLOCK_EDITING_MODE&#039;:
      if (state.get(action.clientId) === action.mode) {
        return state;
      }
      return new Map(state).set(action.clientId, action.mode);
    case &#039;UNSET_BLOCK_EDITING_MODE&#039;:
      {
        if (!state.has(action.clientId)) {
          return state;
        }
        const newState = new Map(state);
        newState.delete(action.clientId);
        return newState;
      }
    case &#039;RESET_BLOCKS&#039;:
      {
        return state.has(&#039;&#039;) ? new Map().set(&#039;&#039;, state.get(&#039;&#039;)) : state;
      }
  }
  return state;
}

/**
 * Reducer returning the clientId of the block settings menu that is currently open.
 *
 * @param {string|null} state  Current state.
 * @param {Object}      action Dispatched action.
 *
 * @return {string|null} Updated state.
 */
function openedBlockSettingsMenu(state = null, action) {
  if (&#039;SET_OPENED_BLOCK_SETTINGS_MENU&#039; === action.type) {
    var _action$clientId;
    return (_action$clientId = action?.clientId) !== null &amp;&amp; _action$clientId !== void 0 ? _action$clientId : null;
  }
  return state;
}

/**
 * Reducer returning a map of style IDs to style overrides.
 *
 * @param {Map}    state  Current state.
 * @param {Object} action Dispatched action.
 *
 * @return {Map} Updated state.
 */
function styleOverrides(state = new Map(), action) {
  switch (action.type) {
    case &#039;SET_STYLE_OVERRIDE&#039;:
      return new Map(state).set(action.id, action.style);
    case &#039;DELETE_STYLE_OVERRIDE&#039;:
      {
        const newState = new Map(state);
        newState.delete(action.id);
        return newState;
      }
  }
  return state;
}

/**
 * Reducer returning a map of the registered inserter media categories.
 *
 * @param {Array}  state  Current state.
 * @param {Object} action Dispatched action.
 *
 * @return {Array} Updated state.
 */
function registeredInserterMediaCategories(state = [], action) {
  switch (action.type) {
    case &#039;REGISTER_INSERTER_MEDIA_CATEGORY&#039;:
      return [...state, action.category];
  }
  return state;
}

/**
 * Reducer setting last focused element
 *
 * @param {boolean} state  Current state.
 * @param {Object}  action Dispatched action.
 *
 * @return {boolean} Updated state.
 */
function lastFocus(state = false, action) {
  switch (action.type) {
    case &#039;LAST_FOCUS&#039;:
      return action.lastFocus;
  }
  return state;
}

/**
 * Reducer setting currently hovered block.
 *
 * @param {boolean} state  Current state.
 * @param {Object}  action Dispatched action.
 *
 * @return {boolean} Updated state.
 */
function hoveredBlockClientId(state = false, action) {
  switch (action.type) {
    case &#039;HOVER_BLOCK&#039;:
      return action.clientId;
  }
  return state;
}

/**
 * Reducer setting zoom out state.
 *
 * @param {boolean} state  Current state.
 * @param {Object}  action Dispatched action.
 *
 * @return {number} Updated state.
 */
function zoomLevel(state = 100, action) {
  switch (action.type) {
    case &#039;SET_ZOOM_LEVEL&#039;:
      return action.zoom;
    case &#039;RESET_ZOOM_LEVEL&#039;:
      return 100;
  }
  return state;
}

/**
 * Reducer setting the insertion point
 *
 * @param {boolean} state  Current state.
 * @param {Object}  action Dispatched action.
 *
 * @return {Object} Updated state.
 */
function insertionPoint(state = null, action) {
  switch (action.type) {
    case &#039;SET_INSERTION_POINT&#039;:
      return action.value;
    case &#039;SELECT_BLOCK&#039;:
      return null;
  }
  return state;
}
const combinedReducers = (0,external_wp_data_namespaceObject.combineReducers)({
  blocks,
  isDragging,
  isTyping,
  isBlockInterfaceHidden,
  draggedBlocks,
  selection,
  isMultiSelecting,
  isSelectionEnabled,
  initialPosition,
  blocksMode,
  blockListSettings,
  insertionPoint,
  insertionCue,
  template,
  settings,
  preferences,
  lastBlockAttributesChange,
  lastFocus,
  expandedBlock,
  highlightedBlock,
  lastBlockInserted,
  temporarilyEditingAsBlocks,
  temporarilyEditingFocusModeRevert,
  blockVisibility,
  blockEditingModes,
  styleOverrides,
  removalPromptData,
  blockRemovalRules,
  openedBlockSettingsMenu,
  registeredInserterMediaCategories,
  hoveredBlockClientId,
  zoomLevel
});

/**
 * Retrieves a block&#039;s tree structure, handling both controlled and uncontrolled inner blocks.
 *
 * @param {Object} state    The current state object.
 * @param {string} clientId The client ID of the block to retrieve.
 *
 * @return {Object|undefined} The block tree object, or undefined if not found. For controlled blocks,
 *                           returns a merged tree with controlled inner blocks.
 */
function getBlockTreeBlock(state, clientId) {
  if (clientId === &#039;&#039;) {
    const rootBlock = state.blocks.tree.get(clientId);
    if (!rootBlock) {
      return;
    }

    // Patch the root block to have a clientId property.
    // TODO - consider updating the blocks reducer so that the root block has this property.
    return {
      clientId: &#039;&#039;,
      ...rootBlock
    };
  }
  if (!state.blocks.controlledInnerBlocks[clientId]) {
    return state.blocks.tree.get(clientId);
  }
  const controlledTree = state.blocks.tree.get(`controlled||${clientId}`);
  const regularTree = state.blocks.tree.get(clientId);
  return {
    ...regularTree,
    innerBlocks: controlledTree?.innerBlocks
  };
}

/**
 * Recursively traverses through a block tree of a given block and executes a callback for each block.
 *
 * @param {Object}   state    The store state.
 * @param {string}   clientId The clientId of the block to start traversing from.
 * @param {Function} callback Function to execute for each block encountered during traversal.
 *                            The callback receives the current block as its argument.
 */
function traverseBlockTree(state, clientId, callback) {
  const tree = getBlockTreeBlock(state, clientId);
  if (!tree) {
    return;
  }
  callback(tree);
  if (!tree?.innerBlocks?.length) {
    return;
  }
  for (const innerBlock of tree?.innerBlocks) {
    traverseBlockTree(state, innerBlock.clientId, callback);
  }
}

/**
 * Checks if a block has a parent in a list of client IDs, and if so returns the client ID of the parent.
 *
 * @param {Object} state     The current state object.
 * @param {string} clientId  The client ID of the block to search the parents of.
 * @param {Array}  clientIds The client IDs of the blocks to check.
 *
 * @return {string|undefined} The client ID of the parent block if found, undefined otherwise.
 */
function findParentInClientIdsList(state, clientId, clientIds) {
  if (!clientIds.length) {
    return;
  }
  let parent = state.blocks.parents.get(clientId);
  while (parent !== undefined) {
    if (clientIds.includes(parent)) {
      return parent;
    }
    parent = state.blocks.parents.get(parent);
  }
}

/**
 * Checks if a block has any bindings in its metadata attributes.
 *
 * @param {Object} block The block object to check for bindings.
 * @return {boolean}    True if the block has bindings, false otherwise.
 */
function hasBindings(block) {
  return block?.attributes?.metadata?.bindings &amp;&amp; Object.keys(block?.attributes?.metadata?.bindings).length;
}

/**
 * Computes and returns derived block editing modes for a given block tree.
 *
 * This function calculates the editing modes for each block in the tree, taking into account
 * various factors such as zoom level, navigation mode, sections, and synced patterns.
 *
 * @param {Object}  state        The current state object.
 * @param {boolean} isNavMode    Whether the navigation mode is active.
 * @param {string}  treeClientId The client ID of the root block for the tree. Defaults to an empty string.
 * @return {Map} A Map containing the derived block editing modes, keyed by block client ID.
 */
function getDerivedBlockEditingModesForTree(state, isNavMode = false, treeClientId = &#039;&#039;) {
  const isZoomedOut = state?.zoomLevel &lt; 100 || state?.zoomLevel === &#039;auto-scaled&#039;;
  const derivedBlockEditingModes = new Map();

  // When there are sections, the majority of blocks are disabled,
  // so the default block editing mode is set to disabled.
  const sectionRootClientId = state.settings?.[sectionRootClientIdKey];
  const sectionClientIds = state.blocks.order.get(sectionRootClientId);
  const hasDisabledBlocks = Array.from(state.blockEditingModes).some(([, mode]) =&gt; mode === &#039;disabled&#039;);
  const templatePartClientIds = [];
  const syncedPatternClientIds = [];
  Object.keys(state.blocks.controlledInnerBlocks).forEach(clientId =&gt; {
    const block = state.blocks.byClientId?.get(clientId);
    if (block?.name === &#039;core/template-part&#039;) {
      templatePartClientIds.push(clientId);
    }
    if (block?.name === &#039;core/block&#039;) {
      syncedPatternClientIds.push(clientId);
    }
  });
  traverseBlockTree(state, treeClientId, block =&gt; {
    const {
      clientId,
      name: blockName
    } = block;

    // If the block already has an explicit block editing mode set,
    // don&#039;t override it.
    if (state.blockEditingModes.has(clientId)) {
      return;
    }

    // Disabled explicit block editing modes are inherited by children.
    // It&#039;s an expensive calculation, so only do it if there are disabled blocks.
    if (hasDisabledBlocks) {
      // Look through parents to find one with an explicit block editing mode.
      let ancestorBlockEditingMode;
      let parent = state.blocks.parents.get(clientId);
      while (parent !== undefined) {
        // There&#039;s a chance we only just calculated this for the parent,
        // if so we can return that value for a faster lookup.
        if (derivedBlockEditingModes.has(parent)) {
          ancestorBlockEditingMode = derivedBlockEditingModes.get(parent);
        } else if (state.blockEditingModes.has(parent)) {
          // Checking the explicit block editing mode will be slower,
          // as the block editing mode is more likely to be set on a
          // distant ancestor.
          ancestorBlockEditingMode = state.blockEditingModes.get(parent);
        }
        if (ancestorBlockEditingMode) {
          break;
        }
        parent = state.blocks.parents.get(parent);
      }

      // If the ancestor block editing mode is disabled, it&#039;s inherited by the child.
      if (ancestorBlockEditingMode === &#039;disabled&#039;) {
        derivedBlockEditingModes.set(clientId, &#039;disabled&#039;);
        return;
      }
    }
    if (isZoomedOut || isNavMode) {
      // If the root block is the section root set its editing mode to contentOnly.
      if (clientId === sectionRootClientId) {
        derivedBlockEditingModes.set(clientId, &#039;contentOnly&#039;);
        return;
      }

      // There are no sections, so everything else is disabled.
      if (!sectionClientIds?.length) {
        derivedBlockEditingModes.set(clientId, &#039;disabled&#039;);
        return;
      }
      if (sectionClientIds.includes(clientId)) {
        derivedBlockEditingModes.set(clientId, &#039;contentOnly&#039;);
        return;
      }

      // If zoomed out, all blocks that aren&#039;t sections or the section root are
      // disabled.
      if (isZoomedOut) {
        derivedBlockEditingModes.set(clientId, &#039;disabled&#039;);
        return;
      }
      const isInSection = !!findParentInClientIdsList(state, clientId, sectionClientIds);
      if (!isInSection) {
        if (clientId === &#039;&#039;) {
          derivedBlockEditingModes.set(clientId, &#039;disabled&#039;);
          return;
        }

        // Allow selection of template parts outside of sections.
        if (blockName === &#039;core/template-part&#039;) {
          derivedBlockEditingModes.set(clientId, &#039;contentOnly&#039;);
          return;
        }
        const isInTemplatePart = !!findParentInClientIdsList(state, clientId, templatePartClientIds);
        // Allow contentOnly blocks in template parts outside of sections
        // to be editable. Only disable blocks that don&#039;t fit this criteria.
        if (!isInTemplatePart &amp;&amp; !isContentBlock(blockName)) {
          derivedBlockEditingModes.set(clientId, &#039;disabled&#039;);
          return;
        }
      }

      // Handle synced pattern content so the inner blocks of a synced pattern are
      // properly disabled.
      if (syncedPatternClientIds.length) {
        const parentPatternClientId = findParentInClientIdsList(state, clientId, syncedPatternClientIds);
        if (parentPatternClientId) {
          // This is a pattern nested in another pattern, it should be disabled.
          if (findParentInClientIdsList(state, parentPatternClientId, syncedPatternClientIds)) {
            derivedBlockEditingModes.set(clientId, &#039;disabled&#039;);
            return;
          }
          if (hasBindings(block)) {
            derivedBlockEditingModes.set(clientId, &#039;contentOnly&#039;);
            return;
          }

          // Synced pattern content without a binding isn&#039;t editable
          // from the instance, the user has to edit the pattern source,
          // so return &#039;disabled&#039;.
          derivedBlockEditingModes.set(clientId, &#039;disabled&#039;);
          return;
        }
      }
      if (blockName &amp;&amp; isContentBlock(blockName)) {
        derivedBlockEditingModes.set(clientId, &#039;contentOnly&#039;);
        return;
      }
      derivedBlockEditingModes.set(clientId, &#039;disabled&#039;);
      return;
    }
    if (syncedPatternClientIds.length) {
      // Synced pattern blocks (core/block).
      if (syncedPatternClientIds.includes(clientId)) {
        // This is a pattern nested in another pattern, it should be disabled.
        if (findParentInClientIdsList(state, clientId, syncedPatternClientIds)) {
          derivedBlockEditingModes.set(clientId, &#039;disabled&#039;);
          return;
        }

        // Else do nothing, use the default block editing mode.
        return;
      }

      // Inner blocks of synced patterns.
      const parentPatternClientId = findParentInClientIdsList(state, clientId, syncedPatternClientIds);
      if (parentPatternClientId) {
        // This is a pattern nested in another pattern, it should be disabled.
        if (findParentInClientIdsList(state, parentPatternClientId, syncedPatternClientIds)) {
          derivedBlockEditingModes.set(clientId, &#039;disabled&#039;);
          return;
        }
        if (hasBindings(block)) {
          derivedBlockEditingModes.set(clientId, &#039;contentOnly&#039;);
          return;
        }

        // Synced pattern content without a binding isn&#039;t editable
        // from the instance, the user has to edit the pattern source,
        // so return &#039;disabled&#039;.
        derivedBlockEditingModes.set(clientId, &#039;disabled&#039;);
      }
    }
  });
  return derivedBlockEditingModes;
}

/**
 * Updates the derived block editing modes based on added and removed blocks.
 *
 * This function handles the updating of block editing modes when blocks are added,
 * removed, or moved within the editor.
 *
 * It only returns a value when modifications are made to the block editing modes.
 *
 * @param {Object}  options                    The options for updating derived block editing modes.
 * @param {Object}  options.prevState          The previous state object.
 * @param {Object}  options.nextState          The next state object.
 * @param {Array}   [options.addedBlocks]      An array of blocks that were added.
 * @param {Array}   [options.removedClientIds] An array of client IDs of blocks that were removed.
 * @param {boolean} [options.isNavMode]        Whether the navigation mode is active.
 * @return {Map|undefined} The updated derived block editing modes, or undefined if no changes were made.
 */
function getDerivedBlockEditingModesUpdates({
  prevState,
  nextState,
  addedBlocks,
  removedClientIds,
  isNavMode = false
}) {
  const prevDerivedBlockEditingModes = isNavMode ? prevState.derivedNavModeBlockEditingModes : prevState.derivedBlockEditingModes;
  let nextDerivedBlockEditingModes;

  // Perform removals before additions to handle cases like the `MOVE_BLOCKS_TO_POSITION` action.
  // That action removes a set of clientIds, but adds the same blocks back in a different location.
  // If removals were performed after additions, those moved clientIds would be removed incorrectly.
  removedClientIds?.forEach(clientId =&gt; {
    // The actions only receive parent block IDs for removal.
    // Recurse through the block tree to ensure all blocks are removed.
    // Specifically use the previous state, before the blocks were removed.
    traverseBlockTree(prevState, clientId, block =&gt; {
      if (prevDerivedBlockEditingModes.has(block.clientId)) {
        if (!nextDerivedBlockEditingModes) {
          nextDerivedBlockEditingModes = new Map(prevDerivedBlockEditingModes);
        }
        nextDerivedBlockEditingModes.delete(block.clientId);
      }
    });
  });
  addedBlocks?.forEach(addedBlock =&gt; {
    traverseBlockTree(nextState, addedBlock.clientId, block =&gt; {
      const updates = getDerivedBlockEditingModesForTree(nextState, isNavMode, block.clientId);
      if (updates.size) {
        if (!nextDerivedBlockEditingModes) {
          nextDerivedBlockEditingModes = new Map([...(prevDerivedBlockEditingModes?.size ? prevDerivedBlockEditingModes : []), ...updates]);
        } else {
          nextDerivedBlockEditingModes = new Map([...(nextDerivedBlockEditingModes?.size ? nextDerivedBlockEditingModes : []), ...updates]);
        }
      }
    });
  });
  return nextDerivedBlockEditingModes;
}

/**
 * Higher-order reducer that adds derived block editing modes to the state.
 *
 * This function wraps a reducer and enhances it to handle actions that affect
 * block editing modes. It updates the derivedBlockEditingModes in the state
 * based on various actions such as adding, removing, or moving blocks, or changing
 * the editor mode.
 *
 * @param {Function} reducer The original reducer function to be wrapped.
 * @return {Function} A new reducer function that includes derived block editing modes handling.
 */
function withDerivedBlockEditingModes(reducer) {
  return (state, action) =&gt; {
    var _state$derivedBlockEd, _state$derivedNavMode;
    const nextState = reducer(state, action);

    // An exception is needed here to still recompute the block editing modes when
    // the editor mode changes since the editor mode isn&#039;t stored within the
    // block editor state and changing it won&#039;t trigger an altered new state.
    if (action.type !== &#039;SET_EDITOR_MODE&#039; &amp;&amp; nextState === state) {
      return state;
    }
    switch (action.type) {
      case &#039;REMOVE_BLOCKS&#039;:
        {
          const nextDerivedBlockEditingModes = getDerivedBlockEditingModesUpdates({
            prevState: state,
            nextState,
            removedClientIds: action.clientIds,
            isNavMode: false
          });
          const nextDerivedNavModeBlockEditingModes = getDerivedBlockEditingModesUpdates({
            prevState: state,
            nextState,
            removedClientIds: action.clientIds,
            isNavMode: true
          });
          if (nextDerivedBlockEditingModes || nextDerivedNavModeBlockEditingModes) {
            return {
              ...nextState,
              derivedBlockEditingModes: nextDerivedBlockEditingModes !== null &amp;&amp; nextDerivedBlockEditingModes !== void 0 ? nextDerivedBlockEditingModes : state.derivedBlockEditingModes,
              derivedNavModeBlockEditingModes: nextDerivedNavModeBlockEditingModes !== null &amp;&amp; nextDerivedNavModeBlockEditingModes !== void 0 ? nextDerivedNavModeBlockEditingModes : state.derivedNavModeBlockEditingModes
            };
          }
          break;
        }
      case &#039;RECEIVE_BLOCKS&#039;:
      case &#039;INSERT_BLOCKS&#039;:
        {
          const nextDerivedBlockEditingModes = getDerivedBlockEditingModesUpdates({
            prevState: state,
            nextState,
            addedBlocks: action.blocks,
            isNavMode: false
          });
          const nextDerivedNavModeBlockEditingModes = getDerivedBlockEditingModesUpdates({
            prevState: state,
            nextState,
            addedBlocks: action.blocks,
            isNavMode: true
          });
          if (nextDerivedBlockEditingModes || nextDerivedNavModeBlockEditingModes) {
            return {
              ...nextState,
              derivedBlockEditingModes: nextDerivedBlockEditingModes !== null &amp;&amp; nextDerivedBlockEditingModes !== void 0 ? nextDerivedBlockEditingModes : state.derivedBlockEditingModes,
              derivedNavModeBlockEditingModes: nextDerivedNavModeBlockEditingModes !== null &amp;&amp; nextDerivedNavModeBlockEditingModes !== void 0 ? nextDerivedNavModeBlockEditingModes : state.derivedNavModeBlockEditingModes
            };
          }
          break;
        }
      case &#039;SET_BLOCK_EDITING_MODE&#039;:
      case &#039;UNSET_BLOCK_EDITING_MODE&#039;:
      case &#039;SET_HAS_CONTROLLED_INNER_BLOCKS&#039;:
        {
          const updatedBlock = getBlockTreeBlock(nextState, action.clientId);

          // The block might have been removed in which case it&#039;ll be
          // handled by the `REMOVE_BLOCKS` action.
          if (!updatedBlock) {
            break;
          }
          const nextDerivedBlockEditingModes = getDerivedBlockEditingModesUpdates({
            prevState: state,
            nextState,
            removedClientIds: [action.clientId],
            addedBlocks: [updatedBlock],
            isNavMode: false
          });
          const nextDerivedNavModeBlockEditingModes = getDerivedBlockEditingModesUpdates({
            prevState: state,
            nextState,
            removedClientIds: [action.clientId],
            addedBlocks: [updatedBlock],
            isNavMode: true
          });
          if (nextDerivedBlockEditingModes || nextDerivedNavModeBlockEditingModes) {
            return {
              ...nextState,
              derivedBlockEditingModes: nextDerivedBlockEditingModes !== null &amp;&amp; nextDerivedBlockEditingModes !== void 0 ? nextDerivedBlockEditingModes : state.derivedBlockEditingModes,
              derivedNavModeBlockEditingModes: nextDerivedNavModeBlockEditingModes !== null &amp;&amp; nextDerivedNavModeBlockEditingModes !== void 0 ? nextDerivedNavModeBlockEditingModes : state.derivedNavModeBlockEditingModes
            };
          }
          break;
        }
      case &#039;REPLACE_BLOCKS&#039;:
        {
          const nextDerivedBlockEditingModes = getDerivedBlockEditingModesUpdates({
            prevState: state,
            nextState,
            addedBlocks: action.blocks,
            removedClientIds: action.clientIds,
            isNavMode: false
          });
          const nextDerivedNavModeBlockEditingModes = getDerivedBlockEditingModesUpdates({
            prevState: state,
            nextState,
            addedBlocks: action.blocks,
            removedClientIds: action.clientIds,
            isNavMode: true
          });
          if (nextDerivedBlockEditingModes || nextDerivedNavModeBlockEditingModes) {
            return {
              ...nextState,
              derivedBlockEditingModes: nextDerivedBlockEditingModes !== null &amp;&amp; nextDerivedBlockEditingModes !== void 0 ? nextDerivedBlockEditingModes : state.derivedBlockEditingModes,
              derivedNavModeBlockEditingModes: nextDerivedNavModeBlockEditingModes !== null &amp;&amp; nextDerivedNavModeBlockEditingModes !== void 0 ? nextDerivedNavModeBlockEditingModes : state.derivedNavModeBlockEditingModes
            };
          }
          break;
        }
      case &#039;REPLACE_INNER_BLOCKS&#039;:
        {
          // Get the clientIds of the blocks that are being replaced
          // from the old state, before they were removed.
          const removedClientIds = state.blocks.order.get(action.rootClientId);
          const nextDerivedBlockEditingModes = getDerivedBlockEditingModesUpdates({
            prevState: state,
            nextState,
            addedBlocks: action.blocks,
            removedClientIds,
            isNavMode: false
          });
          const nextDerivedNavModeBlockEditingModes = getDerivedBlockEditingModesUpdates({
            prevState: state,
            nextState,
            addedBlocks: action.blocks,
            removedClientIds,
            isNavMode: true
          });
          if (nextDerivedBlockEditingModes || nextDerivedNavModeBlockEditingModes) {
            return {
              ...nextState,
              derivedBlockEditingModes: nextDerivedBlockEditingModes !== null &amp;&amp; nextDerivedBlockEditingModes !== void 0 ? nextDerivedBlockEditingModes : state.derivedBlockEditingModes,
              derivedNavModeBlockEditingModes: nextDerivedNavModeBlockEditingModes !== null &amp;&amp; nextDerivedNavModeBlockEditingModes !== void 0 ? nextDerivedNavModeBlockEditingModes : state.derivedNavModeBlockEditingModes
            };
          }
          break;
        }
      case &#039;MOVE_BLOCKS_TO_POSITION&#039;:
        {
          const addedBlocks = action.clientIds.map(clientId =&gt; {
            return nextState.blocks.byClientId.get(clientId);
          });
          const nextDerivedBlockEditingModes = getDerivedBlockEditingModesUpdates({
            prevState: state,
            nextState,
            addedBlocks,
            removedClientIds: action.clientIds,
            isNavMode: false
          });
          const nextDerivedNavModeBlockEditingModes = getDerivedBlockEditingModesUpdates({
            prevState: state,
            nextState,
            addedBlocks,
            removedClientIds: action.clientIds,
            isNavMode: true
          });
          if (nextDerivedBlockEditingModes || nextDerivedNavModeBlockEditingModes) {
            return {
              ...nextState,
              derivedBlockEditingModes: nextDerivedBlockEditingModes !== null &amp;&amp; nextDerivedBlockEditingModes !== void 0 ? nextDerivedBlockEditingModes : state.derivedBlockEditingModes,
              derivedNavModeBlockEditingModes: nextDerivedNavModeBlockEditingModes !== null &amp;&amp; nextDerivedNavModeBlockEditingModes !== void 0 ? nextDerivedNavModeBlockEditingModes : state.derivedNavModeBlockEditingModes
            };
          }
          break;
        }
      case &#039;UPDATE_SETTINGS&#039;:
        {
          // Recompute the entire tree if the section root changes.
          if (state?.settings?.[sectionRootClientIdKey] !== nextState?.settings?.[sectionRootClientIdKey]) {
            return {
              ...nextState,
              derivedBlockEditingModes: getDerivedBlockEditingModesForTree(nextState, false /* Nav mode off */),
              derivedNavModeBlockEditingModes: getDerivedBlockEditingModesForTree(nextState, true /* Nav mode on */)
            };
          }
          break;
        }
      case &#039;RESET_BLOCKS&#039;:
      case &#039;SET_EDITOR_MODE&#039;:
      case &#039;RESET_ZOOM_LEVEL&#039;:
      case &#039;SET_ZOOM_LEVEL&#039;:
        {
          // Recompute the entire tree if the editor mode or zoom level changes,
          // or if all the blocks are reset.
          return {
            ...nextState,
            derivedBlockEditingModes: getDerivedBlockEditingModesForTree(nextState, false /* Nav mode off */),
            derivedNavModeBlockEditingModes: getDerivedBlockEditingModesForTree(nextState, true /* Nav mode on */)
          };
        }
    }

    // If there&#039;s no change, the derivedBlockEditingModes from the previous
    // state need to be preserved.
    nextState.derivedBlockEditingModes = (_state$derivedBlockEd = state?.derivedBlockEditingModes) !== null &amp;&amp; _state$derivedBlockEd !== void 0 ? _state$derivedBlockEd : new Map();
    nextState.derivedNavModeBlockEditingModes = (_state$derivedNavMode = state?.derivedNavModeBlockEditingModes) !== null &amp;&amp; _state$derivedNavMode !== void 0 ? _state$derivedNavMode : new Map();
    return nextState;
  };
}
function withAutomaticChangeReset(reducer) {
  return (state, action) =&gt; {
    const nextState = reducer(state, action);
    if (!state) {
      return nextState;
    }

    // Take over the last value without creating a new reference.
    nextState.automaticChangeStatus = state.automaticChangeStatus;
    if (action.type === &#039;MARK_AUTOMATIC_CHANGE&#039;) {
      return {
        ...nextState,
        automaticChangeStatus: &#039;pending&#039;
      };
    }
    if (action.type === &#039;MARK_AUTOMATIC_CHANGE_FINAL&#039; &amp;&amp; state.automaticChangeStatus === &#039;pending&#039;) {
      return {
        ...nextState,
        automaticChangeStatus: &#039;final&#039;
      };
    }

    // If there&#039;s a change that doesn&#039;t affect blocks or selection, maintain
    // the current status.
    if (nextState.blocks === state.blocks &amp;&amp; nextState.selection === state.selection) {
      return nextState;
    }

    // As long as the state is not final, ignore any selection changes.
    if (nextState.automaticChangeStatus !== &#039;final&#039; &amp;&amp; nextState.selection !== state.selection) {
      return nextState;
    }

    // Reset the status if blocks change or selection changes (when status is final).
    return {
      ...nextState,
      automaticChangeStatus: undefined
    };
  };
}
/* harmony default export */ const reducer = ((0,external_wp_compose_namespaceObject.pipe)(withDerivedBlockEditingModes, withAutomaticChangeReset)(combinedReducers));

;// external [&quot;wp&quot;,&quot;primitives&quot;]
const external_wp_primitives_namespaceObject = window[&quot;wp&quot;][&quot;primitives&quot;];
;// external &quot;ReactJSXRuntime&quot;
const external_ReactJSXRuntime_namespaceObject = window[&quot;ReactJSXRuntime&quot;];
;// ./node_modules/@wordpress/icons/build-module/library/symbol.js
/**
 * WordPress dependencies
 */


const symbol = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;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&quot;
  })
});
/* harmony default export */ const library_symbol = (symbol);

;// external [&quot;wp&quot;,&quot;richText&quot;]
const external_wp_richText_namespaceObject = window[&quot;wp&quot;][&quot;richText&quot;];
;// external [&quot;wp&quot;,&quot;preferences&quot;]
const external_wp_preferences_namespaceObject = window[&quot;wp&quot;][&quot;preferences&quot;];
;// external [&quot;wp&quot;,&quot;blockSerializationDefaultParser&quot;]
const external_wp_blockSerializationDefaultParser_namespaceObject = window[&quot;wp&quot;][&quot;blockSerializationDefaultParser&quot;];
;// ./node_modules/@wordpress/block-editor/build-module/store/constants.js
const STORE_NAME = &#039;core/block-editor&#039;;

;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/block-patterns-tab/utils.js
/**
 * WordPress dependencies
 */


const INSERTER_PATTERN_TYPES = {
  user: &#039;user&#039;,
  theme: &#039;theme&#039;,
  directory: &#039;directory&#039;
};
const INSERTER_SYNC_TYPES = {
  full: &#039;fully&#039;,
  unsynced: &#039;unsynced&#039;
};
const allPatternsCategory = {
  name: &#039;allPatterns&#039;,
  label: (0,external_wp_i18n_namespaceObject._x)(&#039;All&#039;, &#039;patterns&#039;)
};
const myPatternsCategory = {
  name: &#039;myPatterns&#039;,
  label: (0,external_wp_i18n_namespaceObject.__)(&#039;My patterns&#039;)
};
const starterPatternsCategory = {
  name: &#039;core/starter-content&#039;,
  label: (0,external_wp_i18n_namespaceObject.__)(&#039;Starter content&#039;)
};
function isPatternFiltered(pattern, sourceFilter, syncFilter) {
  const isUserPattern = pattern.name.startsWith(&#039;core/block&#039;);
  const isDirectoryPattern = pattern.source === &#039;core&#039; || pattern.source?.startsWith(&#039;pattern-directory&#039;);

  // If theme source selected, filter out user created patterns and those from
  // the core patterns directory.
  if (sourceFilter === INSERTER_PATTERN_TYPES.theme &amp;&amp; (isUserPattern || isDirectoryPattern)) {
    return true;
  }

  // If the directory source is selected, filter out user created patterns
  // and those bundled with the theme.
  if (sourceFilter === INSERTER_PATTERN_TYPES.directory &amp;&amp; (isUserPattern || !isDirectoryPattern)) {
    return true;
  }

  // If user source selected, filter out theme patterns.
  if (sourceFilter === INSERTER_PATTERN_TYPES.user &amp;&amp; pattern.type !== INSERTER_PATTERN_TYPES.user) {
    return true;
  }

  // Filter by sync status.
  if (syncFilter === INSERTER_SYNC_TYPES.full &amp;&amp; pattern.syncStatus !== &#039;&#039;) {
    return true;
  }
  if (syncFilter === INSERTER_SYNC_TYPES.unsynced &amp;&amp; pattern.syncStatus !== &#039;unsynced&#039; &amp;&amp; isUserPattern) {
    return true;
  }
  return false;
}

;// ./node_modules/@wordpress/block-editor/build-module/utils/object.js
/**
 * Immutably sets a value inside an object. Like `lodash#set`, but returning a
 * new object. Treats nullish initial values as empty objects. Clones any
 * nested objects. Supports arrays, too.
 *
 * @param {Object}              object Object to set a value in.
 * @param {number|string|Array} path   Path in the object to modify.
 * @param {*}                   value  New value to set.
 * @return {Object} Cloned object with the new value set.
 */
function setImmutably(object, path, value) {
  // Normalize path
  path = Array.isArray(path) ? [...path] : [path];

  // Shallowly clone the base of the object
  object = Array.isArray(object) ? [...object] : {
    ...object
  };
  const leaf = path.pop();

  // Traverse object from root to leaf, shallowly cloning at each level
  let prev = object;
  for (const key of path) {
    const lvl = prev[key];
    prev = prev[key] = Array.isArray(lvl) ? [...lvl] : {
      ...lvl
    };
  }
  prev[leaf] = value;
  return object;
}

/**
 * Helper util to return a value from a certain path of the object.
 * Path is specified as either:
 * - a string of properties, separated by dots, for example: &quot;x.y&quot;.
 * - an array of properties, for example `[ &#039;x&#039;, &#039;y&#039; ]`.
 * You can also specify a default value in case the result is nullish.
 *
 * @param {Object}       object       Input object.
 * @param {string|Array} path         Path to the object property.
 * @param {*}            defaultValue Default value if the value at the specified path is nullish.
 * @return {*} Value of the object property at the specified path.
 */
const getValueFromObjectPath = (object, path, defaultValue) =&gt; {
  var _value;
  const arrayPath = Array.isArray(path) ? path : path.split(&#039;.&#039;);
  let value = object;
  arrayPath.forEach(fieldName =&gt; {
    value = value?.[fieldName];
  });
  return (_value = value) !== null &amp;&amp; _value !== void 0 ? _value : defaultValue;
};

/**
 * Helper util to filter out objects with duplicate values for a given property.
 *
 * @param {Object[]} array    Array of objects to filter.
 * @param {string}   property Property to filter unique values by.
 *
 * @return {Object[]} Array of objects with unique values for the specified property.
 */
function uniqByProperty(array, property) {
  const seen = new Set();
  return array.filter(item =&gt; {
    const value = item[property];
    return seen.has(value) ? false : seen.add(value);
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/store/get-block-settings.js
/**
 * WordPress dependencies
 */



/**
 * Internal dependencies
 */


const blockedPaths = [&#039;color&#039;, &#039;border&#039;, &#039;dimensions&#039;, &#039;typography&#039;, &#039;spacing&#039;];
const deprecatedFlags = {
  &#039;color.palette&#039;: settings =&gt; settings.colors,
  &#039;color.gradients&#039;: settings =&gt; settings.gradients,
  &#039;color.custom&#039;: settings =&gt; settings.disableCustomColors === undefined ? undefined : !settings.disableCustomColors,
  &#039;color.customGradient&#039;: settings =&gt; settings.disableCustomGradients === undefined ? undefined : !settings.disableCustomGradients,
  &#039;typography.fontSizes&#039;: settings =&gt; settings.fontSizes,
  &#039;typography.customFontSize&#039;: settings =&gt; settings.disableCustomFontSizes === undefined ? undefined : !settings.disableCustomFontSizes,
  &#039;typography.lineHeight&#039;: settings =&gt; settings.enableCustomLineHeight,
  &#039;spacing.units&#039;: settings =&gt; {
    if (settings.enableCustomUnits === undefined) {
      return;
    }
    if (settings.enableCustomUnits === true) {
      return [&#039;px&#039;, &#039;em&#039;, &#039;rem&#039;, &#039;vh&#039;, &#039;vw&#039;, &#039;%&#039;];
    }
    return settings.enableCustomUnits;
  },
  &#039;spacing.padding&#039;: settings =&gt; settings.enableCustomSpacing
};
const prefixedFlags = {
  /*
   * These were only available in the plugin
   * and can be removed when the minimum WordPress version
   * for the plugin is 5.9.
   */
  &#039;border.customColor&#039;: &#039;border.color&#039;,
  &#039;border.customStyle&#039;: &#039;border.style&#039;,
  &#039;border.customWidth&#039;: &#039;border.width&#039;,
  &#039;typography.customFontStyle&#039;: &#039;typography.fontStyle&#039;,
  &#039;typography.customFontWeight&#039;: &#039;typography.fontWeight&#039;,
  &#039;typography.customLetterSpacing&#039;: &#039;typography.letterSpacing&#039;,
  &#039;typography.customTextDecorations&#039;: &#039;typography.textDecoration&#039;,
  &#039;typography.customTextTransforms&#039;: &#039;typography.textTransform&#039;,
  /*
   * These were part of WordPress 5.8 and we need to keep them.
   */
  &#039;border.customRadius&#039;: &#039;border.radius&#039;,
  &#039;spacing.customMargin&#039;: &#039;spacing.margin&#039;,
  &#039;spacing.customPadding&#039;: &#039;spacing.padding&#039;,
  &#039;typography.customLineHeight&#039;: &#039;typography.lineHeight&#039;
};

/**
 * Remove `custom` prefixes for flags that did not land in 5.8.
 *
 * This provides continued support for `custom` prefixed properties. It will
 * be removed once third party devs have had sufficient time to update themes,
 * plugins, etc.
 *
 * @see https://github.com/WordPress/gutenberg/pull/34485
 *
 * @param {string} path Path to desired value in settings.
 * @return {string}     The value for defined setting.
 */
const removeCustomPrefixes = path =&gt; {
  return prefixedFlags[path] || path;
};
function getBlockSettings(state, clientId, ...paths) {
  const blockName = getBlockName(state, clientId);
  const candidates = [];
  if (clientId) {
    let id = clientId;
    do {
      const name = getBlockName(state, id);
      if ((0,external_wp_blocks_namespaceObject.hasBlockSupport)(name, &#039;__experimentalSettings&#039;, false)) {
        candidates.push(id);
      }
    } while (id = state.blocks.parents.get(id));
  }
  return paths.map(path =&gt; {
    if (blockedPaths.includes(path)) {
      // eslint-disable-next-line no-console
      console.warn(&#039;Top level useSetting paths are disabled. Please use a subpath to query the information needed.&#039;);
      return undefined;
    }

    // 0. Allow third parties to filter the block&#039;s settings at runtime.
    let result = (0,external_wp_hooks_namespaceObject.applyFilters)(&#039;blockEditor.useSetting.before&#039;, undefined, path, clientId, blockName);
    if (undefined !== result) {
      return result;
    }
    const normalizedPath = removeCustomPrefixes(path);

    // 1. Take settings from the block instance or its ancestors.
    // Start from the current block and work our way up the ancestors.
    for (const candidateClientId of candidates) {
      var _getValueFromObjectPa;
      const candidateAtts = getBlockAttributes(state, candidateClientId);
      result = (_getValueFromObjectPa = getValueFromObjectPath(candidateAtts.settings?.blocks?.[blockName], normalizedPath)) !== null &amp;&amp; _getValueFromObjectPa !== void 0 ? _getValueFromObjectPa : getValueFromObjectPath(candidateAtts.settings, normalizedPath);
      if (result !== undefined) {
        // Stop the search for more distant ancestors and move on.
        break;
      }
    }

    // 2. Fall back to the settings from the block editor store (__experimentalFeatures).
    const settings = getSettings(state);
    if (result === undefined &amp;&amp; blockName) {
      result = getValueFromObjectPath(settings.__experimentalFeatures?.blocks?.[blockName], normalizedPath);
    }
    if (result === undefined) {
      result = getValueFromObjectPath(settings.__experimentalFeatures, normalizedPath);
    }

    // Return if the setting was found in either the block instance or the store.
    if (result !== undefined) {
      if (external_wp_blocks_namespaceObject.__EXPERIMENTAL_PATHS_WITH_OVERRIDE[normalizedPath]) {
        var _ref, _result$custom;
        return (_ref = (_result$custom = result.custom) !== null &amp;&amp; _result$custom !== void 0 ? _result$custom : result.theme) !== null &amp;&amp; _ref !== void 0 ? _ref : result.default;
      }
      return result;
    }

    // 3. Otherwise, use deprecated settings.
    const deprecatedSettingsValue = deprecatedFlags[normalizedPath]?.(settings);
    if (deprecatedSettingsValue !== undefined) {
      return deprecatedSettingsValue;
    }

    // 4. Fallback for typography.dropCap:
    // This is only necessary to support typography.dropCap.
    // when __experimentalFeatures are not present (core without plugin).
    // To remove when __experimentalFeatures are ported to core.
    return normalizedPath === &#039;typography.dropCap&#039; ? true : undefined;
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/store/private-selectors.js
/**
 * WordPress dependencies
 */


/**
 * Internal dependencies
 */








/**
 * Returns true if the block interface is hidden, or false otherwise.
 *
 * @param {Object} state Global application state.
 *
 * @return {boolean} Whether the block toolbar is hidden.
 */
function private_selectors_isBlockInterfaceHidden(state) {
  return state.isBlockInterfaceHidden;
}

/**
 * Gets the client ids of the last inserted blocks.
 *
 * @param {Object} state Global application state.
 * @return {Array|undefined} Client Ids of the last inserted block(s).
 */
function getLastInsertedBlocksClientIds(state) {
  return state?.lastBlockInserted?.clientIds;
}
function getBlockWithoutAttributes(state, clientId) {
  return state.blocks.byClientId.get(clientId);
}

/**
 * Returns true if all of the descendants of a block with the given client ID
 * have an editing mode of &#039;disabled&#039;, or false otherwise.
 *
 * @param {Object} state    Global application state.
 * @param {string} clientId The block client ID.
 *
 * @return {boolean} Whether the block descendants are disabled.
 */
const isBlockSubtreeDisabled = (state, clientId) =&gt; {
  const isChildSubtreeDisabled = childClientId =&gt; {
    return getBlockEditingMode(state, childClientId) === &#039;disabled&#039; &amp;&amp; getBlockOrder(state, childClientId).every(isChildSubtreeDisabled);
  };
  return getBlockOrder(state, clientId).every(isChildSubtreeDisabled);
};
function getEnabledClientIdsTreeUnmemoized(state, rootClientId) {
  const blockOrder = getBlockOrder(state, rootClientId);
  const result = [];
  for (const clientId of blockOrder) {
    const innerBlocks = getEnabledClientIdsTreeUnmemoized(state, clientId);
    if (getBlockEditingMode(state, clientId) !== &#039;disabled&#039;) {
      result.push({
        clientId,
        innerBlocks
      });
    } else {
      result.push(...innerBlocks);
    }
  }
  return result;
}

/**
 * Returns a tree of block objects with only clientID and innerBlocks set.
 * Blocks with a &#039;disabled&#039; editing mode are not included.
 *
 * @param {Object}  state        Global application state.
 * @param {?string} rootClientId Optional root client ID of block list.
 *
 * @return {Object[]} Tree of block objects with only clientID and innerBlocks set.
 */
const getEnabledClientIdsTree = (0,external_wp_data_namespaceObject.createRegistrySelector)(select =&gt; (0,external_wp_data_namespaceObject.createSelector)(getEnabledClientIdsTreeUnmemoized, state =&gt; [state.blocks.order, state.derivedBlockEditingModes, state.derivedNavModeBlockEditingModes, state.blockEditingModes, state.settings.templateLock, state.blockListSettings, select(STORE_NAME).__unstableGetEditorMode(state)]));

/**
 * Returns a list of a given block&#039;s ancestors, from top to bottom. Blocks with
 * a &#039;disabled&#039; editing mode are excluded.
 *
 * @see getBlockParents
 *
 * @param {Object}  state     Global application state.
 * @param {string}  clientId  The block client ID.
 * @param {boolean} ascending Order results from bottom to top (true) or top
 *                            to bottom (false).
 */
const getEnabledBlockParents = (0,external_wp_data_namespaceObject.createSelector)((state, clientId, ascending = false) =&gt; {
  return getBlockParents(state, clientId, ascending).filter(parent =&gt; getBlockEditingMode(state, parent) !== &#039;disabled&#039;);
}, state =&gt; [state.blocks.parents, state.blockEditingModes, state.settings.templateLock, state.blockListSettings]);

/**
 * Selector that returns the data needed to display a prompt when certain
 * blocks are removed, or `false` if no such prompt is requested.
 *
 * @param {Object} state Global application state.
 *
 * @return {Object|false} Data for removal prompt display, if any.
 */
function getRemovalPromptData(state) {
  return state.removalPromptData;
}

/**
 * Returns true if removal prompt exists, or false otherwise.
 *
 * @param {Object} state Global application state.
 *
 * @return {boolean} Whether removal prompt exists.
 */
function getBlockRemovalRules(state) {
  return state.blockRemovalRules;
}

/**
 * Returns the client ID of the block settings menu that is currently open.
 *
 * @param {Object} state Global application state.
 * @return {string|null} The client ID of the block menu that is currently open.
 */
function getOpenedBlockSettingsMenu(state) {
  return state.openedBlockSettingsMenu;
}

/**
 * Returns all style overrides, intended to be merged with global editor styles.
 *
 * Overrides are sorted to match the order of the blocks they relate to. This
 * is useful to maintain correct CSS cascade order.
 *
 * @param {Object} state Global application state.
 *
 * @return {Array} An array of style ID to style override pairs.
 */
const getStyleOverrides = (0,external_wp_data_namespaceObject.createSelector)(state =&gt; {
  const clientIds = getClientIdsWithDescendants(state);
  const clientIdMap = clientIds.reduce((acc, clientId, index) =&gt; {
    acc[clientId] = index;
    return acc;
  }, {});
  return [...state.styleOverrides].sort((overrideA, overrideB) =&gt; {
    var _clientIdMap$clientId, _clientIdMap$clientId2;
    // Once the overrides Map is spread to an array, the first element
    // is the key, while the second is the override itself including
    // the clientId to sort by.
    const [, {
      clientId: clientIdA
    }] = overrideA;
    const [, {
      clientId: clientIdB
    }] = overrideB;
    const aIndex = (_clientIdMap$clientId = clientIdMap[clientIdA]) !== null &amp;&amp; _clientIdMap$clientId !== void 0 ? _clientIdMap$clientId : -1;
    const bIndex = (_clientIdMap$clientId2 = clientIdMap[clientIdB]) !== null &amp;&amp; _clientIdMap$clientId2 !== void 0 ? _clientIdMap$clientId2 : -1;
    return aIndex - bIndex;
  });
}, state =&gt; [state.blocks.order, state.styleOverrides]);

/** @typedef {import(&#039;./actions&#039;).InserterMediaCategory} InserterMediaCategory */
/**
 * Returns the registered inserter media categories through the public API.
 *
 * @param {Object} state Editor state.
 *
 * @return {InserterMediaCategory[]} Inserter media categories.
 */
function getRegisteredInserterMediaCategories(state) {
  return state.registeredInserterMediaCategories;
}

/**
 * Returns an array containing the allowed inserter media categories.
 * It merges the registered media categories from extenders with the
 * core ones. It also takes into account the allowed `mime_types`, which
 * can be altered by `upload_mimes` filter and restrict some of them.
 *
 * @param {Object} state Global application state.
 *
 * @return {InserterMediaCategory[]} Client IDs of descendants.
 */
const getInserterMediaCategories = (0,external_wp_data_namespaceObject.createSelector)(state =&gt; {
  const {
    settings: {
      inserterMediaCategories,
      allowedMimeTypes,
      enableOpenverseMediaCategory
    },
    registeredInserterMediaCategories
  } = state;
  // The allowed `mime_types` can be altered by `upload_mimes` filter and restrict
  // some of them. In this case we shouldn&#039;t add the category to the available media
  // categories list in the inserter.
  if (!inserterMediaCategories &amp;&amp; !registeredInserterMediaCategories.length || !allowedMimeTypes) {
    return;
  }
  const coreInserterMediaCategoriesNames = inserterMediaCategories?.map(({
    name
  }) =&gt; name) || [];
  const mergedCategories = [...(inserterMediaCategories || []), ...(registeredInserterMediaCategories || []).filter(({
    name
  }) =&gt; !coreInserterMediaCategoriesNames.includes(name))];
  return mergedCategories.filter(category =&gt; {
    // Check if Openverse category is enabled.
    if (!enableOpenverseMediaCategory &amp;&amp; category.name === &#039;openverse&#039;) {
      return false;
    }
    return Object.values(allowedMimeTypes).some(mimeType =&gt; mimeType.startsWith(`${category.mediaType}/`));
  });
}, state =&gt; [state.settings.inserterMediaCategories, state.settings.allowedMimeTypes, state.settings.enableOpenverseMediaCategory, state.registeredInserterMediaCategories]);

/**
 * Returns whether there is at least one allowed pattern for inner blocks children.
 * This is useful for deferring the parsing of all patterns until needed.
 *
 * @param {Object} state               Editor state.
 * @param {string} [rootClientId=null] Target root client ID.
 *
 * @return {boolean} If there is at least one allowed pattern.
 */
const hasAllowedPatterns = (0,external_wp_data_namespaceObject.createRegistrySelector)(select =&gt; (0,external_wp_data_namespaceObject.createSelector)((state, rootClientId = null) =&gt; {
  const {
    getAllPatterns
  } = unlock(select(STORE_NAME));
  const patterns = getAllPatterns();
  const {
    allowedBlockTypes
  } = getSettings(state);
  return patterns.some(pattern =&gt; {
    const {
      inserter = true
    } = pattern;
    if (!inserter) {
      return false;
    }
    const grammar = getGrammar(pattern);
    return checkAllowListRecursive(grammar, allowedBlockTypes) &amp;&amp; grammar.every(({
      name: blockName
    }) =&gt; canInsertBlockType(state, blockName, rootClientId));
  });
}, (state, rootClientId) =&gt; [...getAllPatternsDependants(select)(state), ...getInsertBlockTypeDependants(select)(state, rootClientId)]));
function mapUserPattern(userPattern, __experimentalUserPatternCategories = []) {
  return {
    name: `core/block/${userPattern.id}`,
    id: userPattern.id,
    type: INSERTER_PATTERN_TYPES.user,
    title: userPattern.title.raw,
    categories: userPattern.wp_pattern_category?.map(catId =&gt; {
      const category = __experimentalUserPatternCategories.find(({
        id
      }) =&gt; id === catId);
      return category ? category.slug : catId;
    }),
    content: userPattern.content.raw,
    syncStatus: userPattern.wp_pattern_sync_status
  };
}
const getPatternBySlug = (0,external_wp_data_namespaceObject.createRegistrySelector)(select =&gt; (0,external_wp_data_namespaceObject.createSelector)((state, patternName) =&gt; {
  var _state$settings$__exp, _state$settings$selec;
  // Only fetch reusable blocks if we know we need them. To do: maybe
  // use the entity record API to retrieve the block by slug.
  if (patternName?.startsWith(&#039;core/block/&#039;)) {
    const _id = parseInt(patternName.slice(&#039;core/block/&#039;.length), 10);
    const block = unlock(select(STORE_NAME)).getReusableBlocks().find(({
      id
    }) =&gt; id === _id);
    if (!block) {
      return null;
    }
    return mapUserPattern(block, state.settings.__experimentalUserPatternCategories);
  }
  return [
  // This setting is left for back compat.
  ...((_state$settings$__exp = state.settings.__experimentalBlockPatterns) !== null &amp;&amp; _state$settings$__exp !== void 0 ? _state$settings$__exp : []), ...((_state$settings$selec = state.settings[selectBlockPatternsKey]?.(select)) !== null &amp;&amp; _state$settings$selec !== void 0 ? _state$settings$selec : [])].find(({
    name
  }) =&gt; name === patternName);
}, (state, patternName) =&gt; patternName?.startsWith(&#039;core/block/&#039;) ? [unlock(select(STORE_NAME)).getReusableBlocks(), state.settings.__experimentalReusableBlocks] : [state.settings.__experimentalBlockPatterns, state.settings[selectBlockPatternsKey]?.(select)]));
const getAllPatterns = (0,external_wp_data_namespaceObject.createRegistrySelector)(select =&gt; (0,external_wp_data_namespaceObject.createSelector)(state =&gt; {
  var _state$settings$__exp2, _state$settings$selec2;
  return [...unlock(select(STORE_NAME)).getReusableBlocks().map(userPattern =&gt; mapUserPattern(userPattern, state.settings.__experimentalUserPatternCategories)),
  // This setting is left for back compat.
  ...((_state$settings$__exp2 = state.settings.__experimentalBlockPatterns) !== null &amp;&amp; _state$settings$__exp2 !== void 0 ? _state$settings$__exp2 : []), ...((_state$settings$selec2 = state.settings[selectBlockPatternsKey]?.(select)) !== null &amp;&amp; _state$settings$selec2 !== void 0 ? _state$settings$selec2 : [])].filter((x, index, arr) =&gt; index === arr.findIndex(y =&gt; x.name === y.name));
}, getAllPatternsDependants(select)));
const EMPTY_ARRAY = [];
const getReusableBlocks = (0,external_wp_data_namespaceObject.createRegistrySelector)(select =&gt; state =&gt; {
  var _ref;
  const reusableBlocksSelect = state.settings[reusableBlocksSelectKey];
  return (_ref = reusableBlocksSelect ? reusableBlocksSelect(select) : state.settings.__experimentalReusableBlocks) !== null &amp;&amp; _ref !== void 0 ? _ref : EMPTY_ARRAY;
});

/**
 * Returns the element of the last element that had focus when focus left the editor canvas.
 *
 * @param {Object} state Block editor state.
 *
 * @return {Object} Element.
 */
function getLastFocus(state) {
  return state.lastFocus;
}

/**
 * Returns true if the user is dragging anything, or false otherwise. It is possible for a
 * user to be dragging data from outside of the editor, so this selector is separate from
 * the `isDraggingBlocks` selector which only returns true if the user is dragging blocks.
 *
 * @param {Object} state Global application state.
 *
 * @return {boolean} Whether user is dragging.
 */
function private_selectors_isDragging(state) {
  return state.isDragging;
}

/**
 * Retrieves the expanded block from the state.
 *
 * @param {Object} state Block editor state.
 *
 * @return {string|null} The client ID of the expanded block, if set.
 */
function getExpandedBlock(state) {
  return state.expandedBlock;
}

/**
 * Retrieves the client ID of the ancestor block that is content locking the block
 * with the provided client ID.
 *
 * @param {Object} state    Global application state.
 * @param {string} clientId Client Id of the block.
 *
 * @return {?string} Client ID of the ancestor block that is content locking the block.
 */
const getContentLockingParent = (state, clientId) =&gt; {
  let current = clientId;
  let result;
  while (!result &amp;&amp; (current = state.blocks.parents.get(current))) {
    if (getTemplateLock(state, current) === &#039;contentOnly&#039;) {
      result = current;
    }
  }
  return result;
};

/**
 * Retrieves the client ID of the parent section block.
 *
 * @param {Object} state    Global application state.
 * @param {string} clientId Client Id of the block.
 *
 * @return {?string} Client ID of the ancestor block that is content locking the block.
 */
const getParentSectionBlock = (state, clientId) =&gt; {
  let current = clientId;
  let result;
  while (!result &amp;&amp; (current = state.blocks.parents.get(current))) {
    if (isSectionBlock(state, current)) {
      result = current;
    }
  }
  return result;
};

/**
 * Retrieves the client ID is a content locking parent
 *
 * @param {Object} state    Global application state.
 * @param {string} clientId Client Id of the block.
 *
 * @return {boolean} Whether the block is a content locking parent.
 */
function isSectionBlock(state, clientId) {
  const blockName = getBlockName(state, clientId);
  if (blockName === &#039;core/block&#039; || getTemplateLock(state, clientId) === &#039;contentOnly&#039;) {
    return true;
  }

  // Template parts become sections in navigation mode.
  const _isNavigationMode = isNavigationMode(state);
  if (_isNavigationMode &amp;&amp; blockName === &#039;core/template-part&#039;) {
    return true;
  }
  const sectionRootClientId = getSectionRootClientId(state);
  const sectionClientIds = getBlockOrder(state, sectionRootClientId);
  return _isNavigationMode &amp;&amp; sectionClientIds.includes(clientId);
}

/**
 * Retrieves the client ID of the block that is content locked but is
 * currently being temporarily edited as a non-locked block.
 *
 * @param {Object} state Global application state.
 *
 * @return {?string} The client ID of the block being temporarily edited as a non-locked block.
 */
function getTemporarilyEditingAsBlocks(state) {
  return state.temporarilyEditingAsBlocks;
}

/**
 * Returns the focus mode that should be reapplied when the user stops editing
 * a content locked blocks as a block without locking.
 *
 * @param {Object} state Global application state.
 *
 * @return {?string} The focus mode that should be re-set when temporarily editing as blocks stops.
 */
function getTemporarilyEditingFocusModeToRevert(state) {
  return state.temporarilyEditingFocusModeRevert;
}

/**
 * Returns the style attributes of multiple blocks.
 *
 * @param {Object}   state     Global application state.
 * @param {string[]} clientIds An array of block client IDs.
 *
 * @return {Object} An object where keys are client IDs and values are the corresponding block styles or undefined.
 */
const getBlockStyles = (0,external_wp_data_namespaceObject.createSelector)((state, clientIds) =&gt; clientIds.reduce((styles, clientId) =&gt; {
  styles[clientId] = state.blocks.attributes.get(clientId)?.style;
  return styles;
}, {}), (state, clientIds) =&gt; [...clientIds.map(clientId =&gt; state.blocks.attributes.get(clientId)?.style)]);

/**
 * Retrieves the client ID of the block which contains the blocks
 * acting as &quot;sections&quot; in the editor. This is typically the &quot;main content&quot;
 * of the template/post.
 *
 * @param {Object} state Editor state.
 *
 * @return {string|undefined} The section root client ID or undefined if not set.
 */
function getSectionRootClientId(state) {
  return state.settings?.[sectionRootClientIdKey];
}

/**
 * Returns whether the editor is considered zoomed out.
 *
 * @param {Object} state Global application state.
 * @return {boolean} Whether the editor is zoomed.
 */
function isZoomOut(state) {
  return state.zoomLevel === &#039;auto-scaled&#039; || state.zoomLevel &lt; 100;
}

/**
 * Returns whether the zoom level.
 *
 * @param {Object} state Global application state.
 * @return {number|&quot;auto-scaled&quot;} Zoom level.
 */
function getZoomLevel(state) {
  return state.zoomLevel;
}

/**
 * Finds the closest block where the block is allowed to be inserted.
 *
 * @param {Object}            state    Editor state.
 * @param {string[] | string} name     Block name or names.
 * @param {string}            clientId Default insertion point.
 *
 * @return {string} clientID of the closest container when the block name can be inserted.
 */
function getClosestAllowedInsertionPoint(state, name, clientId = &#039;&#039;) {
  const blockNames = Array.isArray(name) ? name : [name];
  const areBlockNamesAllowedInClientId = id =&gt; blockNames.every(currentName =&gt; canInsertBlockType(state, currentName, id));

  // If we&#039;re trying to insert at the root level and it&#039;s not allowed
  // Try the section root instead.
  if (!clientId) {
    if (areBlockNamesAllowedInClientId(clientId)) {
      return clientId;
    }
    const sectionRootClientId = getSectionRootClientId(state);
    if (sectionRootClientId &amp;&amp; areBlockNamesAllowedInClientId(sectionRootClientId)) {
      return sectionRootClientId;
    }
    return null;
  }

  // Traverse the block tree up until we find a place where we can insert.
  let current = clientId;
  while (current !== null &amp;&amp; !areBlockNamesAllowedInClientId(current)) {
    const parentClientId = getBlockRootClientId(state, current);
    current = parentClientId;
  }
  return current;
}
function getClosestAllowedInsertionPointForPattern(state, pattern, clientId) {
  const {
    allowedBlockTypes
  } = getSettings(state);
  const isAllowed = checkAllowListRecursive(getGrammar(pattern), allowedBlockTypes);
  if (!isAllowed) {
    return null;
  }
  const names = getGrammar(pattern).map(({
    blockName: name
  }) =&gt; name);
  return getClosestAllowedInsertionPoint(state, names, clientId);
}

/**
 * Where the point where the next block will be inserted into.
 *
 * @param {Object} state
 * @return {Object} where the insertion point in the block editor is or null if none is set.
 */
function getInsertionPoint(state) {
  return state.insertionPoint;
}

;// ./node_modules/@wordpress/block-editor/build-module/store/utils.js
/**
 * WordPress dependencies
 */



/**
 * Internal dependencies
 */




const isFiltered = Symbol(&#039;isFiltered&#039;);
const parsedPatternCache = new WeakMap();
const grammarMapCache = new WeakMap();
function parsePattern(pattern) {
  const blocks = (0,external_wp_blocks_namespaceObject.parse)(pattern.content, {
    __unstableSkipMigrationLogs: true
  });
  if (blocks.length === 1) {
    blocks[0].attributes = {
      ...blocks[0].attributes,
      metadata: {
        ...(blocks[0].attributes.metadata || {}),
        categories: pattern.categories,
        patternName: pattern.name,
        name: blocks[0].attributes.metadata?.name || pattern.title
      }
    };
  }
  return {
    ...pattern,
    blocks
  };
}
function getParsedPattern(pattern) {
  let parsedPattern = parsedPatternCache.get(pattern);
  if (!parsedPattern) {
    parsedPattern = parsePattern(pattern);
    parsedPatternCache.set(pattern, parsedPattern);
  }
  return parsedPattern;
}
function getGrammar(pattern) {
  let grammarMap = grammarMapCache.get(pattern);
  if (!grammarMap) {
    grammarMap = (0,external_wp_blockSerializationDefaultParser_namespaceObject.parse)(pattern.content);
    // Block names are null only at the top level for whitespace.
    grammarMap = grammarMap.filter(block =&gt; block.blockName !== null);
    grammarMapCache.set(pattern, grammarMap);
  }
  return grammarMap;
}
const checkAllowList = (list, item, defaultResult = null) =&gt; {
  if (typeof list === &#039;boolean&#039;) {
    return list;
  }
  if (Array.isArray(list)) {
    // TODO: when there is a canonical way to detect that we are editing a post
    // the following check should be changed to something like:
    // if ( list.includes( &#039;core/post-content&#039; ) &amp;&amp; getEditorMode() === &#039;post-content&#039; &amp;&amp; item === null )
    if (list.includes(&#039;core/post-content&#039;) &amp;&amp; item === null) {
      return true;
    }
    return list.includes(item);
  }
  return defaultResult;
};
const checkAllowListRecursive = (blocks, allowedBlockTypes) =&gt; {
  if (typeof allowedBlockTypes === &#039;boolean&#039;) {
    return allowedBlockTypes;
  }
  const blocksQueue = [...blocks];
  while (blocksQueue.length &gt; 0) {
    const block = blocksQueue.shift();
    const isAllowed = checkAllowList(allowedBlockTypes, block.name || block.blockName, true);
    if (!isAllowed) {
      return false;
    }
    block.innerBlocks?.forEach(innerBlock =&gt; {
      blocksQueue.push(innerBlock);
    });
  }
  return true;
};
const getAllPatternsDependants = select =&gt; state =&gt; {
  return [state.settings.__experimentalBlockPatterns, state.settings.__experimentalUserPatternCategories, state.settings.__experimentalReusableBlocks, state.settings[selectBlockPatternsKey]?.(select), state.blockPatterns, unlock(select(STORE_NAME)).getReusableBlocks()];
};
const getInsertBlockTypeDependants = select =&gt; (state, rootClientId) =&gt; {
  return [state.blockListSettings[rootClientId], state.blocks.byClientId.get(rootClientId), state.settings.allowedBlockTypes, state.settings.templateLock, state.blockEditingModes, select(STORE_NAME).__unstableGetEditorMode(state), getSectionRootClientId(state)];
};

;// ./node_modules/@wordpress/block-editor/build-module/utils/sorting.js
/**
 * Recursive stable sorting comparator function.
 *
 * @param {string|Function} field Field to sort by.
 * @param {Array}           items Items to sort.
 * @param {string}          order Order, &#039;asc&#039; or &#039;desc&#039;.
 * @return {Function} Comparison function to be used in a `.sort()`.
 */
const comparator = (field, items, order) =&gt; {
  return (a, b) =&gt; {
    let cmpA, cmpB;
    if (typeof field === &#039;function&#039;) {
      cmpA = field(a);
      cmpB = field(b);
    } else {
      cmpA = a[field];
      cmpB = b[field];
    }
    if (cmpA &gt; cmpB) {
      return order === &#039;asc&#039; ? 1 : -1;
    } else if (cmpB &gt; cmpA) {
      return order === &#039;asc&#039; ? -1 : 1;
    }
    const orderA = items.findIndex(item =&gt; item === a);
    const orderB = items.findIndex(item =&gt; item === b);

    // Stable sort: maintaining original array order
    if (orderA &gt; orderB) {
      return 1;
    } else if (orderB &gt; orderA) {
      return -1;
    }
    return 0;
  };
};

/**
 * Order items by a certain key.
 * Supports decorator functions that allow complex picking of a comparison field.
 * Sorts in ascending order by default, but supports descending as well.
 * Stable sort - maintains original order of equal items.
 *
 * @param {Array}           items Items to order.
 * @param {string|Function} field Field to order by.
 * @param {string}          order Sorting order, `asc` or `desc`.
 * @return {Array} Sorted items.
 */
function orderBy(items, field, order = &#039;asc&#039;) {
  return items.concat().sort(comparator(field, items, order));
}

;// ./node_modules/@wordpress/block-editor/build-module/store/selectors.js
/**
 * WordPress dependencies
 */









/**
 * Internal dependencies
 */






/**
 * A block selection object.
 *
 * @typedef {Object} WPBlockSelection
 *
 * @property {string} clientId     A block client ID.
 * @property {string} attributeKey A block attribute key.
 * @property {number} offset       An attribute value offset, based on the rich
 *                                 text value. See `wp.richText.create`.
 */

// Module constants.
const MILLISECONDS_PER_HOUR = 3600 * 1000;
const MILLISECONDS_PER_DAY = 24 * 3600 * 1000;
const MILLISECONDS_PER_WEEK = 7 * 24 * 3600 * 1000;

/**
 * Shared reference to an empty array for cases where it is important to avoid
 * returning a new array reference on every invocation, as in a connected or
 * other pure component which performs `shouldComponentUpdate` check on props.
 * This should be used as a last resort, since the normalized data should be
 * maintained by the reducer result in state.
 *
 * @type {Array}
 */
const selectors_EMPTY_ARRAY = [];

/**
 * Shared reference to an empty Set for cases where it is important to avoid
 * returning a new Set reference on every invocation, as in a connected or
 * other pure component which performs `shouldComponentUpdate` check on props.
 * This should be used as a last resort, since the normalized data should be
 * maintained by the reducer result in state.
 *
 * @type {Set}
 */
const EMPTY_SET = new Set();
const DEFAULT_INSERTER_OPTIONS = {
  [isFiltered]: true
};

/**
 * Returns a block&#039;s name given its client ID, or null if no block exists with
 * the client ID.
 *
 * @param {Object} state    Editor state.
 * @param {string} clientId Block client ID.
 *
 * @return {string} Block name.
 */
function getBlockName(state, clientId) {
  const block = state.blocks.byClientId.get(clientId);
  const socialLinkName = &#039;core/social-link&#039;;
  if (external_wp_element_namespaceObject.Platform.OS !== &#039;web&#039; &amp;&amp; block?.name === socialLinkName) {
    const attributes = state.blocks.attributes.get(clientId);
    const {
      service
    } = attributes !== null &amp;&amp; attributes !== void 0 ? attributes : {};
    return service ? `${socialLinkName}-${service}` : socialLinkName;
  }
  return block ? block.name : null;
}

/**
 * Returns whether a block is valid or not.
 *
 * @param {Object} state    Editor state.
 * @param {string} clientId Block client ID.
 *
 * @return {boolean} Is Valid.
 */
function isBlockValid(state, clientId) {
  const block = state.blocks.byClientId.get(clientId);
  return !!block &amp;&amp; block.isValid;
}

/**
 * Returns a block&#039;s attributes given its client ID, or null if no block exists with
 * the client ID.
 *
 * @param {Object} state    Editor state.
 * @param {string} clientId Block client ID.
 *
 * @return {?Object} Block attributes.
 */
function getBlockAttributes(state, clientId) {
  const block = state.blocks.byClientId.get(clientId);
  if (!block) {
    return null;
  }
  return state.blocks.attributes.get(clientId);
}

/**
 * Returns a block given its client ID. This is a parsed copy of the block,
 * containing its `blockName`, `clientId`, and current `attributes` state. This
 * is not the block&#039;s registration settings, which must be retrieved from the
 * blocks module registration store.
 *
 * getBlock recurses through its inner blocks until all its children blocks have
 * been retrieved. Note that getBlock will not return the child inner blocks of
 * an inner block controller. This is because an inner block controller syncs
 * itself with its own entity, and should therefore not be included with the
 * blocks of a different entity. For example, say you call `getBlocks( TP )` to
 * get the blocks of a template part. If another template part is a child of TP,
 * then the nested template part&#039;s child blocks will not be returned. This way,
 * the template block itself is considered part of the parent, but the children
 * are not.
 *
 * @param {Object} state    Editor state.
 * @param {string} clientId Block client ID.
 *
 * @return {Object} Parsed block object.
 */
function getBlock(state, clientId) {
  if (!state.blocks.byClientId.has(clientId)) {
    return null;
  }
  return state.blocks.tree.get(clientId);
}
const __unstableGetBlockWithoutInnerBlocks = (0,external_wp_data_namespaceObject.createSelector)((state, clientId) =&gt; {
  const block = state.blocks.byClientId.get(clientId);
  if (!block) {
    return null;
  }
  return {
    ...block,
    attributes: getBlockAttributes(state, clientId)
  };
}, (state, clientId) =&gt; [state.blocks.byClientId.get(clientId), state.blocks.attributes.get(clientId)]);

/**
 * Returns all block objects for the current post being edited as an array in
 * the order they appear in the post. Note that this will exclude child blocks
 * of nested inner block controllers.
 *
 * @param {Object}  state        Editor state.
 * @param {?string} rootClientId Optional root client ID of block list.
 *
 * @return {Object[]} Post blocks.
 */
function getBlocks(state, rootClientId) {
  const treeKey = !rootClientId || !areInnerBlocksControlled(state, rootClientId) ? rootClientId || &#039;&#039; : &#039;controlled||&#039; + rootClientId;
  return state.blocks.tree.get(treeKey)?.innerBlocks || selectors_EMPTY_ARRAY;
}

/**
 * Returns a stripped down block object containing only its client ID,
 * and its inner blocks&#039; client IDs.
 *
 * @deprecated
 *
 * @param {Object} state    Editor state.
 * @param {string} clientId Client ID of the block to get.
 *
 * @return {Object} Client IDs of the post blocks.
 */
const __unstableGetClientIdWithClientIdsTree = (0,external_wp_data_namespaceObject.createSelector)((state, clientId) =&gt; {
  external_wp_deprecated_default()(&quot;wp.data.select( &#039;core/block-editor&#039; ).__unstableGetClientIdWithClientIdsTree&quot;, {
    since: &#039;6.3&#039;,
    version: &#039;6.5&#039;
  });
  return {
    clientId,
    innerBlocks: __unstableGetClientIdsTree(state, clientId)
  };
}, state =&gt; [state.blocks.order]);

/**
 * Returns the block tree represented in the block-editor store from the
 * given root, consisting of stripped down block objects containing only
 * their client IDs, and their inner blocks&#039; client IDs.
 *
 * @deprecated
 *
 * @param {Object}  state        Editor state.
 * @param {?string} rootClientId Optional root client ID of block list.
 *
 * @return {Object[]} Client IDs of the post blocks.
 */
const __unstableGetClientIdsTree = (0,external_wp_data_namespaceObject.createSelector)((state, rootClientId = &#039;&#039;) =&gt; {
  external_wp_deprecated_default()(&quot;wp.data.select( &#039;core/block-editor&#039; ).__unstableGetClientIdsTree&quot;, {
    since: &#039;6.3&#039;,
    version: &#039;6.5&#039;
  });
  return getBlockOrder(state, rootClientId).map(clientId =&gt; __unstableGetClientIdWithClientIdsTree(state, clientId));
}, state =&gt; [state.blocks.order]);

/**
 * Returns an array containing the clientIds of all descendants of the blocks
 * given. Returned ids are ordered first by the order of the ids given, then
 * by the order that they appear in the editor.
 *
 * @param {Object}          state   Global application state.
 * @param {string|string[]} rootIds Client ID(s) for which descendant blocks are to be returned.
 *
 * @return {Array} Client IDs of descendants.
 */
const getClientIdsOfDescendants = (0,external_wp_data_namespaceObject.createSelector)((state, rootIds) =&gt; {
  rootIds = Array.isArray(rootIds) ? [...rootIds] : [rootIds];
  const ids = [];

  // Add the descendants of the root blocks first.
  for (const rootId of rootIds) {
    const order = state.blocks.order.get(rootId);
    if (order) {
      ids.push(...order);
    }
  }
  let index = 0;

  // Add the descendants of the descendants, recursively.
  while (index &lt; ids.length) {
    const id = ids[index];
    const order = state.blocks.order.get(id);
    if (order) {
      ids.splice(index + 1, 0, ...order);
    }
    index++;
  }
  return ids;
}, state =&gt; [state.blocks.order]);

/**
 * Returns an array containing the clientIds of the top-level blocks and
 * their descendants of any depth (for nested blocks). Ids are returned
 * in the same order that they appear in the editor.
 *
 * @param {Object} state Global application state.
 *
 * @return {Array} ids of top-level and descendant blocks.
 */
const getClientIdsWithDescendants = state =&gt; getClientIdsOfDescendants(state, &#039;&#039;);

/**
 * Returns the total number of blocks, or the total number of blocks with a specific name in a post.
 * The number returned includes nested blocks.
 *
 * @param {Object}  state     Global application state.
 * @param {?string} blockName Optional block name, if specified only blocks of that type will be counted.
 *
 * @return {number} Number of blocks in the post, or number of blocks with name equal to blockName.
 */
const getGlobalBlockCount = (0,external_wp_data_namespaceObject.createSelector)((state, blockName) =&gt; {
  const clientIds = getClientIdsWithDescendants(state);
  if (!blockName) {
    return clientIds.length;
  }
  let count = 0;
  for (const clientId of clientIds) {
    const block = state.blocks.byClientId.get(clientId);
    if (block.name === blockName) {
      count++;
    }
  }
  return count;
}, state =&gt; [state.blocks.order, state.blocks.byClientId]);

/**
 * Returns all blocks that match a blockName. Results include nested blocks.
 *
 * @param {Object}   state     Global application state.
 * @param {string[]} blockName Block name(s) for which clientIds are to be returned.
 *
 * @return {Array} Array of clientIds of blocks with name equal to blockName.
 */
const getBlocksByName = (0,external_wp_data_namespaceObject.createSelector)((state, blockName) =&gt; {
  if (!blockName) {
    return selectors_EMPTY_ARRAY;
  }
  const blockNames = Array.isArray(blockName) ? blockName : [blockName];
  const clientIds = getClientIdsWithDescendants(state);
  const foundBlocks = clientIds.filter(clientId =&gt; {
    const block = state.blocks.byClientId.get(clientId);
    return blockNames.includes(block.name);
  });
  return foundBlocks.length &gt; 0 ? foundBlocks : selectors_EMPTY_ARRAY;
}, state =&gt; [state.blocks.order, state.blocks.byClientId]);

/**
 * Returns all global blocks that match a blockName. Results include nested blocks.
 *
 * @deprecated
 *
 * @param {Object}   state     Global application state.
 * @param {string[]} blockName Block name(s) for which clientIds are to be returned.
 *
 * @return {Array} Array of clientIds of blocks with name equal to blockName.
 */
function __experimentalGetGlobalBlocksByName(state, blockName) {
  external_wp_deprecated_default()(&quot;wp.data.select( &#039;core/block-editor&#039; ).__experimentalGetGlobalBlocksByName&quot;, {
    since: &#039;6.5&#039;,
    alternative: `wp.data.select( &#039;core/block-editor&#039; ).getBlocksByName`
  });
  return getBlocksByName(state, blockName);
}

/**
 * Given an array of block client IDs, returns the corresponding array of block
 * objects.
 *
 * @param {Object}   state     Editor state.
 * @param {string[]} clientIds Client IDs for which blocks are to be returned.
 *
 * @return {WPBlock[]} Block objects.
 */
const getBlocksByClientId = (0,external_wp_data_namespaceObject.createSelector)((state, clientIds) =&gt; (Array.isArray(clientIds) ? clientIds : [clientIds]).map(clientId =&gt; getBlock(state, clientId)), (state, clientIds) =&gt; (Array.isArray(clientIds) ? clientIds : [clientIds]).map(clientId =&gt; state.blocks.tree.get(clientId)));

/**
 * Given an array of block client IDs, returns the corresponding array of block
 * names.
 *
 * @param {Object}   state     Editor state.
 * @param {string[]} clientIds Client IDs for which block names are to be returned.
 *
 * @return {string[]} Block names.
 */
const getBlockNamesByClientId = (0,external_wp_data_namespaceObject.createSelector)((state, clientIds) =&gt; getBlocksByClientId(state, clientIds).filter(Boolean).map(block =&gt; block.name), (state, clientIds) =&gt; getBlocksByClientId(state, clientIds));

/**
 * Returns the number of blocks currently present in the post.
 *
 * @param {Object}  state        Editor state.
 * @param {?string} rootClientId Optional root client ID of block list.
 *
 * @return {number} Number of blocks in the post.
 */
function getBlockCount(state, rootClientId) {
  return getBlockOrder(state, rootClientId).length;
}

/**
 * Returns the current selection start block client ID, attribute key and text
 * offset.
 *
 * @param {Object} state Block editor state.
 *
 * @return {WPBlockSelection} Selection start information.
 */
function getSelectionStart(state) {
  return state.selection.selectionStart;
}

/**
 * Returns the current selection end block client ID, attribute key and text
 * offset.
 *
 * @param {Object} state Block editor state.
 *
 * @return {WPBlockSelection} Selection end information.
 */
function getSelectionEnd(state) {
  return state.selection.selectionEnd;
}

/**
 * Returns the current block selection start. This value may be null, and it
 * may represent either a singular block selection or multi-selection start.
 * A selection is singular if its start and end match.
 *
 * @param {Object} state Global application state.
 *
 * @return {?string} Client ID of block selection start.
 */
function getBlockSelectionStart(state) {
  return state.selection.selectionStart.clientId;
}

/**
 * Returns the current block selection end. This value may be null, and it
 * may represent either a singular block selection or multi-selection end.
 * A selection is singular if its start and end match.
 *
 * @param {Object} state Global application state.
 *
 * @return {?string} Client ID of block selection end.
 */
function getBlockSelectionEnd(state) {
  return state.selection.selectionEnd.clientId;
}

/**
 * Returns the number of blocks currently selected in the post.
 *
 * @param {Object} state Global application state.
 *
 * @return {number} Number of blocks selected in the post.
 */
function getSelectedBlockCount(state) {
  const multiSelectedBlockCount = getMultiSelectedBlockClientIds(state).length;
  if (multiSelectedBlockCount) {
    return multiSelectedBlockCount;
  }
  return state.selection.selectionStart.clientId ? 1 : 0;
}

/**
 * Returns true if there is a single selected block, or false otherwise.
 *
 * @param {Object} state Editor state.
 *
 * @return {boolean} Whether a single block is selected.
 */
function hasSelectedBlock(state) {
  const {
    selectionStart,
    selectionEnd
  } = state.selection;
  return !!selectionStart.clientId &amp;&amp; selectionStart.clientId === selectionEnd.clientId;
}

/**
 * Returns the currently selected block client ID, or null if there is no
 * selected block.
 *
 * @param {Object} state Editor state.
 *
 * @return {?string} Selected block client ID.
 */
function getSelectedBlockClientId(state) {
  const {
    selectionStart,
    selectionEnd
  } = state.selection;
  const {
    clientId
  } = selectionStart;
  if (!clientId || clientId !== selectionEnd.clientId) {
    return null;
  }
  return clientId;
}

/**
 * Returns the currently selected block, or null if there is no selected block.
 *
 * @param {Object} state Global application state.
 *
 * @example
 *
 *```js
 * import { select } from &#039;@wordpress/data&#039;
 * import { store as blockEditorStore } from &#039;@wordpress/block-editor&#039;
 *
 * // Set initial active block client ID
 * let activeBlockClientId = null
 *
 * const getActiveBlockData = () =&gt; {
 * 	const activeBlock = select(blockEditorStore).getSelectedBlock()
 *
 * 	if (activeBlock &amp;&amp; activeBlock.clientId !== activeBlockClientId) {
 * 		activeBlockClientId = activeBlock.clientId
 *
 * 		// Get active block name and attributes
 * 		const activeBlockName = activeBlock.name
 * 		const activeBlockAttributes = activeBlock.attributes
 *
 * 		// Log active block name and attributes
 * 		console.log(activeBlockName, activeBlockAttributes)
 * 		}
 * 	}
 *
 * 	// Subscribe to changes in the editor
 * 	// wp.data.subscribe(() =&gt; {
 * 		// getActiveBlockData()
 * 	// })
 *
 * 	// Update active block data on click
 * 	// onclick=&quot;getActiveBlockData()&quot;
 *```
 *
 * @return {?Object} Selected block.
 */
function getSelectedBlock(state) {
  const clientId = getSelectedBlockClientId(state);
  return clientId ? getBlock(state, clientId) : null;
}

/**
 * Given a block client ID, returns the root block from which the block is
 * nested, an empty string for top-level blocks, or null if the block does not
 * exist.
 *
 * @param {Object} state    Editor state.
 * @param {string} clientId Block from which to find root client ID.
 *
 * @return {?string} Root client ID, if exists
 */
function getBlockRootClientId(state, clientId) {
  var _state$blocks$parents;
  return (_state$blocks$parents = state.blocks.parents.get(clientId)) !== null &amp;&amp; _state$blocks$parents !== void 0 ? _state$blocks$parents : null;
}

/**
 * Given a block client ID, returns the list of all its parents from top to bottom.
 *
 * @param {Object}  state     Editor state.
 * @param {string}  clientId  Block from which to find root client ID.
 * @param {boolean} ascending Order results from bottom to top (true) or top to bottom (false).
 *
 * @return {Array} ClientIDs of the parent blocks.
 */
const getBlockParents = (0,external_wp_data_namespaceObject.createSelector)((state, clientId, ascending = false) =&gt; {
  const parents = [];
  let current = clientId;
  while (current = state.blocks.parents.get(current)) {
    parents.push(current);
  }
  if (!parents.length) {
    return selectors_EMPTY_ARRAY;
  }
  return ascending ? parents : parents.reverse();
}, state =&gt; [state.blocks.parents]);

/**
 * Given a block client ID and a block name, returns the list of all its parents
 * from top to bottom, filtered by the given name(s). For example, if passed
 * &#039;core/group&#039; as the blockName, it will only return parents which are group
 * blocks. If passed `[ &#039;core/group&#039;, &#039;core/cover&#039;]`, as the blockName, it will
 * return parents which are group blocks and parents which are cover blocks.
 *
 * @param {Object}          state     Editor state.
 * @param {string}          clientId  Block from which to find root client ID.
 * @param {string|string[]} blockName Block name(s) to filter.
 * @param {boolean}         ascending Order results from bottom to top (true) or top to bottom (false).
 *
 * @return {Array} ClientIDs of the parent blocks.
 */
const getBlockParentsByBlockName = (0,external_wp_data_namespaceObject.createSelector)((state, clientId, blockName, ascending = false) =&gt; {
  const parents = getBlockParents(state, clientId, ascending);
  const hasName = Array.isArray(blockName) ? name =&gt; blockName.includes(name) : name =&gt; blockName === name;
  return parents.filter(id =&gt; hasName(getBlockName(state, id)));
}, state =&gt; [state.blocks.parents]);
/**
 * 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.
 *
 * @param {Object} state    Editor state.
 * @param {string} clientId Block from which to find root client ID.
 *
 * @return {string} Root client ID
 */
function getBlockHierarchyRootClientId(state, clientId) {
  let current = clientId;
  let parent;
  do {
    parent = current;
    current = state.blocks.parents.get(current);
  } while (current);
  return parent;
}

/**
 * Given a block client ID, returns the lowest common ancestor with selected client ID.
 *
 * @param {Object} state    Editor state.
 * @param {string} clientId Block from which to find common ancestor client ID.
 *
 * @return {string} Common ancestor client ID or undefined
 */
function getLowestCommonAncestorWithSelectedBlock(state, clientId) {
  const selectedId = getSelectedBlockClientId(state);
  const clientParents = [...getBlockParents(state, clientId), clientId];
  const selectedParents = [...getBlockParents(state, selectedId), selectedId];
  let lowestCommonAncestor;
  const maxDepth = Math.min(clientParents.length, selectedParents.length);
  for (let index = 0; index &lt; maxDepth; index++) {
    if (clientParents[index] === selectedParents[index]) {
      lowestCommonAncestor = clientParents[index];
    } else {
      break;
    }
  }
  return lowestCommonAncestor;
}

/**
 * Returns the client ID of the block adjacent one at the given reference
 * startClientId and modifier directionality. Defaults start startClientId to
 * the selected block, and direction as next block. Returns null if there is no
 * adjacent block.
 *
 * @param {Object}  state         Editor state.
 * @param {?string} startClientId Optional client ID of block from which to
 *                                search.
 * @param {?number} modifier      Directionality multiplier (1 next, -1
 *                                previous).
 *
 * @return {?string} Return the client ID of the block, or null if none exists.
 */
function getAdjacentBlockClientId(state, startClientId, modifier = 1) {
  // Default to selected block.
  if (startClientId === undefined) {
    startClientId = getSelectedBlockClientId(state);
  }

  // Try multi-selection starting at extent based on modifier.
  if (startClientId === undefined) {
    if (modifier &lt; 0) {
      startClientId = getFirstMultiSelectedBlockClientId(state);
    } else {
      startClientId = getLastMultiSelectedBlockClientId(state);
    }
  }

  // Validate working start client ID.
  if (!startClientId) {
    return null;
  }

  // Retrieve start block root client ID, being careful to allow the falsey
  // empty string top-level root by explicitly testing against null.
  const rootClientId = getBlockRootClientId(state, startClientId);
  if (rootClientId === null) {
    return null;
  }
  const {
    order
  } = state.blocks;
  const orderSet = order.get(rootClientId);
  const index = orderSet.indexOf(startClientId);
  const nextIndex = index + 1 * modifier;

  // Block was first in set and we&#039;re attempting to get previous.
  if (nextIndex &lt; 0) {
    return null;
  }

  // Block was last in set and we&#039;re attempting to get next.
  if (nextIndex === orderSet.length) {
    return null;
  }

  // Assume incremented index is within the set.
  return orderSet[nextIndex];
}

/**
 * Returns the previous block&#039;s client ID from the given reference start ID.
 * Defaults start to the selected block. Returns null if there is no previous
 * block.
 *
 * @param {Object}  state         Editor state.
 * @param {?string} startClientId Optional client ID of block from which to
 *                                search.
 *
 * @return {?string} Adjacent block&#039;s client ID, or null if none exists.
 */
function getPreviousBlockClientId(state, startClientId) {
  return getAdjacentBlockClientId(state, startClientId, -1);
}

/**
 * Returns the next block&#039;s client ID from the given reference start ID.
 * Defaults start to the selected block. Returns null if there is no next
 * block.
 *
 * @param {Object}  state         Editor state.
 * @param {?string} startClientId Optional client ID of block from which to
 *                                search.
 *
 * @return {?string} Adjacent block&#039;s client ID, or null if none exists.
 */
function getNextBlockClientId(state, startClientId) {
  return getAdjacentBlockClientId(state, startClientId, 1);
}

/* eslint-disable jsdoc/valid-types */
/**
 * Returns the initial caret position for the selected block.
 * This position is to used to position the caret properly when the selected block changes.
 * If the current block is not a RichText, having initial position set to 0 means &quot;focus block&quot;
 *
 * @param {Object} state Global application state.
 *
 * @return {0|-1|null} Initial position.
 */
function getSelectedBlocksInitialCaretPosition(state) {
  /* eslint-enable jsdoc/valid-types */
  return state.initialPosition;
}

/**
 * Returns the current selection set of block client IDs (multiselection or single selection).
 *
 * @param {Object} state Editor state.
 *
 * @return {Array} Multi-selected block client IDs.
 */
const getSelectedBlockClientIds = (0,external_wp_data_namespaceObject.createSelector)(state =&gt; {
  const {
    selectionStart,
    selectionEnd
  } = state.selection;
  if (!selectionStart.clientId || !selectionEnd.clientId) {
    return selectors_EMPTY_ARRAY;
  }
  if (selectionStart.clientId === selectionEnd.clientId) {
    return [selectionStart.clientId];
  }

  // Retrieve root client ID to aid in retrieving relevant nested block
  // order, being careful to allow the falsey empty string top-level root
  // by explicitly testing against null.
  const rootClientId = getBlockRootClientId(state, selectionStart.clientId);
  if (rootClientId === null) {
    return selectors_EMPTY_ARRAY;
  }
  const blockOrder = getBlockOrder(state, rootClientId);
  const startIndex = blockOrder.indexOf(selectionStart.clientId);
  const endIndex = blockOrder.indexOf(selectionEnd.clientId);
  if (startIndex &gt; endIndex) {
    return blockOrder.slice(endIndex, startIndex + 1);
  }
  return blockOrder.slice(startIndex, endIndex + 1);
}, state =&gt; [state.blocks.order, state.selection.selectionStart.clientId, state.selection.selectionEnd.clientId]);

/**
 * Returns the current multi-selection set of block client IDs, or an empty
 * array if there is no multi-selection.
 *
 * @param {Object} state Editor state.
 *
 * @return {Array} Multi-selected block client IDs.
 */
function getMultiSelectedBlockClientIds(state) {
  const {
    selectionStart,
    selectionEnd
  } = state.selection;
  if (selectionStart.clientId === selectionEnd.clientId) {
    return selectors_EMPTY_ARRAY;
  }
  return getSelectedBlockClientIds(state);
}

/**
 * Returns the current multi-selection set of blocks, or an empty array if
 * there is no multi-selection.
 *
 * @param {Object} state Editor state.
 *
 * @return {Array} Multi-selected block objects.
 */
const getMultiSelectedBlocks = (0,external_wp_data_namespaceObject.createSelector)(state =&gt; {
  const multiSelectedBlockClientIds = getMultiSelectedBlockClientIds(state);
  if (!multiSelectedBlockClientIds.length) {
    return selectors_EMPTY_ARRAY;
  }
  return multiSelectedBlockClientIds.map(clientId =&gt; getBlock(state, clientId));
}, state =&gt; [...getSelectedBlockClientIds.getDependants(state), state.blocks.byClientId, state.blocks.order, state.blocks.attributes]);

/**
 * Returns the client ID of the first block in the multi-selection set, or null
 * if there is no multi-selection.
 *
 * @param {Object} state Editor state.
 *
 * @return {?string} First block client ID in the multi-selection set.
 */
function getFirstMultiSelectedBlockClientId(state) {
  return getMultiSelectedBlockClientIds(state)[0] || null;
}

/**
 * Returns the client ID of the last block in the multi-selection set, or null
 * if there is no multi-selection.
 *
 * @param {Object} state Editor state.
 *
 * @return {?string} Last block client ID in the multi-selection set.
 */
function getLastMultiSelectedBlockClientId(state) {
  const selectedClientIds = getMultiSelectedBlockClientIds(state);
  return selectedClientIds[selectedClientIds.length - 1] || null;
}

/**
 * Returns true if a multi-selection exists, and the block corresponding to the
 * specified client ID is the first block of the multi-selection set, or false
 * otherwise.
 *
 * @param {Object} state    Editor state.
 * @param {string} clientId Block client ID.
 *
 * @return {boolean} Whether block is first in multi-selection.
 */
function isFirstMultiSelectedBlock(state, clientId) {
  return getFirstMultiSelectedBlockClientId(state) === clientId;
}

/**
 * Returns true if the client ID occurs within the block multi-selection, or
 * false otherwise.
 *
 * @param {Object} state    Editor state.
 * @param {string} clientId Block client ID.
 *
 * @return {boolean} Whether block is in multi-selection set.
 */
function isBlockMultiSelected(state, clientId) {
  return getMultiSelectedBlockClientIds(state).indexOf(clientId) !== -1;
}

/**
 * Returns true if an ancestor of the block is multi-selected, or false
 * otherwise.
 *
 * @param {Object} state    Editor state.
 * @param {string} clientId Block client ID.
 *
 * @return {boolean} Whether an ancestor of the block is in multi-selection
 *                   set.
 */
const isAncestorMultiSelected = (0,external_wp_data_namespaceObject.createSelector)((state, clientId) =&gt; {
  let ancestorClientId = clientId;
  let isMultiSelected = false;
  while (ancestorClientId &amp;&amp; !isMultiSelected) {
    ancestorClientId = getBlockRootClientId(state, ancestorClientId);
    isMultiSelected = isBlockMultiSelected(state, ancestorClientId);
  }
  return isMultiSelected;
}, state =&gt; [state.blocks.order, state.selection.selectionStart.clientId, state.selection.selectionEnd.clientId]);

/**
 * Returns the client ID of the block which begins the multi-selection set, or
 * null if there is no multi-selection.
 *
 * This is not necessarily the first client ID in the selection.
 *
 * @see getFirstMultiSelectedBlockClientId
 *
 * @param {Object} state Editor state.
 *
 * @return {?string} Client ID of block beginning multi-selection.
 */
function getMultiSelectedBlocksStartClientId(state) {
  const {
    selectionStart,
    selectionEnd
  } = state.selection;
  if (selectionStart.clientId === selectionEnd.clientId) {
    return null;
  }
  return selectionStart.clientId || null;
}

/**
 * Returns the client ID of the block which ends the multi-selection set, or
 * null if there is no multi-selection.
 *
 * This is not necessarily the last client ID in the selection.
 *
 * @see getLastMultiSelectedBlockClientId
 *
 * @param {Object} state Editor state.
 *
 * @return {?string} Client ID of block ending multi-selection.
 */
function getMultiSelectedBlocksEndClientId(state) {
  const {
    selectionStart,
    selectionEnd
  } = state.selection;
  if (selectionStart.clientId === selectionEnd.clientId) {
    return null;
  }
  return selectionEnd.clientId || null;
}

/**
 * Returns true if the selection is not partial.
 *
 * @param {Object} state Editor state.
 *
 * @return {boolean} Whether the selection is mergeable.
 */
function __unstableIsFullySelected(state) {
  const selectionAnchor = getSelectionStart(state);
  const selectionFocus = getSelectionEnd(state);
  return !selectionAnchor.attributeKey &amp;&amp; !selectionFocus.attributeKey &amp;&amp; typeof selectionAnchor.offset === &#039;undefined&#039; &amp;&amp; typeof selectionFocus.offset === &#039;undefined&#039;;
}

/**
 * Returns true if the selection is collapsed.
 *
 * @param {Object} state Editor state.
 *
 * @return {boolean} Whether the selection is collapsed.
 */
function __unstableIsSelectionCollapsed(state) {
  const selectionAnchor = getSelectionStart(state);
  const selectionFocus = getSelectionEnd(state);
  return !!selectionAnchor &amp;&amp; !!selectionFocus &amp;&amp; selectionAnchor.clientId === selectionFocus.clientId &amp;&amp; selectionAnchor.attributeKey === selectionFocus.attributeKey &amp;&amp; selectionAnchor.offset === selectionFocus.offset;
}
function __unstableSelectionHasUnmergeableBlock(state) {
  return getSelectedBlockClientIds(state).some(clientId =&gt; {
    const blockName = getBlockName(state, clientId);
    const blockType = (0,external_wp_blocks_namespaceObject.getBlockType)(blockName);
    return !blockType.merge;
  });
}

/**
 * Check whether the selection is mergeable.
 *
 * @param {Object}  state     Editor state.
 * @param {boolean} isForward Whether to merge forwards.
 *
 * @return {boolean} Whether the selection is mergeable.
 */
function __unstableIsSelectionMergeable(state, isForward) {
  const selectionAnchor = getSelectionStart(state);
  const selectionFocus = getSelectionEnd(state);

  // It&#039;s not mergeable if the start and end are within the same block.
  if (selectionAnchor.clientId === selectionFocus.clientId) {
    return false;
  }

  // It&#039;s not mergeable if there&#039;s no rich text selection.
  if (!selectionAnchor.attributeKey || !selectionFocus.attributeKey || typeof selectionAnchor.offset === &#039;undefined&#039; || typeof selectionFocus.offset === &#039;undefined&#039;) {
    return false;
  }
  const anchorRootClientId = getBlockRootClientId(state, selectionAnchor.clientId);
  const focusRootClientId = getBlockRootClientId(state, selectionFocus.clientId);

  // It&#039;s not mergeable if the selection doesn&#039;t start and end in the same
  // block list. Maybe in the future it should be allowed.
  if (anchorRootClientId !== focusRootClientId) {
    return false;
  }
  const blockOrder = getBlockOrder(state, anchorRootClientId);
  const anchorIndex = blockOrder.indexOf(selectionAnchor.clientId);
  const focusIndex = blockOrder.indexOf(selectionFocus.clientId);

  // Reassign selection start and end based on order.
  let selectionStart, selectionEnd;
  if (anchorIndex &gt; focusIndex) {
    selectionStart = selectionFocus;
    selectionEnd = selectionAnchor;
  } else {
    selectionStart = selectionAnchor;
    selectionEnd = selectionFocus;
  }
  const targetBlockClientId = isForward ? selectionEnd.clientId : selectionStart.clientId;
  const blockToMergeClientId = isForward ? selectionStart.clientId : selectionEnd.clientId;
  const targetBlockName = getBlockName(state, targetBlockClientId);
  const targetBlockType = (0,external_wp_blocks_namespaceObject.getBlockType)(targetBlockName);
  if (!targetBlockType.merge) {
    return false;
  }
  const blockToMerge = getBlock(state, blockToMergeClientId);

  // It&#039;s mergeable if the blocks are of the same type.
  if (blockToMerge.name === targetBlockName) {
    return true;
  }

  // If the blocks are of a different type, try to transform the block being
  // merged into the same type of block.
  const blocksToMerge = (0,external_wp_blocks_namespaceObject.switchToBlockType)(blockToMerge, targetBlockName);
  return blocksToMerge &amp;&amp; blocksToMerge.length;
}

/**
 * Get partial selected blocks with their content updated
 * based on the selection.
 *
 * @param {Object} state Editor state.
 *
 * @return {Object[]} Updated partial selected blocks.
 */
const __unstableGetSelectedBlocksWithPartialSelection = state =&gt; {
  const selectionAnchor = getSelectionStart(state);
  const selectionFocus = getSelectionEnd(state);
  if (selectionAnchor.clientId === selectionFocus.clientId) {
    return selectors_EMPTY_ARRAY;
  }

  // Can&#039;t split if the selection is not set.
  if (!selectionAnchor.attributeKey || !selectionFocus.attributeKey || typeof selectionAnchor.offset === &#039;undefined&#039; || typeof selectionFocus.offset === &#039;undefined&#039;) {
    return selectors_EMPTY_ARRAY;
  }
  const anchorRootClientId = getBlockRootClientId(state, selectionAnchor.clientId);
  const focusRootClientId = getBlockRootClientId(state, selectionFocus.clientId);

  // It&#039;s not splittable if the selection doesn&#039;t start and end in the same
  // block list. Maybe in the future it should be allowed.
  if (anchorRootClientId !== focusRootClientId) {
    return selectors_EMPTY_ARRAY;
  }
  const blockOrder = getBlockOrder(state, anchorRootClientId);
  const anchorIndex = blockOrder.indexOf(selectionAnchor.clientId);
  const focusIndex = blockOrder.indexOf(selectionFocus.clientId);

  // Reassign selection start and end based on order.
  const [selectionStart, selectionEnd] = anchorIndex &gt; focusIndex ? [selectionFocus, selectionAnchor] : [selectionAnchor, selectionFocus];
  const blockA = getBlock(state, selectionStart.clientId);
  const blockB = getBlock(state, selectionEnd.clientId);
  const htmlA = blockA.attributes[selectionStart.attributeKey];
  const htmlB = blockB.attributes[selectionEnd.attributeKey];
  let valueA = (0,external_wp_richText_namespaceObject.create)({
    html: htmlA
  });
  let valueB = (0,external_wp_richText_namespaceObject.create)({
    html: htmlB
  });
  valueA = (0,external_wp_richText_namespaceObject.remove)(valueA, 0, selectionStart.offset);
  valueB = (0,external_wp_richText_namespaceObject.remove)(valueB, selectionEnd.offset, valueB.text.length);
  return [{
    ...blockA,
    attributes: {
      ...blockA.attributes,
      [selectionStart.attributeKey]: (0,external_wp_richText_namespaceObject.toHTMLString)({
        value: valueA
      })
    }
  }, {
    ...blockB,
    attributes: {
      ...blockB.attributes,
      [selectionEnd.attributeKey]: (0,external_wp_richText_namespaceObject.toHTMLString)({
        value: valueB
      })
    }
  }];
};

/**
 * Returns an array containing all block client IDs in the editor in the order
 * they appear. Optionally accepts a root client ID of the block list for which
 * the order should be returned, defaulting to the top-level block order.
 *
 * @param {Object}  state        Editor state.
 * @param {?string} rootClientId Optional root client ID of block list.
 *
 * @return {Array} Ordered client IDs of editor blocks.
 */
function getBlockOrder(state, rootClientId) {
  return state.blocks.order.get(rootClientId || &#039;&#039;) || selectors_EMPTY_ARRAY;
}

/**
 * Returns the index at which the block corresponding to the specified client
 * ID occurs within the block order, or `-1` if the block does not exist.
 *
 * @param {Object} state    Editor state.
 * @param {string} clientId Block client ID.
 *
 * @return {number} Index at which block exists in order.
 */
function getBlockIndex(state, clientId) {
  const rootClientId = getBlockRootClientId(state, clientId);
  return getBlockOrder(state, rootClientId).indexOf(clientId);
}

/**
 * Returns true if the block corresponding to the specified client ID is
 * currently selected and no multi-selection exists, or false otherwise.
 *
 * @param {Object} state    Editor state.
 * @param {string} clientId Block client ID.
 *
 * @return {boolean} Whether block is selected and multi-selection exists.
 */
function isBlockSelected(state, clientId) {
  const {
    selectionStart,
    selectionEnd
  } = state.selection;
  if (selectionStart.clientId !== selectionEnd.clientId) {
    return false;
  }
  return selectionStart.clientId === clientId;
}

/**
 * Returns true if one of the block&#039;s inner blocks is selected.
 *
 * @param {Object}  state    Editor state.
 * @param {string}  clientId Block client ID.
 * @param {boolean} deep     Perform a deep check.
 *
 * @return {boolean} Whether the block has an inner block selected
 */
function hasSelectedInnerBlock(state, clientId, deep = false) {
  const selectedBlockClientIds = getSelectedBlockClientIds(state);
  if (!selectedBlockClientIds.length) {
    return false;
  }
  if (deep) {
    return selectedBlockClientIds.some(id =&gt;
    // Pass true because we don&#039;t care about order and it&#039;s more
    // performant.
    getBlockParents(state, id, true).includes(clientId));
  }
  return selectedBlockClientIds.some(id =&gt; getBlockRootClientId(state, id) === clientId);
}

/**
 * Returns true if one of the block&#039;s inner blocks is dragged.
 *
 * @param {Object}  state    Editor state.
 * @param {string}  clientId Block client ID.
 * @param {boolean} deep     Perform a deep check.
 *
 * @return {boolean} Whether the block has an inner block dragged
 */
function hasDraggedInnerBlock(state, clientId, deep = false) {
  return getBlockOrder(state, clientId).some(innerClientId =&gt; isBlockBeingDragged(state, innerClientId) || deep &amp;&amp; hasDraggedInnerBlock(state, innerClientId, deep));
}

/**
 * Returns true if the block corresponding to the specified client ID is
 * currently selected but isn&#039;t the last of the selected blocks. Here &quot;last&quot;
 * refers to the block sequence in the document, _not_ the sequence of
 * multi-selection, which is why `state.selectionEnd` isn&#039;t used.
 *
 * @param {Object} state    Editor state.
 * @param {string} clientId Block client ID.
 *
 * @return {boolean} Whether block is selected and not the last in the
 *                   selection.
 */
function isBlockWithinSelection(state, clientId) {
  if (!clientId) {
    return false;
  }
  const clientIds = getMultiSelectedBlockClientIds(state);
  const index = clientIds.indexOf(clientId);
  return index &gt; -1 &amp;&amp; index &lt; clientIds.length - 1;
}

/**
 * Returns true if a multi-selection has been made, or false otherwise.
 *
 * @param {Object} state Editor state.
 *
 * @return {boolean} Whether multi-selection has been made.
 */
function hasMultiSelection(state) {
  const {
    selectionStart,
    selectionEnd
  } = state.selection;
  return selectionStart.clientId !== selectionEnd.clientId;
}

/**
 * Whether in the process of multi-selecting or not. This flag is only true
 * while the multi-selection is being selected (by mouse move), and is false
 * once the multi-selection has been settled.
 *
 * @see hasMultiSelection
 *
 * @param {Object} state Global application state.
 *
 * @return {boolean} True if multi-selecting, false if not.
 */
function selectors_isMultiSelecting(state) {
  return state.isMultiSelecting;
}

/**
 * Selector that returns if multi-selection is enabled or not.
 *
 * @param {Object} state Global application state.
 *
 * @return {boolean} True if it should be possible to multi-select blocks, false if multi-selection is disabled.
 */
function selectors_isSelectionEnabled(state) {
  return state.isSelectionEnabled;
}

/**
 * Returns the block&#039;s editing mode, defaulting to &quot;visual&quot; if not explicitly
 * assigned.
 *
 * @param {Object} state    Editor state.
 * @param {string} clientId Block client ID.
 *
 * @return {Object} Block editing mode.
 */
function getBlockMode(state, clientId) {
  return state.blocksMode[clientId] || &#039;visual&#039;;
}

/**
 * Returns true if the user is typing, or false otherwise.
 *
 * @param {Object} state Global application state.
 *
 * @return {boolean} Whether user is typing.
 */
function selectors_isTyping(state) {
  return state.isTyping;
}

/**
 * Returns true if the user is dragging blocks, or false otherwise.
 *
 * @param {Object} state Global application state.
 *
 * @return {boolean} Whether user is dragging blocks.
 */
function isDraggingBlocks(state) {
  return !!state.draggedBlocks.length;
}

/**
 * Returns the client ids of any blocks being directly dragged.
 *
 * This does not include children of a parent being dragged.
 *
 * @param {Object} state Global application state.
 *
 * @return {string[]} Array of dragged block client ids.
 */
function getDraggedBlockClientIds(state) {
  return state.draggedBlocks;
}

/**
 * Returns whether the block is being dragged.
 *
 * Only returns true if the block is being directly dragged,
 * not if the block is a child of a parent being dragged.
 * See `isAncestorBeingDragged` for child blocks.
 *
 * @param {Object} state    Global application state.
 * @param {string} clientId Client id for block to check.
 *
 * @return {boolean} Whether the block is being dragged.
 */
function isBlockBeingDragged(state, clientId) {
  return state.draggedBlocks.includes(clientId);
}

/**
 * Returns whether a parent/ancestor of the block is being dragged.
 *
 * @param {Object} state    Global application state.
 * @param {string} clientId Client id for block to check.
 *
 * @return {boolean} Whether the block&#039;s ancestor is being dragged.
 */
function isAncestorBeingDragged(state, clientId) {
  // Return early if no blocks are being dragged rather than
  // the more expensive check for parents.
  if (!isDraggingBlocks(state)) {
    return false;
  }
  const parents = getBlockParents(state, clientId);
  return parents.some(parentClientId =&gt; isBlockBeingDragged(state, parentClientId));
}

/**
 * Returns true if the caret is within formatted text, or false otherwise.
 *
 * @deprecated
 *
 * @return {boolean} Whether the caret is within formatted text.
 */
function isCaretWithinFormattedText() {
  external_wp_deprecated_default()(&#039;wp.data.select( &quot;core/block-editor&quot; ).isCaretWithinFormattedText&#039;, {
    since: &#039;6.1&#039;,
    version: &#039;6.3&#039;
  });
  return false;
}

/**
 * Returns the location of the insertion cue. Defaults to the last index.
 *
 * @param {Object} state Editor state.
 *
 * @return {Object} Insertion point object with `rootClientId`, `index`.
 */
const getBlockInsertionPoint = (0,external_wp_data_namespaceObject.createSelector)(state =&gt; {
  let rootClientId, index;
  const {
    insertionCue,
    selection: {
      selectionEnd
    }
  } = state;
  if (insertionCue !== null) {
    return insertionCue;
  }
  const {
    clientId
  } = selectionEnd;
  if (clientId) {
    rootClientId = getBlockRootClientId(state, clientId) || undefined;
    index = getBlockIndex(state, selectionEnd.clientId) + 1;
  } else {
    index = getBlockOrder(state).length;
  }
  return {
    rootClientId,
    index
  };
}, state =&gt; [state.insertionCue, state.selection.selectionEnd.clientId, state.blocks.parents, state.blocks.order]);

/**
 * Returns true if the block insertion point is visible.
 *
 * @param {Object} state Global application state.
 *
 * @return {?boolean} Whether the insertion point is visible or not.
 */
function isBlockInsertionPointVisible(state) {
  return state.insertionCue !== null;
}

/**
 * Returns whether the blocks matches the template or not.
 *
 * @param {boolean} state
 * @return {?boolean} Whether the template is valid or not.
 */
function isValidTemplate(state) {
  return state.template.isValid;
}

/**
 * Returns the defined block template
 *
 * @param {boolean} state
 *
 * @return {?Array} Block Template.
 */
function getTemplate(state) {
  return state.settings.template;
}

/**
 * Returns the defined block template lock. Optionally accepts a root block
 * client ID as context, otherwise defaulting to the global context.
 *
 * @param {Object}  state        Editor state.
 * @param {?string} rootClientId Optional block root client ID.
 *
 * @return {string|false} Block Template Lock
 */
function getTemplateLock(state, rootClientId) {
  var _getBlockListSettings;
  if (!rootClientId) {
    var _state$settings$templ;
    return (_state$settings$templ = state.settings.templateLock) !== null &amp;&amp; _state$settings$templ !== void 0 ? _state$settings$templ : false;
  }
  return (_getBlockListSettings = getBlockListSettings(state, rootClientId)?.templateLock) !== null &amp;&amp; _getBlockListSettings !== void 0 ? _getBlockListSettings : false;
}

/**
 * Determines if the given block type is visible in the inserter.
 * Note that this is different than whether a block is allowed to be inserted.
 * In some cases, the block is not allowed in a given position but
 * it should still be visible in the inserter to be able to add it
 * to a different position.
 *
 * @param {Object}        state           Editor state.
 * @param {string|Object} blockNameOrType The block type object, e.g., the response
 *                                        from the block directory; or a string name of
 *                                        an installed block type, e.g.&#039; core/paragraph&#039;.
 * @param {?string}       rootClientId    Optional root client ID of block list.
 *
 * @return {boolean} Whether the given block type is allowed to be inserted.
 */
const isBlockVisibleInTheInserter = (state, blockNameOrType, rootClientId = null) =&gt; {
  let blockType;
  let blockName;
  if (blockNameOrType &amp;&amp; &#039;object&#039; === typeof blockNameOrType) {
    blockType = blockNameOrType;
    blockName = blockNameOrType.name;
  } else {
    blockType = (0,external_wp_blocks_namespaceObject.getBlockType)(blockNameOrType);
    blockName = blockNameOrType;
  }
  if (!blockType) {
    return false;
  }
  const {
    allowedBlockTypes
  } = getSettings(state);
  const isBlockAllowedInEditor = checkAllowList(allowedBlockTypes, blockName, true);
  if (!isBlockAllowedInEditor) {
    return false;
  }

  // If parent blocks are not visible, child blocks should be hidden too.
  const parents = (Array.isArray(blockType.parent) ? blockType.parent : []).concat(Array.isArray(blockType.ancestor) ? blockType.ancestor : []);
  if (parents.length &gt; 0) {
    // This is an exception to the rule that says that all blocks are visible in the inserter.
    // Blocks that require a given parent or ancestor are only visible if we&#039;re within that parent.
    if (parents.includes(&#039;core/post-content&#039;)) {
      return true;
    }
    let current = rootClientId;
    let hasParent = false;
    do {
      if (parents.includes(getBlockName(state, current))) {
        hasParent = true;
        break;
      }
      current = state.blocks.parents.get(current);
    } while (current);
    return hasParent;
  }
  return true;
};

/**
 * Determines if the given block type is allowed to be inserted into the block list.
 * This function is not exported and not memoized because using a memoized selector
 * inside another memoized selector is just a waste of time.
 *
 * @param {Object}        state        Editor state.
 * @param {string|Object} blockName    The block type object, e.g., the response
 *                                     from the block directory; or a string name of
 *                                     an installed block type, e.g.&#039; core/paragraph&#039;.
 * @param {?string}       rootClientId Optional root client ID of block list.
 *
 * @return {boolean} Whether the given block type is allowed to be inserted.
 */
const canInsertBlockTypeUnmemoized = (state, blockName, rootClientId = null) =&gt; {
  if (!isBlockVisibleInTheInserter(state, blockName, rootClientId)) {
    return false;
  }
  let blockType;
  if (blockName &amp;&amp; &#039;object&#039; === typeof blockName) {
    blockType = blockName;
    blockName = blockType.name;
  } else {
    blockType = (0,external_wp_blocks_namespaceObject.getBlockType)(blockName);
  }
  const isLocked = !!getTemplateLock(state, rootClientId);
  if (isLocked) {
    return false;
  }
  const _isSectionBlock = !!isSectionBlock(state, rootClientId);
  if (_isSectionBlock) {
    return false;
  }
  if (getBlockEditingMode(state, rootClientId !== null &amp;&amp; rootClientId !== void 0 ? rootClientId : &#039;&#039;) === &#039;disabled&#039;) {
    return false;
  }
  const parentBlockListSettings = getBlockListSettings(state, rootClientId);

  // The parent block doesn&#039;t have settings indicating it doesn&#039;t support
  // inner blocks, return false.
  if (rootClientId &amp;&amp; parentBlockListSettings === undefined) {
    return false;
  }
  const parentName = getBlockName(state, rootClientId);
  const parentBlockType = (0,external_wp_blocks_namespaceObject.getBlockType)(parentName);

  // Look at the `blockType.allowedBlocks` field to determine whether this is an allowed child block.
  const parentAllowedChildBlocks = parentBlockType?.allowedBlocks;
  let hasParentAllowedBlock = checkAllowList(parentAllowedChildBlocks, blockName);

  // The `allowedBlocks` block list setting can further limit which blocks are allowed children.
  if (hasParentAllowedBlock !== false) {
    const parentAllowedBlocks = parentBlockListSettings?.allowedBlocks;
    const hasParentListAllowedBlock = checkAllowList(parentAllowedBlocks, blockName);
    // Never downgrade the result from `true` to `null`
    if (hasParentListAllowedBlock !== null) {
      hasParentAllowedBlock = hasParentListAllowedBlock;
    }
  }
  const blockAllowedParentBlocks = blockType.parent;
  const hasBlockAllowedParent = checkAllowList(blockAllowedParentBlocks, parentName);
  let hasBlockAllowedAncestor = true;
  const blockAllowedAncestorBlocks = blockType.ancestor;
  if (blockAllowedAncestorBlocks) {
    const ancestors = [rootClientId, ...getBlockParents(state, rootClientId)];
    hasBlockAllowedAncestor = ancestors.some(ancestorClientId =&gt; checkAllowList(blockAllowedAncestorBlocks, getBlockName(state, ancestorClientId)));
  }
  const canInsert = hasBlockAllowedAncestor &amp;&amp; (hasParentAllowedBlock === null &amp;&amp; hasBlockAllowedParent === null || hasParentAllowedBlock === true || hasBlockAllowedParent === true);
  if (!canInsert) {
    return canInsert;
  }

  /**
   * This filter is an ad-hoc solution to prevent adding template parts inside post content.
   * Conceptually, having a filter inside a selector is bad pattern so this code will be
   * replaced by a declarative API that doesn&#039;t the following drawbacks:
   *
   * Filters are not reactive: Upon switching between &quot;template mode&quot; and non &quot;template mode&quot;,
   * the filter and selector won&#039;t necessarily be executed again. For now, it doesn&#039;t matter much
   * because you can&#039;t switch between the two modes while the inserter stays open.
   *
   * Filters are global: Once they&#039;re defined, they will affect all editor instances and all registries.
   * An ideal API would only affect specific editor instances.
   */
  return (0,external_wp_hooks_namespaceObject.applyFilters)(&#039;blockEditor.__unstableCanInsertBlockType&#039;, canInsert, blockType, rootClientId, {
    // Pass bound selectors of the current registry. If we&#039;re in a nested
    // context, the data will differ from the one selected from the root
    // registry.
    getBlock: getBlock.bind(null, state),
    getBlockParentsByBlockName: getBlockParentsByBlockName.bind(null, state)
  });
};

/**
 * Determines if the given block type is allowed to be inserted into the block list.
 *
 * @param {Object}  state        Editor state.
 * @param {string}  blockName    The name of the block type, e.g.&#039; core/paragraph&#039;.
 * @param {?string} rootClientId Optional root client ID of block list.
 *
 * @return {boolean} Whether the given block type is allowed to be inserted.
 */
const canInsertBlockType = (0,external_wp_data_namespaceObject.createRegistrySelector)(select =&gt; (0,external_wp_data_namespaceObject.createSelector)(canInsertBlockTypeUnmemoized, (state, blockName, rootClientId) =&gt; getInsertBlockTypeDependants(select)(state, rootClientId)));

/**
 * Determines if the given blocks are allowed to be inserted into the block
 * list.
 *
 * @param {Object}  state        Editor state.
 * @param {string}  clientIds    The block client IDs to be inserted.
 * @param {?string} rootClientId Optional root client ID of block list.
 *
 * @return {boolean} Whether the given blocks are allowed to be inserted.
 */
function canInsertBlocks(state, clientIds, rootClientId = null) {
  return clientIds.every(id =&gt; canInsertBlockType(state, getBlockName(state, id), rootClientId));
}

/**
 * Determines if the given block is allowed to be deleted.
 *
 * @param {Object} state    Editor state.
 * @param {string} clientId The block client Id.
 *
 * @return {boolean} Whether the given block is allowed to be removed.
 */
function canRemoveBlock(state, clientId) {
  const attributes = getBlockAttributes(state, clientId);
  if (attributes === null) {
    return true;
  }
  if (attributes.lock?.remove !== undefined) {
    return !attributes.lock.remove;
  }
  const rootClientId = getBlockRootClientId(state, clientId);
  if (getTemplateLock(state, rootClientId)) {
    return false;
  }
  const isBlockWithinSection = !!getParentSectionBlock(state, clientId);
  if (isBlockWithinSection) {
    return false;
  }
  return getBlockEditingMode(state, rootClientId) !== &#039;disabled&#039;;
}

/**
 * Determines if the given blocks are allowed to be removed.
 *
 * @param {Object} state     Editor state.
 * @param {string} clientIds The block client IDs to be removed.
 *
 * @return {boolean} Whether the given blocks are allowed to be removed.
 */
function canRemoveBlocks(state, clientIds) {
  return clientIds.every(clientId =&gt; canRemoveBlock(state, clientId));
}

/**
 * Determines if the given block is allowed to be moved.
 *
 * @param {Object} state    Editor state.
 * @param {string} clientId The block client Id.
 *
 * @return {boolean} Whether the given block is allowed to be moved.
 */
function canMoveBlock(state, clientId) {
  const attributes = getBlockAttributes(state, clientId);
  if (attributes === null) {
    return true;
  }
  if (attributes.lock?.move !== undefined) {
    return !attributes.lock.move;
  }
  const rootClientId = getBlockRootClientId(state, clientId);
  if (getTemplateLock(state, rootClientId) === &#039;all&#039;) {
    return false;
  }
  return getBlockEditingMode(state, rootClientId) !== &#039;disabled&#039;;
}

/**
 * Determines if the given blocks are allowed to be moved.
 *
 * @param {Object} state     Editor state.
 * @param {string} clientIds The block client IDs to be moved.
 *
 * @return {boolean} Whether the given blocks are allowed to be moved.
 */
function canMoveBlocks(state, clientIds) {
  return clientIds.every(clientId =&gt; canMoveBlock(state, clientId));
}

/**
 * Determines if the given block is allowed to be edited.
 *
 * @param {Object} state    Editor state.
 * @param {string} clientId The block client Id.
 *
 * @return {boolean} Whether the given block is allowed to be edited.
 */
function canEditBlock(state, clientId) {
  const attributes = getBlockAttributes(state, clientId);
  if (attributes === null) {
    return true;
  }
  const {
    lock
  } = attributes;

  // When the edit is true, we cannot edit the block.
  return !lock?.edit;
}

/**
 * Determines if the given block type can be locked/unlocked by a user.
 *
 * @param {Object}          state      Editor state.
 * @param {(string|Object)} nameOrType Block name or type object.
 *
 * @return {boolean} Whether a given block type can be locked/unlocked.
 */
function canLockBlockType(state, nameOrType) {
  if (!(0,external_wp_blocks_namespaceObject.hasBlockSupport)(nameOrType, &#039;lock&#039;, true)) {
    return false;
  }

  // Use block editor settings as the default value.
  return !!state.settings?.canLockBlocks;
}

/**
 * Returns information about how recently and frequently a block has been inserted.
 *
 * @param {Object} state Global application state.
 * @param {string} id    A string which identifies the insert, e.g. &#039;core/block/12&#039;
 *
 * @return {?{ time: number, count: number }} An object containing `time` which is when the last
 *                                            insert occurred as a UNIX epoch, and `count` which is
 *                                            the number of inserts that have occurred.
 */
function getInsertUsage(state, id) {
  var _state$preferences$in;
  return (_state$preferences$in = state.preferences.insertUsage?.[id]) !== null &amp;&amp; _state$preferences$in !== void 0 ? _state$preferences$in : null;
}

/**
 * Returns whether we can show a block type in the inserter
 *
 * @param {Object}  state        Global State
 * @param {Object}  blockType    BlockType
 * @param {?string} rootClientId Optional root client ID of block list.
 *
 * @return {boolean} Whether the given block type is allowed to be shown in the inserter.
 */
const canIncludeBlockTypeInInserter = (state, blockType, rootClientId) =&gt; {
  if (!(0,external_wp_blocks_namespaceObject.hasBlockSupport)(blockType, &#039;inserter&#039;, true)) {
    return false;
  }
  return canInsertBlockTypeUnmemoized(state, blockType.name, rootClientId);
};

/**
 * Return a function to be used to transform a block variation to an inserter item
 *
 * @param {Object} state Global State
 * @param {Object} item  Denormalized inserter item
 * @return {Function} Function to transform a block variation to inserter item
 */
const getItemFromVariation = (state, item) =&gt; variation =&gt; {
  const variationId = `${item.id}/${variation.name}`;
  const {
    time,
    count = 0
  } = getInsertUsage(state, variationId) || {};
  return {
    ...item,
    id: variationId,
    icon: variation.icon || item.icon,
    title: variation.title || item.title,
    description: variation.description || item.description,
    category: variation.category || item.category,
    // If `example` is explicitly undefined for the variation, the preview will not be shown.
    example: variation.hasOwnProperty(&#039;example&#039;) ? variation.example : item.example,
    initialAttributes: {
      ...item.initialAttributes,
      ...variation.attributes
    },
    innerBlocks: variation.innerBlocks,
    keywords: variation.keywords || item.keywords,
    frecency: calculateFrecency(time, count)
  };
};

/**
 * Returns the calculated frecency.
 *
 * &#039;frecency&#039; is a heuristic (https://en.wikipedia.org/wiki/Frecency)
 * that combines block usage frequency and recency.
 *
 * @param {number} time  When the last insert occurred as a UNIX epoch
 * @param {number} count The number of inserts that have occurred.
 *
 * @return {number} The calculated frecency.
 */
const calculateFrecency = (time, count) =&gt; {
  if (!time) {
    return count;
  }
  // The selector is cached, which means Date.now() is the last time that the
  // relevant state changed. This suits our needs.
  const duration = Date.now() - time;
  switch (true) {
    case duration &lt; MILLISECONDS_PER_HOUR:
      return count * 4;
    case duration &lt; MILLISECONDS_PER_DAY:
      return count * 2;
    case duration &lt; MILLISECONDS_PER_WEEK:
      return count / 2;
    default:
      return count / 4;
  }
};

/**
 * Returns a function that accepts a block type and builds an item to be shown
 * in a specific context. It&#039;s used for building items for Inserter and available
 * block Transforms list.
 *
 * @param {Object} state              Editor state.
 * @param {Object} options            Options object for handling the building of a block type.
 * @param {string} options.buildScope The scope for which the item is going to be used.
 * @return {Function} Function returns an item to be shown in a specific context (Inserter|Transforms list).
 */
const buildBlockTypeItem = (state, {
  buildScope = &#039;inserter&#039;
}) =&gt; blockType =&gt; {
  const id = blockType.name;
  let isDisabled = false;
  if (!(0,external_wp_blocks_namespaceObject.hasBlockSupport)(blockType.name, &#039;multiple&#039;, true)) {
    isDisabled = getBlocksByClientId(state, getClientIdsWithDescendants(state)).some(({
      name
    }) =&gt; name === blockType.name);
  }
  const {
    time,
    count = 0
  } = getInsertUsage(state, id) || {};
  const blockItemBase = {
    id,
    name: blockType.name,
    title: blockType.title,
    icon: blockType.icon,
    isDisabled,
    frecency: calculateFrecency(time, count)
  };
  if (buildScope === &#039;transform&#039;) {
    return blockItemBase;
  }
  const inserterVariations = (0,external_wp_blocks_namespaceObject.getBlockVariations)(blockType.name, &#039;inserter&#039;);
  return {
    ...blockItemBase,
    initialAttributes: {},
    description: blockType.description,
    category: blockType.category,
    keywords: blockType.keywords,
    parent: blockType.parent,
    ancestor: blockType.ancestor,
    variations: inserterVariations,
    example: blockType.example,
    utility: 1 // Deprecated.
  };
};

/**
 * Determines the items that appear in the inserter. Includes both static
 * items (e.g. a regular block type) and dynamic items (e.g. a reusable block).
 *
 * Each item object contains what&#039;s necessary to display a button in the
 * inserter and handle its selection.
 *
 * The &#039;frecency&#039; property is a heuristic (https://en.wikipedia.org/wiki/Frecency)
 * that combines block usage frequency and recency.
 *
 * Items are returned ordered descendingly by their &#039;utility&#039; and &#039;frecency&#039;.
 *
 * @param    {Object}   state             Editor state.
 * @param    {?string}  rootClientId      Optional root client ID of block list.
 *
 * @return {WPEditorInserterItem[]} Items that appear in inserter.
 *
 * @typedef {Object} WPEditorInserterItem
 * @property {string}   id                Unique identifier for the item.
 * @property {string}   name              The type of block to create.
 * @property {Object}   initialAttributes Attributes to pass to the newly created block.
 * @property {string}   title             Title of the item, as it appears in the inserter.
 * @property {string}   icon              Dashicon for the item, as it appears in the inserter.
 * @property {string}   category          Block category that the item is associated with.
 * @property {string[]} keywords          Keywords that can be searched to find this item.
 * @property {boolean}  isDisabled        Whether or not the user should be prevented from inserting
 *                                        this item.
 * @property {number}   frecency          Heuristic that combines frequency and recency.
 */
const getInserterItems = (0,external_wp_data_namespaceObject.createRegistrySelector)(select =&gt; (0,external_wp_data_namespaceObject.createSelector)((state, rootClientId = null, options = DEFAULT_INSERTER_OPTIONS) =&gt; {
  const buildReusableBlockInserterItem = reusableBlock =&gt; {
    const icon = !reusableBlock.wp_pattern_sync_status ? {
      src: library_symbol,
      foreground: &#039;var(--wp-block-synced-color)&#039;
    } : library_symbol;
    const id = `core/block/${reusableBlock.id}`;
    const {
      time,
      count = 0
    } = getInsertUsage(state, id) || {};
    const frecency = calculateFrecency(time, count);
    return {
      id,
      name: &#039;core/block&#039;,
      initialAttributes: {
        ref: reusableBlock.id
      },
      title: reusableBlock.title?.raw,
      icon,
      category: &#039;reusable&#039;,
      keywords: [&#039;reusable&#039;],
      isDisabled: false,
      utility: 1,
      // Deprecated.
      frecency,
      content: reusableBlock.content?.raw,
      syncStatus: reusableBlock.wp_pattern_sync_status
    };
  };
  const syncedPatternInserterItems = canInsertBlockTypeUnmemoized(state, &#039;core/block&#039;, rootClientId) ? unlock(select(STORE_NAME)).getReusableBlocks().map(buildReusableBlockInserterItem) : [];
  const buildBlockTypeInserterItem = buildBlockTypeItem(state, {
    buildScope: &#039;inserter&#039;
  });
  let blockTypeInserterItems = (0,external_wp_blocks_namespaceObject.getBlockTypes)().filter(blockType =&gt; (0,external_wp_blocks_namespaceObject.hasBlockSupport)(blockType, &#039;inserter&#039;, true)).map(buildBlockTypeInserterItem);
  if (options[isFiltered] !== false) {
    blockTypeInserterItems = blockTypeInserterItems.filter(blockType =&gt; canIncludeBlockTypeInInserter(state, blockType, rootClientId));
  } else {
    blockTypeInserterItems = blockTypeInserterItems.filter(blockType =&gt; isBlockVisibleInTheInserter(state, blockType, rootClientId)).map(blockType =&gt; ({
      ...blockType,
      isAllowedInCurrentRoot: canIncludeBlockTypeInInserter(state, blockType, rootClientId)
    }));
  }
  const items = blockTypeInserterItems.reduce((accumulator, item) =&gt; {
    const {
      variations = []
    } = item;
    // Exclude any block type item that is to be replaced by a default variation.
    if (!variations.some(({
      isDefault
    }) =&gt; isDefault)) {
      accumulator.push(item);
    }
    if (variations.length) {
      const variationMapper = getItemFromVariation(state, item);
      accumulator.push(...variations.map(variationMapper));
    }
    return accumulator;
  }, []);

  // Ensure core blocks are prioritized in the returned results,
  // because third party blocks can be registered earlier than
  // the core blocks (usually by using the `init` action),
  // thus affecting the display order.
  // We don&#039;t sort reusable blocks as they are handled differently.
  const groupByType = (blocks, block) =&gt; {
    const {
      core,
      noncore
    } = blocks;
    const type = block.name.startsWith(&#039;core/&#039;) ? core : noncore;
    type.push(block);
    return blocks;
  };
  const {
    core: coreItems,
    noncore: nonCoreItems
  } = items.reduce(groupByType, {
    core: [],
    noncore: []
  });
  const sortedBlockTypes = [...coreItems, ...nonCoreItems];
  return [...sortedBlockTypes, ...syncedPatternInserterItems];
}, (state, rootClientId) =&gt; [(0,external_wp_blocks_namespaceObject.getBlockTypes)(), unlock(select(STORE_NAME)).getReusableBlocks(), state.blocks.order, state.preferences.insertUsage, ...getInsertBlockTypeDependants(select)(state, rootClientId)]));

/**
 * Determines the items that appear in the available block transforms list.
 *
 * Each item object contains what&#039;s necessary to display a menu item in the
 * transform list and handle its selection.
 *
 * The &#039;frecency&#039; property is a heuristic (https://en.wikipedia.org/wiki/Frecency)
 * that combines block usage frequency and recency.
 *
 * Items are returned ordered descendingly by their &#039;frecency&#039;.
 *
 * @param    {Object}          state        Editor state.
 * @param    {Object|Object[]} blocks       Block object or array objects.
 * @param    {?string}         rootClientId Optional root client ID of block list.
 *
 * @return {WPEditorTransformItem[]} Items that appear in inserter.
 *
 * @typedef {Object} WPEditorTransformItem
 * @property {string}          id           Unique identifier for the item.
 * @property {string}          name         The type of block to create.
 * @property {string}          title        Title of the item, as it appears in the inserter.
 * @property {string}          icon         Dashicon for the item, as it appears in the inserter.
 * @property {boolean}         isDisabled   Whether or not the user should be prevented from inserting
 *                                          this item.
 * @property {number}          frecency     Heuristic that combines frequency and recency.
 */
const getBlockTransformItems = (0,external_wp_data_namespaceObject.createRegistrySelector)(select =&gt; (0,external_wp_data_namespaceObject.createSelector)((state, blocks, rootClientId = null) =&gt; {
  const normalizedBlocks = Array.isArray(blocks) ? blocks : [blocks];
  const buildBlockTypeTransformItem = buildBlockTypeItem(state, {
    buildScope: &#039;transform&#039;
  });
  const blockTypeTransformItems = (0,external_wp_blocks_namespaceObject.getBlockTypes)().filter(blockType =&gt; canIncludeBlockTypeInInserter(state, blockType, rootClientId)).map(buildBlockTypeTransformItem);
  const itemsByName = Object.fromEntries(Object.entries(blockTypeTransformItems).map(([, value]) =&gt; [value.name, value]));
  const possibleTransforms = (0,external_wp_blocks_namespaceObject.getPossibleBlockTransformations)(normalizedBlocks).reduce((accumulator, block) =&gt; {
    if (itemsByName[block?.name]) {
      accumulator.push(itemsByName[block.name]);
    }
    return accumulator;
  }, []);
  return orderBy(possibleTransforms, block =&gt; itemsByName[block.name].frecency, &#039;desc&#039;);
}, (state, blocks, rootClientId) =&gt; [(0,external_wp_blocks_namespaceObject.getBlockTypes)(), state.preferences.insertUsage, ...getInsertBlockTypeDependants(select)(state, rootClientId)]));

/**
 * Determines whether there are items to show in the inserter.
 *
 * @param {Object}  state        Editor state.
 * @param {?string} rootClientId Optional root client ID of block list.
 *
 * @return {boolean} Items that appear in inserter.
 */
const hasInserterItems = (0,external_wp_data_namespaceObject.createRegistrySelector)(select =&gt; (state, rootClientId = null) =&gt; {
  const hasBlockType = (0,external_wp_blocks_namespaceObject.getBlockTypes)().some(blockType =&gt; canIncludeBlockTypeInInserter(state, blockType, rootClientId));
  if (hasBlockType) {
    return true;
  }
  const hasReusableBlock = canInsertBlockTypeUnmemoized(state, &#039;core/block&#039;, rootClientId) &amp;&amp; unlock(select(STORE_NAME)).getReusableBlocks().length &gt; 0;
  return hasReusableBlock;
});

/**
 * Returns the list of allowed inserter blocks for inner blocks children.
 *
 * @param {Object}  state        Editor state.
 * @param {?string} rootClientId Optional root client ID of block list.
 *
 * @return {Array?} The list of allowed block types.
 */
const getAllowedBlocks = (0,external_wp_data_namespaceObject.createRegistrySelector)(select =&gt; (0,external_wp_data_namespaceObject.createSelector)((state, rootClientId = null) =&gt; {
  if (!rootClientId) {
    return;
  }
  const blockTypes = (0,external_wp_blocks_namespaceObject.getBlockTypes)().filter(blockType =&gt; canIncludeBlockTypeInInserter(state, blockType, rootClientId));
  const hasReusableBlock = canInsertBlockTypeUnmemoized(state, &#039;core/block&#039;, rootClientId) &amp;&amp; unlock(select(STORE_NAME)).getReusableBlocks().length &gt; 0;
  if (hasReusableBlock) {
    blockTypes.push(&#039;core/block&#039;);
  }
  return blockTypes;
}, (state, rootClientId) =&gt; [(0,external_wp_blocks_namespaceObject.getBlockTypes)(), unlock(select(STORE_NAME)).getReusableBlocks(), ...getInsertBlockTypeDependants(select)(state, rootClientId)]));
const __experimentalGetAllowedBlocks = (0,external_wp_data_namespaceObject.createSelector)((state, rootClientId = null) =&gt; {
  external_wp_deprecated_default()(&#039;wp.data.select( &quot;core/block-editor&quot; ).__experimentalGetAllowedBlocks&#039;, {
    alternative: &#039;wp.data.select( &quot;core/block-editor&quot; ).getAllowedBlocks&#039;,
    since: &#039;6.2&#039;,
    version: &#039;6.4&#039;
  });
  return getAllowedBlocks(state, rootClientId);
}, (state, rootClientId) =&gt; getAllowedBlocks.getDependants(state, rootClientId));

/**
 * Returns the block to be directly inserted by the block appender.
 *
 * @param    {Object}         state            Editor state.
 * @param    {?string}        rootClientId     Optional root client ID of block list.
 *
 * @return {WPDirectInsertBlock|undefined}              The block type to be directly inserted.
 *
 * @typedef {Object} WPDirectInsertBlock
 * @property {string}         name             The type of block.
 * @property {?Object}        attributes       Attributes to pass to the newly created block.
 * @property {?Array&lt;string&gt;} attributesToCopy Attributes to be copied from adjacent blocks when inserted.
 */
function getDirectInsertBlock(state, rootClientId = null) {
  var _state$blockListSetti;
  if (!rootClientId) {
    return;
  }
  const {
    defaultBlock,
    directInsert
  } = (_state$blockListSetti = state.blockListSettings[rootClientId]) !== null &amp;&amp; _state$blockListSetti !== void 0 ? _state$blockListSetti : {};
  if (!defaultBlock || !directInsert) {
    return;
  }
  return defaultBlock;
}
function __experimentalGetDirectInsertBlock(state, rootClientId = null) {
  external_wp_deprecated_default()(&#039;wp.data.select( &quot;core/block-editor&quot; ).__experimentalGetDirectInsertBlock&#039;, {
    alternative: &#039;wp.data.select( &quot;core/block-editor&quot; ).getDirectInsertBlock&#039;,
    since: &#039;6.3&#039;,
    version: &#039;6.4&#039;
  });
  return getDirectInsertBlock(state, rootClientId);
}
const __experimentalGetParsedPattern = (0,external_wp_data_namespaceObject.createRegistrySelector)(select =&gt; (state, patternName) =&gt; {
  const pattern = unlock(select(STORE_NAME)).getPatternBySlug(patternName);
  return pattern ? getParsedPattern(pattern) : null;
});
const getAllowedPatternsDependants = select =&gt; (state, rootClientId) =&gt; [...getAllPatternsDependants(select)(state), ...getInsertBlockTypeDependants(select)(state, rootClientId)];
const patternsWithParsedBlocks = new WeakMap();
function enhancePatternWithParsedBlocks(pattern) {
  let enhancedPattern = patternsWithParsedBlocks.get(pattern);
  if (!enhancedPattern) {
    enhancedPattern = {
      ...pattern,
      get blocks() {
        return getParsedPattern(pattern).blocks;
      }
    };
    patternsWithParsedBlocks.set(pattern, enhancedPattern);
  }
  return enhancedPattern;
}

/**
 * Returns the list of allowed patterns for inner blocks children.
 *
 * @param {Object}  state        Editor state.
 * @param {?string} rootClientId Optional target root client ID.
 *
 * @return {Array?} The list of allowed patterns.
 */
const __experimentalGetAllowedPatterns = (0,external_wp_data_namespaceObject.createRegistrySelector)(select =&gt; {
  return (0,external_wp_data_namespaceObject.createSelector)((state, rootClientId = null, options = DEFAULT_INSERTER_OPTIONS) =&gt; {
    const {
      getAllPatterns
    } = unlock(select(STORE_NAME));
    const patterns = getAllPatterns();
    const {
      allowedBlockTypes
    } = getSettings(state);
    const parsedPatterns = patterns.filter(({
      inserter = true
    }) =&gt; !!inserter).map(enhancePatternWithParsedBlocks);
    const availableParsedPatterns = parsedPatterns.filter(pattern =&gt; checkAllowListRecursive(getGrammar(pattern), allowedBlockTypes));
    const patternsAllowed = availableParsedPatterns.filter(pattern =&gt; getGrammar(pattern).every(({
      blockName: name
    }) =&gt; options[isFiltered] !== false ? canInsertBlockType(state, name, rootClientId) : isBlockVisibleInTheInserter(state, name, rootClientId)));
    return patternsAllowed;
  }, getAllowedPatternsDependants(select));
});

/**
 * Returns the list of patterns based on their declared `blockTypes`
 * and a block&#039;s name.
 * Patterns can use `blockTypes` to integrate in work flows like
 * suggesting appropriate patterns in a Placeholder state(during insertion)
 * or blocks transformations.
 *
 * @param {Object}          state        Editor state.
 * @param {string|string[]} blockNames   Block&#039;s name or array of block names to find matching patterns.
 * @param {?string}         rootClientId Optional target root client ID.
 *
 * @return {Array} The list of matched block patterns based on declared `blockTypes` and block name.
 */
const getPatternsByBlockTypes = (0,external_wp_data_namespaceObject.createRegistrySelector)(select =&gt; (0,external_wp_data_namespaceObject.createSelector)((state, blockNames, rootClientId = null) =&gt; {
  if (!blockNames) {
    return selectors_EMPTY_ARRAY;
  }
  const patterns = select(STORE_NAME).__experimentalGetAllowedPatterns(rootClientId);
  const normalizedBlockNames = Array.isArray(blockNames) ? blockNames : [blockNames];
  const filteredPatterns = patterns.filter(pattern =&gt; pattern?.blockTypes?.some?.(blockName =&gt; normalizedBlockNames.includes(blockName)));
  if (filteredPatterns.length === 0) {
    return selectors_EMPTY_ARRAY;
  }
  return filteredPatterns;
}, (state, blockNames, rootClientId) =&gt; getAllowedPatternsDependants(select)(state, rootClientId)));
const __experimentalGetPatternsByBlockTypes = (0,external_wp_data_namespaceObject.createRegistrySelector)(select =&gt; {
  external_wp_deprecated_default()(&#039;wp.data.select( &quot;core/block-editor&quot; ).__experimentalGetPatternsByBlockTypes&#039;, {
    alternative: &#039;wp.data.select( &quot;core/block-editor&quot; ).getPatternsByBlockTypes&#039;,
    since: &#039;6.2&#039;,
    version: &#039;6.4&#039;
  });
  return select(STORE_NAME).getPatternsByBlockTypes;
});

/**
 * Determines the items that appear in the available pattern transforms list.
 *
 * For now we only handle blocks without InnerBlocks and take into account
 * the `role` property of blocks&#039; attributes for the transformation.
 *
 * We return the first set of possible eligible block patterns,
 * by checking the `blockTypes` property. We still have to recurse through
 * block pattern&#039;s blocks and try to find matches from the selected blocks.
 * Now this happens in the consumer to avoid heavy operations in the selector.
 *
 * @param {Object}   state        Editor state.
 * @param {Object[]} blocks       The selected blocks.
 * @param {?string}  rootClientId Optional root client ID of block list.
 *
 * @return {WPBlockPattern[]} Items that are eligible for a pattern transformation.
 */
const __experimentalGetPatternTransformItems = (0,external_wp_data_namespaceObject.createRegistrySelector)(select =&gt; (0,external_wp_data_namespaceObject.createSelector)((state, blocks, rootClientId = null) =&gt; {
  if (!blocks) {
    return selectors_EMPTY_ARRAY;
  }
  /**
   * For now we only handle blocks without InnerBlocks and take into account
   * the `role` property of blocks&#039; attributes for the transformation.
   * Note that the blocks have been retrieved through `getBlock`, which doesn&#039;t
   * return the inner blocks of an inner block controller, so we still need
   * to check for this case too.
   */
  if (blocks.some(({
    clientId,
    innerBlocks
  }) =&gt; innerBlocks.length || areInnerBlocksControlled(state, clientId))) {
    return selectors_EMPTY_ARRAY;
  }

  // Create a Set of the selected block names that is used in patterns filtering.
  const selectedBlockNames = Array.from(new Set(blocks.map(({
    name
  }) =&gt; name)));
  /**
   * Here we will return first set of possible eligible block patterns,
   * by checking the `blockTypes` property. We still have to recurse through
   * block pattern&#039;s blocks and try to find matches from the selected blocks.
   * Now this happens in the consumer to avoid heavy operations in the selector.
   */
  return select(STORE_NAME).getPatternsByBlockTypes(selectedBlockNames, rootClientId);
}, (state, blocks, rootClientId) =&gt; getAllowedPatternsDependants(select)(state, rootClientId)));

/**
 * Returns the Block List settings of a block, if any exist.
 *
 * @param {Object}  state    Editor state.
 * @param {?string} clientId Block client ID.
 *
 * @return {?Object} Block settings of the block if set.
 */
function getBlockListSettings(state, clientId) {
  return state.blockListSettings[clientId];
}

/**
 * Returns the editor settings.
 *
 * @param {Object} state Editor state.
 *
 * @return {Object} The editor settings object.
 */
function getSettings(state) {
  return state.settings;
}

/**
 * Returns true if the most recent block change is be considered persistent, or
 * false otherwise. A persistent change is one committed by BlockEditorProvider
 * via its `onChange` callback, in addition to `onInput`.
 *
 * @param {Object} state Block editor state.
 *
 * @return {boolean} Whether the most recent block change was persistent.
 */
function isLastBlockChangePersistent(state) {
  return state.blocks.isPersistentChange;
}

/**
 * Returns the block list settings for an array of blocks, if any exist.
 *
 * @param {Object} state     Editor state.
 * @param {Array}  clientIds Block client IDs.
 *
 * @return {Object} An object where the keys are client ids and the values are
 *                  a block list setting object.
 */
const __experimentalGetBlockListSettingsForBlocks = (0,external_wp_data_namespaceObject.createSelector)((state, clientIds = []) =&gt; {
  return clientIds.reduce((blockListSettingsForBlocks, clientId) =&gt; {
    if (!state.blockListSettings[clientId]) {
      return blockListSettingsForBlocks;
    }
    return {
      ...blockListSettingsForBlocks,
      [clientId]: state.blockListSettings[clientId]
    };
  }, {});
}, state =&gt; [state.blockListSettings]);

/**
 * Returns the title of a given reusable block
 *
 * @param {Object}        state Global application state.
 * @param {number|string} ref   The shared block&#039;s ID.
 *
 * @return {string} The reusable block saved title.
 */
const __experimentalGetReusableBlockTitle = (0,external_wp_data_namespaceObject.createRegistrySelector)(select =&gt; (0,external_wp_data_namespaceObject.createSelector)((state, ref) =&gt; {
  external_wp_deprecated_default()(&quot;wp.data.select( &#039;core/block-editor&#039; ).__experimentalGetReusableBlockTitle&quot;, {
    since: &#039;6.6&#039;,
    version: &#039;6.8&#039;
  });
  const reusableBlock = unlock(select(STORE_NAME)).getReusableBlocks().find(block =&gt; block.id === ref);
  if (!reusableBlock) {
    return null;
  }
  return reusableBlock.title?.raw;
}, () =&gt; [unlock(select(STORE_NAME)).getReusableBlocks()]));

/**
 * Returns true if the most recent block change is be considered ignored, or
 * false otherwise. An ignored change is one not to be committed by
 * BlockEditorProvider, neither via `onChange` nor `onInput`.
 *
 * @param {Object} state Block editor state.
 *
 * @return {boolean} Whether the most recent block change was ignored.
 */
function __unstableIsLastBlockChangeIgnored(state) {
  // TODO: Removal Plan: Changes incurred by RECEIVE_BLOCKS should not be
  // ignored if in-fact they result in a change in blocks state. The current
  // need to ignore changes not a result of user interaction should be
  // accounted for in the refactoring of reusable blocks as occurring within
  // their own separate block editor / state (#7119).
  return state.blocks.isIgnoredChange;
}

/**
 * Returns the block attributes changed as a result of the last dispatched
 * action.
 *
 * @param {Object} state Block editor state.
 *
 * @return {Object&lt;string,Object&gt;} Subsets of block attributes changed, keyed
 *                                 by block client ID.
 */
function __experimentalGetLastBlockAttributeChanges(state) {
  return state.lastBlockAttributesChange;
}

/**
 * Returns whether the navigation mode is enabled.
 *
 * @param {Object} state Editor state.
 *
 * @return {boolean} Is navigation mode enabled.
 */
function isNavigationMode(state) {
  return __unstableGetEditorMode(state) === &#039;navigation&#039;;
}

/**
 * Returns the current editor mode.
 *
 * @param {Object} state Editor state.
 *
 * @return {string} the editor mode.
 */
const __unstableGetEditorMode = (0,external_wp_data_namespaceObject.createRegistrySelector)(select =&gt; state =&gt; {
  var _state$settings$edito;
  if (!window?.__experimentalEditorWriteMode) {
    return &#039;edit&#039;;
  }
  return (_state$settings$edito = state.settings.editorTool) !== null &amp;&amp; _state$settings$edito !== void 0 ? _state$settings$edito : select(external_wp_preferences_namespaceObject.store).get(&#039;core&#039;, &#039;editorTool&#039;);
});

/**
 * Returns whether block moving mode is enabled.
 *
 * @deprecated
 */
function hasBlockMovingClientId() {
  external_wp_deprecated_default()(&#039;wp.data.select( &quot;core/block-editor&quot; ).hasBlockMovingClientId&#039;, {
    since: &#039;6.7&#039;,
    hint: &#039;Block moving mode feature has been removed&#039;
  });
  return false;
}

/**
 * Returns true if the last change was an automatic change, false otherwise.
 *
 * @param {Object} state Global application state.
 *
 * @return {boolean} Whether the last change was automatic.
 */
function didAutomaticChange(state) {
  return !!state.automaticChangeStatus;
}

/**
 * Returns true if the current highlighted block matches the block clientId.
 *
 * @param {Object} state    Global application state.
 * @param {string} clientId The block to check.
 *
 * @return {boolean} Whether the block is currently highlighted.
 */
function isBlockHighlighted(state, clientId) {
  return state.highlightedBlock === clientId;
}

/**
 * Checks if a given block has controlled inner blocks.
 *
 * @param {Object} state    Global application state.
 * @param {string} clientId The block to check.
 *
 * @return {boolean} True if the block has controlled inner blocks.
 */
function areInnerBlocksControlled(state, clientId) {
  return !!state.blocks.controlledInnerBlocks[clientId];
}

/**
 * Returns the clientId for the first &#039;active&#039; block of a given array of block names.
 * A block is &#039;active&#039; if it (or a child) is the selected block.
 * Returns the first match moving up the DOM from the selected block.
 *
 * @param {Object}   state            Global application state.
 * @param {string[]} validBlocksNames The names of block types to check for.
 *
 * @return {string} The matching block&#039;s clientId.
 */
const __experimentalGetActiveBlockIdByBlockNames = (0,external_wp_data_namespaceObject.createSelector)((state, validBlockNames) =&gt; {
  if (!validBlockNames.length) {
    return null;
  }
  // Check if selected block is a valid entity area.
  const selectedBlockClientId = getSelectedBlockClientId(state);
  if (validBlockNames.includes(getBlockName(state, selectedBlockClientId))) {
    return selectedBlockClientId;
  }
  // Check if first selected block is a child of a valid entity area.
  const multiSelectedBlockClientIds = getMultiSelectedBlockClientIds(state);
  const entityAreaParents = getBlockParentsByBlockName(state, selectedBlockClientId || multiSelectedBlockClientIds[0], validBlockNames);
  if (entityAreaParents) {
    // Last parent closest/most interior.
    return entityAreaParents[entityAreaParents.length - 1];
  }
  return null;
}, (state, validBlockNames) =&gt; [state.selection.selectionStart.clientId, state.selection.selectionEnd.clientId, validBlockNames]);

/**
 * Tells if the block with the passed clientId was just inserted.
 *
 * @param {Object}  state    Global application state.
 * @param {Object}  clientId Client Id of the block.
 * @param {?string} source   Optional insertion source of the block.
 * @return {boolean} True if the block matches the last block inserted from the specified source.
 */
function wasBlockJustInserted(state, clientId, source) {
  const {
    lastBlockInserted
  } = state;
  return lastBlockInserted.clientIds?.includes(clientId) &amp;&amp; lastBlockInserted.source === source;
}

/**
 * Tells if the block is visible on the canvas or not.
 *
 * @param {Object} state    Global application state.
 * @param {Object} clientId Client Id of the block.
 * @return {boolean} True if the block is visible.
 */
function isBlockVisible(state, clientId) {
  var _state$blockVisibilit;
  return (_state$blockVisibilit = state.blockVisibility?.[clientId]) !== null &amp;&amp; _state$blockVisibilit !== void 0 ? _state$blockVisibilit : true;
}

/**
 * Returns the currently hovered block.
 *
 * @param {Object} state Global application state.
 * @return {Object} Client Id of the hovered block.
 */
function getHoveredBlockClientId(state) {
  return state.hoveredBlockClientId;
}

/**
 * Returns the list of all hidden blocks.
 *
 * @param {Object} state Global application state.
 * @return {[string]} List of hidden blocks.
 */
const __unstableGetVisibleBlocks = (0,external_wp_data_namespaceObject.createSelector)(state =&gt; {
  const visibleBlocks = new Set(Object.keys(state.blockVisibility).filter(key =&gt; state.blockVisibility[key]));
  if (visibleBlocks.size === 0) {
    return EMPTY_SET;
  }
  return visibleBlocks;
}, state =&gt; [state.blockVisibility]);
function __unstableHasActiveBlockOverlayActive(state, clientId) {
  // Prevent overlay on blocks with a non-default editing mode. If the mode is
  // &#039;disabled&#039; then the overlay is redundant since the block can&#039;t be
  // selected. If the mode is &#039;contentOnly&#039; then the overlay is redundant
  // since there will be no controls to interact with once selected.
  if (getBlockEditingMode(state, clientId) !== &#039;default&#039;) {
    return false;
  }

  // If the block editing is locked, the block overlay is always active.
  if (!canEditBlock(state, clientId)) {
    return true;
  }

  // In zoom-out mode, the block overlay is always active for section level blocks.
  if (isZoomOut(state)) {
    const sectionRootClientId = getSectionRootClientId(state);
    if (sectionRootClientId) {
      const sectionClientIds = getBlockOrder(state, sectionRootClientId);
      if (sectionClientIds?.includes(clientId)) {
        return true;
      }
    } else if (clientId &amp;&amp; !getBlockRootClientId(state, clientId)) {
      return true;
    }
  }

  // In navigation mode, the block overlay is active when the block is not
  // selected (and doesn&#039;t contain a selected child). The same behavior is
  // also enabled in all modes for blocks that have controlled children
  // (reusable block, template part, navigation), unless explicitly disabled
  // with `supports.__experimentalDisableBlockOverlay`.
  const blockSupportDisable = (0,external_wp_blocks_namespaceObject.hasBlockSupport)(getBlockName(state, clientId), &#039;__experimentalDisableBlockOverlay&#039;, false);
  const shouldEnableIfUnselected = blockSupportDisable ? false : areInnerBlocksControlled(state, clientId);
  return shouldEnableIfUnselected &amp;&amp; !isBlockSelected(state, clientId) &amp;&amp; !hasSelectedInnerBlock(state, clientId, true);
}
function __unstableIsWithinBlockOverlay(state, clientId) {
  let parent = state.blocks.parents.get(clientId);
  while (!!parent) {
    if (__unstableHasActiveBlockOverlayActive(state, parent)) {
      return true;
    }
    parent = state.blocks.parents.get(parent);
  }
  return false;
}

/**
 * @typedef {import(&#039;../components/block-editing-mode&#039;).BlockEditingMode} BlockEditingMode
 */

/**
 * Returns the block editing mode for a given block.
 *
 * The mode can be one of three options:
 *
 * - `&#039;disabled&#039;`: Prevents editing the block entirely, i.e. it cannot be
 *   selected.
 * - `&#039;contentOnly&#039;`: Hides all non-content UI, e.g. auxiliary controls in the
 *   toolbar, the block movers, block settings.
 * - `&#039;default&#039;`: Allows editing the block as normal.
 *
 * Blocks can set a mode using the `useBlockEditingMode` hook.
 *
 * The mode is inherited by all of the block&#039;s inner blocks, unless they have
 * their own mode.
 *
 * A template lock can also set a mode. If the template lock is `&#039;contentOnly&#039;`,
 * the block&#039;s mode is overridden to `&#039;contentOnly&#039;` if the block has a content
 * role attribute, or `&#039;disabled&#039;` otherwise.
 *
 * @see useBlockEditingMode
 *
 * @param {Object} state    Global application state.
 * @param {string} clientId The block client ID, or `&#039;&#039;` for the root container.
 *
 * @return {BlockEditingMode} The block editing mode. One of `&#039;disabled&#039;`,
 *                            `&#039;contentOnly&#039;`, or `&#039;default&#039;`.
 */
const getBlockEditingMode = (0,external_wp_data_namespaceObject.createRegistrySelector)(select =&gt; (state, clientId = &#039;&#039;) =&gt; {
  // Some selectors that call this provide `null` as the default
  // rootClientId, but the default rootClientId is actually `&#039;&#039;`.
  if (clientId === null) {
    clientId = &#039;&#039;;
  }
  const isNavMode = isNavigationMode(state);

  // If the editor is currently not in navigation mode, check if the clientId
  // has an editing mode set in the regular derived map.
  // There may be an editing mode set here for synced patterns or in zoomed out
  // mode.
  if (!isNavMode &amp;&amp; state.derivedBlockEditingModes?.has(clientId)) {
    return state.derivedBlockEditingModes.get(clientId);
  }

  // If the editor *is* in navigation mode, the block editing mode states
  // are stored in the derivedNavModeBlockEditingModes map.
  if (isNavMode &amp;&amp; state.derivedNavModeBlockEditingModes?.has(clientId)) {
    return state.derivedNavModeBlockEditingModes.get(clientId);
  }

  // In normal mode, consider that an explicitly set editing mode takes over.
  const blockEditingMode = state.blockEditingModes.get(clientId);
  if (blockEditingMode) {
    return blockEditingMode;
  }

  // In normal mode, top level is default mode.
  if (clientId === &#039;&#039;) {
    return &#039;default&#039;;
  }
  const rootClientId = getBlockRootClientId(state, clientId);
  const templateLock = getTemplateLock(state, rootClientId);
  // If the parent of the block is contentOnly locked, check whether it&#039;s a content block.
  if (templateLock === &#039;contentOnly&#039;) {
    const name = getBlockName(state, clientId);
    const {
      hasContentRoleAttribute
    } = unlock(select(external_wp_blocks_namespaceObject.store));
    const isContent = hasContentRoleAttribute(name);
    return isContent ? &#039;contentOnly&#039; : &#039;disabled&#039;;
  }
  return &#039;default&#039;;
});

/**
 * Indicates if a block is ungroupable.
 * A block is ungroupable if it is a single grouping block with inner blocks.
 * If a block has an `ungroup` transform, it is also ungroupable, without the
 * requirement of being the default grouping block.
 * Additionally a block can only be ungrouped if it has inner blocks and can
 * be removed.
 *
 * @param {Object} state    Global application state.
 * @param {string} clientId Client Id of the block. If not passed the selected block&#039;s client id will be used.
 * @return {boolean} True if the block is ungroupable.
 */
const isUngroupable = (0,external_wp_data_namespaceObject.createRegistrySelector)(select =&gt; (state, clientId = &#039;&#039;) =&gt; {
  const _clientId = clientId || getSelectedBlockClientId(state);
  if (!_clientId) {
    return false;
  }
  const {
    getGroupingBlockName
  } = select(external_wp_blocks_namespaceObject.store);
  const block = getBlock(state, _clientId);
  const groupingBlockName = getGroupingBlockName();
  const _isUngroupable = block &amp;&amp; (block.name === groupingBlockName || (0,external_wp_blocks_namespaceObject.getBlockType)(block.name)?.transforms?.ungroup) &amp;&amp; !!block.innerBlocks.length;
  return _isUngroupable &amp;&amp; canRemoveBlock(state, _clientId);
});

/**
 * Indicates if the provided blocks(by client ids) are groupable.
 * We need to have at least one block, have a grouping block name set and
 * be able to remove these blocks.
 *
 * @param {Object}   state     Global application state.
 * @param {string[]} clientIds Block client ids. If not passed the selected blocks client ids will be used.
 * @return {boolean} True if the blocks are groupable.
 */
const isGroupable = (0,external_wp_data_namespaceObject.createRegistrySelector)(select =&gt; (state, clientIds = selectors_EMPTY_ARRAY) =&gt; {
  const {
    getGroupingBlockName
  } = select(external_wp_blocks_namespaceObject.store);
  const groupingBlockName = getGroupingBlockName();
  const _clientIds = clientIds?.length ? clientIds : getSelectedBlockClientIds(state);
  const rootClientId = _clientIds?.length ? getBlockRootClientId(state, _clientIds[0]) : undefined;
  const groupingBlockAvailable = canInsertBlockType(state, groupingBlockName, rootClientId);
  const _isGroupable = groupingBlockAvailable &amp;&amp; _clientIds.length;
  return _isGroupable &amp;&amp; canRemoveBlocks(state, _clientIds);
});

/**
 * DO-NOT-USE in production.
 * This selector is created for internal/experimental only usage and may be
 * removed anytime without any warning, causing breakage on any plugin or theme invoking it.
 *
 * @deprecated
 *
 * @param {Object} state    Global application state.
 * @param {Object} clientId Client Id of the block.
 *
 * @return {?string} Client ID of the ancestor block that is content locking the block.
 */
const __unstableGetContentLockingParent = (state, clientId) =&gt; {
  external_wp_deprecated_default()(&quot;wp.data.select( &#039;core/block-editor&#039; ).__unstableGetContentLockingParent&quot;, {
    since: &#039;6.1&#039;,
    version: &#039;6.7&#039;
  });
  return getContentLockingParent(state, clientId);
};

/**
 * DO-NOT-USE in production.
 * This selector is created for internal/experimental only usage and may be
 * removed anytime without any warning, causing breakage on any plugin or theme invoking it.
 *
 * @deprecated
 *
 * @param {Object} state Global application state.
 */
function __unstableGetTemporarilyEditingAsBlocks(state) {
  external_wp_deprecated_default()(&quot;wp.data.select( &#039;core/block-editor&#039; ).__unstableGetTemporarilyEditingAsBlocks&quot;, {
    since: &#039;6.1&#039;,
    version: &#039;6.7&#039;
  });
  return getTemporarilyEditingAsBlocks(state);
}

/**
 * DO-NOT-USE in production.
 * This selector is created for internal/experimental only usage and may be
 * removed anytime without any warning, causing breakage on any plugin or theme invoking it.
 *
 * @deprecated
 *
 * @param {Object} state Global application state.
 */
function __unstableGetTemporarilyEditingFocusModeToRevert(state) {
  external_wp_deprecated_default()(&quot;wp.data.select( &#039;core/block-editor&#039; ).__unstableGetTemporarilyEditingFocusModeToRevert&quot;, {
    since: &#039;6.5&#039;,
    version: &#039;6.7&#039;
  });
  return getTemporarilyEditingFocusModeToRevert(state);
}

;// external [&quot;wp&quot;,&quot;a11y&quot;]
const external_wp_a11y_namespaceObject = window[&quot;wp&quot;][&quot;a11y&quot;];
;// ./node_modules/@wordpress/block-editor/build-module/store/private-actions.js
/**
 * WordPress dependencies
 */





/**
 * Internal dependencies
 */


const castArray = maybeArray =&gt; Array.isArray(maybeArray) ? maybeArray : [maybeArray];

/**
 * A list of private/experimental block editor settings that
 * should not become a part of the WordPress public API.
 * BlockEditorProvider will remove these settings from the
 * settings object it receives.
 *
 * @see https://github.com/WordPress/gutenberg/pull/46131
 */
const privateSettings = [&#039;inserterMediaCategories&#039;, &#039;blockInspectorAnimation&#039;, &#039;mediaSideload&#039;];

/**
 * Action that updates the block editor settings and
 * conditionally preserves the experimental ones.
 *
 * @param {Object}  settings                          Updated settings
 * @param {Object}  options                           Options object.
 * @param {boolean} options.stripExperimentalSettings Whether to strip experimental settings.
 * @param {boolean} options.reset                     Whether to reset the settings.
 * @return {Object} Action object
 */
function __experimentalUpdateSettings(settings, {
  stripExperimentalSettings = false,
  reset = false
} = {}) {
  let incomingSettings = settings;
  if (Object.hasOwn(incomingSettings, &#039;__unstableIsPreviewMode&#039;)) {
    external_wp_deprecated_default()(&quot;__unstableIsPreviewMode argument in wp.data.dispatch(&#039;core/block-editor&#039;).updateSettings&quot;, {
      since: &#039;6.8&#039;,
      alternative: &#039;isPreviewMode&#039;
    });
    incomingSettings = {
      ...incomingSettings
    };
    incomingSettings.isPreviewMode = incomingSettings.__unstableIsPreviewMode;
    delete incomingSettings.__unstableIsPreviewMode;
  }
  let cleanSettings = incomingSettings;

  // There are no plugins in the mobile apps, so there is no
  // need to strip the experimental settings:
  if (stripExperimentalSettings &amp;&amp; external_wp_element_namespaceObject.Platform.OS === &#039;web&#039;) {
    cleanSettings = {};
    for (const key in incomingSettings) {
      if (!privateSettings.includes(key)) {
        cleanSettings[key] = incomingSettings[key];
      }
    }
  }
  return {
    type: &#039;UPDATE_SETTINGS&#039;,
    settings: cleanSettings,
    reset
  };
}

/**
 * Hides the block interface (eg. toolbar, outline, etc.)
 *
 * @return {Object} Action object.
 */
function hideBlockInterface() {
  return {
    type: &#039;HIDE_BLOCK_INTERFACE&#039;
  };
}

/**
 * Shows the block interface (eg. toolbar, outline, etc.)
 *
 * @return {Object} Action object.
 */
function showBlockInterface() {
  return {
    type: &#039;SHOW_BLOCK_INTERFACE&#039;
  };
}

/**
 * Yields action objects used in signalling that the blocks corresponding to
 * the set of specified client IDs are to be removed.
 *
 * Compared to `removeBlocks`, this private interface exposes an additional
 * parameter; see `forceRemove`.
 *
 * @param {string|string[]} clientIds      Client IDs of blocks to remove.
 * @param {boolean}         selectPrevious True if the previous block
 *                                         or the immediate parent
 *                                         (if no previous block exists)
 *                                         should be selected
 *                                         when a block is removed.
 * @param {boolean}         forceRemove    Whether to force the operation,
 *                                         bypassing any checks for certain
 *                                         block types.
 */
const privateRemoveBlocks = (clientIds, selectPrevious = true, forceRemove = false) =&gt; ({
  select,
  dispatch,
  registry
}) =&gt; {
  if (!clientIds || !clientIds.length) {
    return;
  }
  clientIds = castArray(clientIds);
  const canRemoveBlocks = select.canRemoveBlocks(clientIds);
  if (!canRemoveBlocks) {
    return;
  }

  // In certain editing contexts, we&#039;d like to prevent accidental removal
  // of important blocks. For example, in the site editor, the Query Loop
  // block is deemed important. In such cases, we&#039;ll ask the user for
  // confirmation that they intended to remove such block(s). However,
  // the editor instance is responsible for presenting those confirmation
  // prompts to the user. Any instance opting into removal prompts must
  // register using `setBlockRemovalRules()`.
  //
  // @see https://github.com/WordPress/gutenberg/pull/51145
  const rules = !forceRemove &amp;&amp; select.getBlockRemovalRules();
  if (rules) {
    function flattenBlocks(blocks) {
      const result = [];
      const stack = [...blocks];
      while (stack.length) {
        const {
          innerBlocks,
          ...block
        } = stack.shift();
        stack.push(...innerBlocks);
        result.push(block);
      }
      return result;
    }
    const blockList = clientIds.map(select.getBlock);
    const flattenedBlocks = flattenBlocks(blockList);

    // Find the first message and use it.
    let message;
    for (const rule of rules) {
      message = rule.callback(flattenedBlocks);
      if (message) {
        dispatch(displayBlockRemovalPrompt(clientIds, selectPrevious, message));
        return;
      }
    }
  }
  if (selectPrevious) {
    dispatch.selectPreviousBlock(clientIds[0], selectPrevious);
  }

  // We&#039;re batching these two actions because an extra `undo/redo` step can
  // be created, based on whether we insert a default block or not.
  registry.batch(() =&gt; {
    dispatch({
      type: &#039;REMOVE_BLOCKS&#039;,
      clientIds
    });
    // To avoid a focus loss when removing the last block, assure there is
    // always a default block if the last of the blocks have been removed.
    dispatch(ensureDefaultBlock());
  });
};

/**
 * Action which will insert a default block insert action if there
 * are no other blocks at the root of the editor. This action should be used
 * in actions which may result in no blocks remaining in the editor (removal,
 * replacement, etc).
 */
const ensureDefaultBlock = () =&gt; ({
  select,
  dispatch
}) =&gt; {
  // To avoid a focus loss when removing the last block, assure there is
  // always a default block if the last of the blocks have been removed.
  const count = select.getBlockCount();
  if (count &gt; 0) {
    return;
  }

  // If there&#039;s an custom appender, don&#039;t insert default block.
  // We have to remember to manually move the focus elsewhere to
  // prevent it from being lost though.
  const {
    __unstableHasCustomAppender
  } = select.getSettings();
  if (__unstableHasCustomAppender) {
    return;
  }
  dispatch.insertDefaultBlock();
};

/**
 * Returns an action object used in signalling that a block removal prompt must
 * be displayed.
 *
 * Contrast with `setBlockRemovalRules`.
 *
 * @param {string|string[]} clientIds      Client IDs of blocks to remove.
 * @param {boolean}         selectPrevious True if the previous block or the
 *                                         immediate parent (if no previous
 *                                         block exists) should be selected
 *                                         when a block is removed.
 * @param {string}          message        Message to display in the prompt.
 *
 * @return {Object} Action object.
 */
function displayBlockRemovalPrompt(clientIds, selectPrevious, message) {
  return {
    type: &#039;DISPLAY_BLOCK_REMOVAL_PROMPT&#039;,
    clientIds,
    selectPrevious,
    message
  };
}

/**
 * Returns an action object used in signalling that a block removal prompt must
 * be cleared, either be cause the user has confirmed or canceled the request
 * for removal.
 *
 * @return {Object} Action object.
 */
function clearBlockRemovalPrompt() {
  return {
    type: &#039;CLEAR_BLOCK_REMOVAL_PROMPT&#039;
  };
}

/**
 * Returns an action object used to set up any rules that a block editor may
 * provide in order to prevent a user from accidentally removing certain
 * blocks. These rules are then used to display a confirmation prompt to the
 * user. For instance, in the Site Editor, the Query Loop block is important
 * enough to warrant such confirmation.
 *
 * IMPORTANT: Registering rules implicitly signals to the `privateRemoveBlocks`
 * action that the editor will be responsible for displaying block removal
 * prompts and confirming deletions. This action is meant to be used by
 * component `BlockRemovalWarningModal` only.
 *
 * The data is a record whose keys are block types (e.g. &#039;core/query&#039;) and
 * whose values are the explanation to be shown to users (e.g. &#039;Query Loop
 * displays a list of posts or pages.&#039;).
 *
 * Contrast with `displayBlockRemovalPrompt`.
 *
 * @param {Record&lt;string,string&gt;|false} rules Block removal rules.
 * @return {Object} Action object.
 */
function setBlockRemovalRules(rules = false) {
  return {
    type: &#039;SET_BLOCK_REMOVAL_RULES&#039;,
    rules
  };
}

/**
 * Sets the client ID of the block settings menu that is currently open.
 *
 * @param {?string} clientId The block client ID.
 * @return {Object} Action object.
 */
function setOpenedBlockSettingsMenu(clientId) {
  return {
    type: &#039;SET_OPENED_BLOCK_SETTINGS_MENU&#039;,
    clientId
  };
}
function setStyleOverride(id, style) {
  return {
    type: &#039;SET_STYLE_OVERRIDE&#039;,
    id,
    style
  };
}
function deleteStyleOverride(id) {
  return {
    type: &#039;DELETE_STYLE_OVERRIDE&#039;,
    id
  };
}

/**
 * Action that sets the element that had focus when focus leaves the editor canvas.
 *
 * @param {Object} lastFocus The last focused element.
 *
 *
 * @return {Object} Action object.
 */
function setLastFocus(lastFocus = null) {
  return {
    type: &#039;LAST_FOCUS&#039;,
    lastFocus
  };
}

/**
 * Action that stops temporarily editing as blocks.
 *
 * @param {string} clientId The block&#039;s clientId.
 */
function stopEditingAsBlocks(clientId) {
  return ({
    select,
    dispatch,
    registry
  }) =&gt; {
    const focusModeToRevert = unlock(registry.select(store)).getTemporarilyEditingFocusModeToRevert();
    dispatch.__unstableMarkNextChangeAsNotPersistent();
    dispatch.updateBlockAttributes(clientId, {
      templateLock: &#039;contentOnly&#039;
    });
    dispatch.updateBlockListSettings(clientId, {
      ...select.getBlockListSettings(clientId),
      templateLock: &#039;contentOnly&#039;
    });
    dispatch.updateSettings({
      focusMode: focusModeToRevert
    });
    dispatch.__unstableSetTemporarilyEditingAsBlocks();
  };
}

/**
 * Returns an action object used in signalling that the user has begun to drag.
 *
 * @return {Object} Action object.
 */
function startDragging() {
  return {
    type: &#039;START_DRAGGING&#039;
  };
}

/**
 * Returns an action object used in signalling that the user has stopped dragging.
 *
 * @return {Object} Action object.
 */
function stopDragging() {
  return {
    type: &#039;STOP_DRAGGING&#039;
  };
}

/**
 * @param {string|null} clientId The block&#039;s clientId, or `null` to clear.
 *
 * @return  {Object} Action object.
 */
function expandBlock(clientId) {
  return {
    type: &#039;SET_BLOCK_EXPANDED_IN_LIST_VIEW&#039;,
    clientId
  };
}

/**
 * @param {Object} value
 * @param {string} value.rootClientId The root client ID to insert at.
 * @param {number} value.index        The index to insert at.
 *
 * @return {Object} Action object.
 */
function setInsertionPoint(value) {
  return {
    type: &#039;SET_INSERTION_POINT&#039;,
    value
  };
}

/**
 * Temporarily modify/unlock the content-only block for editions.
 *
 * @param {string} clientId The client id of the block.
 */
const modifyContentLockBlock = clientId =&gt; ({
  select,
  dispatch
}) =&gt; {
  dispatch.selectBlock(clientId);
  dispatch.__unstableMarkNextChangeAsNotPersistent();
  dispatch.updateBlockAttributes(clientId, {
    templateLock: undefined
  });
  dispatch.updateBlockListSettings(clientId, {
    ...select.getBlockListSettings(clientId),
    templateLock: false
  });
  const focusModeToRevert = select.getSettings().focusMode;
  dispatch.updateSettings({
    focusMode: true
  });
  dispatch.__unstableSetTemporarilyEditingAsBlocks(clientId, focusModeToRevert);
};

/**
 * Sets the zoom level.
 *
 * @param {number} zoom the new zoom level
 * @return {Object} Action object.
 */
const setZoomLevel = (zoom = 100) =&gt; ({
  select,
  dispatch
}) =&gt; {
  // When switching to zoom-out mode, we need to select the parent section
  if (zoom !== 100) {
    const firstSelectedClientId = select.getBlockSelectionStart();
    const sectionRootClientId = select.getSectionRootClientId();
    if (firstSelectedClientId) {
      let sectionClientId;
      if (sectionRootClientId) {
        const sectionClientIds = select.getBlockOrder(sectionRootClientId);

        // If the selected block is a section block, use it.
        if (sectionClientIds?.includes(firstSelectedClientId)) {
          sectionClientId = firstSelectedClientId;
        } else {
          // If the selected block is not a section block, find
          // the parent section that contains the selected block.
          sectionClientId = select.getBlockParents(firstSelectedClientId).find(parent =&gt; sectionClientIds.includes(parent));
        }
      } else {
        sectionClientId = select.getBlockHierarchyRootClientId(firstSelectedClientId);
      }
      if (sectionClientId) {
        dispatch.selectBlock(sectionClientId);
      } else {
        dispatch.clearSelectedBlock();
      }
      (0,external_wp_a11y_namespaceObject.speak)((0,external_wp_i18n_namespaceObject.__)(&#039;You are currently in zoom-out mode.&#039;));
    }
  }
  dispatch({
    type: &#039;SET_ZOOM_LEVEL&#039;,
    zoom
  });
};

/**
 * Resets the Zoom state.
 * @return {Object} Action object.
 */
function resetZoomLevel() {
  return {
    type: &#039;RESET_ZOOM_LEVEL&#039;
  };
}

;// external [&quot;wp&quot;,&quot;notices&quot;]
const external_wp_notices_namespaceObject = window[&quot;wp&quot;][&quot;notices&quot;];
;// ./node_modules/@wordpress/block-editor/build-module/utils/selection.js
/**
 * WordPress dependencies
 */


/**
 * A robust way to retain selection position through various
 * transforms is to insert a special character at the position and
 * then recover it.
 */
const START_OF_SELECTED_AREA = &#039;\u0086&#039;;

/**
 * Retrieve the block attribute that contains the selection position.
 *
 * @param {Object} blockAttributes Block attributes.
 * @return {string|void} The name of the block attribute that was previously selected.
 */
function retrieveSelectedAttribute(blockAttributes) {
  if (!blockAttributes) {
    return;
  }
  return Object.keys(blockAttributes).find(name =&gt; {
    const value = blockAttributes[name];
    return (typeof value === &#039;string&#039; || value instanceof external_wp_richText_namespaceObject.RichTextData) &amp;&amp;
    // To do: refactor this to use rich text&#039;s selection instead, so we
    // no longer have to use on this hack inserting a special character.
    value.toString().indexOf(START_OF_SELECTED_AREA) !== -1;
  });
}
function findRichTextAttributeKey(blockType) {
  for (const [key, value] of Object.entries(blockType.attributes)) {
    if (value.source === &#039;rich-text&#039; || value.source === &#039;html&#039;) {
      return key;
    }
  }
}

;// ./node_modules/@wordpress/block-editor/build-module/store/actions.js
/* eslint no-console: [ &#039;error&#039;, { allow: [ &#039;error&#039;, &#039;warn&#039; ] } ] */
/**
 * WordPress dependencies
 */








/**
 * Internal dependencies
 */



/** @typedef {import(&#039;../components/use-on-block-drop/types&#039;).WPDropOperation} WPDropOperation */

const actions_castArray = maybeArray =&gt; Array.isArray(maybeArray) ? maybeArray : [maybeArray];

/**
 * Action that resets blocks state to the specified array of blocks, taking precedence
 * over any other content reflected as an edit in state.
 *
 * @param {Array} blocks Array of blocks.
 */
const resetBlocks = blocks =&gt; ({
  dispatch
}) =&gt; {
  dispatch({
    type: &#039;RESET_BLOCKS&#039;,
    blocks
  });
  dispatch(validateBlocksToTemplate(blocks));
};

/**
 * Block validity is a function of blocks state (at the point of a
 * reset) and the template setting. As a compromise to its placement
 * across distinct parts of state, it is implemented here as a side
 * effect of the block reset action.
 *
 * @param {Array} blocks Array of blocks.
 */
const validateBlocksToTemplate = blocks =&gt; ({
  select,
  dispatch
}) =&gt; {
  const template = select.getTemplate();
  const templateLock = select.getTemplateLock();

  // Unlocked templates are considered always valid because they act
  // as default values only.
  const isBlocksValidToTemplate = !template || templateLock !== &#039;all&#039; || (0,external_wp_blocks_namespaceObject.doBlocksMatchTemplate)(blocks, template);

  // Update if validity has changed.
  const isValidTemplate = select.isValidTemplate();
  if (isBlocksValidToTemplate !== isValidTemplate) {
    dispatch.setTemplateValidity(isBlocksValidToTemplate);
    return isBlocksValidToTemplate;
  }
};

/**
 * A block selection object.
 *
 * @typedef {Object} WPBlockSelection
 *
 * @property {string} clientId     A block client ID.
 * @property {string} attributeKey A block attribute key.
 * @property {number} offset       An attribute value offset, based on the rich
 *                                 text value. See `wp.richText.create`.
 */

/**
 * A selection object.
 *
 * @typedef {Object} WPSelection
 *
 * @property {WPBlockSelection} start The selection start.
 * @property {WPBlockSelection} end   The selection end.
 */

/* eslint-disable jsdoc/valid-types */
/**
 * Returns an action object used in signalling that selection state should be
 * reset to the specified selection.
 *
 * @param {WPBlockSelection} selectionStart  The selection start.
 * @param {WPBlockSelection} selectionEnd    The selection end.
 * @param {0|-1|null}        initialPosition Initial block position.
 *
 * @return {Object} Action object.
 */
function resetSelection(selectionStart, selectionEnd, initialPosition) {
  /* eslint-enable jsdoc/valid-types */
  return {
    type: &#039;RESET_SELECTION&#039;,
    selectionStart,
    selectionEnd,
    initialPosition
  };
}

/**
 * Returns an action object used in signalling that blocks have been received.
 * Unlike resetBlocks, these should be appended to the existing known set, not
 * replacing.
 *
 * @deprecated
 *
 * @param {Object[]} blocks Array of block objects.
 *
 * @return {Object} Action object.
 */
function receiveBlocks(blocks) {
  external_wp_deprecated_default()(&#039;wp.data.dispatch( &quot;core/block-editor&quot; ).receiveBlocks&#039;, {
    since: &#039;5.9&#039;,
    alternative: &#039;resetBlocks or insertBlocks&#039;
  });
  return {
    type: &#039;RECEIVE_BLOCKS&#039;,
    blocks
  };
}

/**
 * Action that updates attributes of multiple blocks with the specified client IDs.
 *
 * @param {string|string[]} clientIds     Block client IDs.
 * @param {Object}          attributes    Block attributes to be merged. Should be keyed by clientIds if
 *                                        uniqueByBlock is true.
 * @param {boolean}         uniqueByBlock true if each block in clientIds array has a unique set of attributes
 * @return {Object} Action object.
 */
function updateBlockAttributes(clientIds, attributes, uniqueByBlock = false) {
  return {
    type: &#039;UPDATE_BLOCK_ATTRIBUTES&#039;,
    clientIds: actions_castArray(clientIds),
    attributes,
    uniqueByBlock
  };
}

/**
 * Action that updates the block with the specified client ID.
 *
 * @param {string} clientId Block client ID.
 * @param {Object} updates  Block attributes to be merged.
 *
 * @return {Object} Action object.
 */
function updateBlock(clientId, updates) {
  return {
    type: &#039;UPDATE_BLOCK&#039;,
    clientId,
    updates
  };
}

/* eslint-disable jsdoc/valid-types */
/**
 * Returns an action object used in signalling that the block with the
 * specified client ID has been selected, optionally accepting a position
 * value reflecting its selection directionality. An initialPosition of -1
 * reflects a reverse selection.
 *
 * @param {string}    clientId        Block client ID.
 * @param {0|-1|null} initialPosition Optional initial position. Pass as -1 to
 *                                    reflect reverse selection.
 *
 * @return {Object} Action object.
 */
function selectBlock(clientId, initialPosition = 0) {
  /* eslint-enable jsdoc/valid-types */
  return {
    type: &#039;SELECT_BLOCK&#039;,
    initialPosition,
    clientId
  };
}

/**
 * Returns an action object used in signalling that the block with the
 * specified client ID has been hovered.
 *
 * @param {string} clientId Block client ID.
 *
 * @return {Object} Action object.
 */
function hoverBlock(clientId) {
  return {
    type: &#039;HOVER_BLOCK&#039;,
    clientId
  };
}

/**
 * Yields action objects used in signalling that the block preceding the given
 * clientId (or optionally, its first parent from bottom to top)
 * should be selected.
 *
 * @param {string}  clientId         Block client ID.
 * @param {boolean} fallbackToParent If true, select the first parent if there is no previous block.
 */
const selectPreviousBlock = (clientId, fallbackToParent = false) =&gt; ({
  select,
  dispatch
}) =&gt; {
  const previousBlockClientId = select.getPreviousBlockClientId(clientId);
  if (previousBlockClientId) {
    dispatch.selectBlock(previousBlockClientId, -1);
  } else if (fallbackToParent) {
    const firstParentClientId = select.getBlockRootClientId(clientId);
    if (firstParentClientId) {
      dispatch.selectBlock(firstParentClientId, -1);
    }
  }
};

/**
 * Yields action objects used in signalling that the block following the given
 * clientId should be selected.
 *
 * @param {string} clientId Block client ID.
 */
const selectNextBlock = clientId =&gt; ({
  select,
  dispatch
}) =&gt; {
  const nextBlockClientId = select.getNextBlockClientId(clientId);
  if (nextBlockClientId) {
    dispatch.selectBlock(nextBlockClientId);
  }
};

/**
 * Action that starts block multi-selection.
 *
 * @return {Object} Action object.
 */
function startMultiSelect() {
  return {
    type: &#039;START_MULTI_SELECT&#039;
  };
}

/**
 * Action that stops block multi-selection.
 *
 * @return {Object} Action object.
 */
function stopMultiSelect() {
  return {
    type: &#039;STOP_MULTI_SELECT&#039;
  };
}

/**
 * Action that changes block multi-selection.
 *
 * @param {string}      start                         First block of the multi selection.
 * @param {string}      end                           Last block of the multiselection.
 * @param {number|null} __experimentalInitialPosition Optional initial position. Pass as null to skip focus within editor canvas.
 */
const multiSelect = (start, end, __experimentalInitialPosition = 0) =&gt; ({
  select,
  dispatch
}) =&gt; {
  const startBlockRootClientId = select.getBlockRootClientId(start);
  const endBlockRootClientId = select.getBlockRootClientId(end);

  // Only allow block multi-selections at the same level.
  if (startBlockRootClientId !== endBlockRootClientId) {
    return;
  }
  dispatch({
    type: &#039;MULTI_SELECT&#039;,
    start,
    end,
    initialPosition: __experimentalInitialPosition
  });
  const blockCount = select.getSelectedBlockCount();
  (0,external_wp_a11y_namespaceObject.speak)((0,external_wp_i18n_namespaceObject.sprintf)(/* translators: %s: number of selected blocks */
  (0,external_wp_i18n_namespaceObject._n)(&#039;%s block selected.&#039;, &#039;%s blocks selected.&#039;, blockCount), blockCount), &#039;assertive&#039;);
};

/**
 * Action that clears the block selection.
 *
 * @return {Object} Action object.
 */
function clearSelectedBlock() {
  return {
    type: &#039;CLEAR_SELECTED_BLOCK&#039;
  };
}

/**
 * Action that enables or disables block selection.
 *
 * @param {boolean} [isSelectionEnabled=true] Whether block selection should
 *                                            be enabled.
 *
 * @return {Object} Action object.
 */
function toggleSelection(isSelectionEnabled = true) {
  return {
    type: &#039;TOGGLE_SELECTION&#039;,
    isSelectionEnabled
  };
}

/* eslint-disable jsdoc/valid-types */
/**
 * Action that replaces given blocks with one or more replacement blocks.
 *
 * @param {(string|string[])} clientIds       Block client ID(s) to replace.
 * @param {(Object|Object[])} blocks          Replacement block(s).
 * @param {number}            indexToSelect   Index of replacement block to select.
 * @param {0|-1|null}         initialPosition Index of caret after in the selected block after the operation.
 * @param {?Object}           meta            Optional Meta values to be passed to the action object.
 *
 * @return {Object} Action object.
 */
const replaceBlocks = (clientIds, blocks, indexToSelect, initialPosition = 0, meta) =&gt; ({
  select,
  dispatch,
  registry
}) =&gt; {
  /* eslint-enable jsdoc/valid-types */
  clientIds = actions_castArray(clientIds);
  blocks = actions_castArray(blocks);
  const rootClientId = select.getBlockRootClientId(clientIds[0]);
  // Replace is valid if the new blocks can be inserted in the root block.
  for (let index = 0; index &lt; blocks.length; index++) {
    const block = blocks[index];
    const canInsertBlock = select.canInsertBlockType(block.name, rootClientId);
    if (!canInsertBlock) {
      return;
    }
  }
  // We&#039;re batching these two actions because an extra `undo/redo` step can
  // be created, based on whether we insert a default block or not.
  registry.batch(() =&gt; {
    dispatch({
      type: &#039;REPLACE_BLOCKS&#039;,
      clientIds,
      blocks,
      time: Date.now(),
      indexToSelect,
      initialPosition,
      meta
    });
    // To avoid a focus loss when removing the last block, assure there is
    // always a default block if the last of the blocks have been removed.
    dispatch.ensureDefaultBlock();
  });
};

/**
 * Action that replaces a single block with one or more replacement blocks.
 *
 * @param {(string|string[])} clientId Block client ID to replace.
 * @param {(Object|Object[])} block    Replacement block(s).
 *
 * @return {Object} Action object.
 */
function replaceBlock(clientId, block) {
  return replaceBlocks(clientId, block);
}

/**
 * Higher-order action creator which, given the action type to dispatch creates
 * an action creator for managing block movement.
 *
 * @param {string} type Action type to dispatch.
 *
 * @return {Function} Action creator.
 */
const createOnMove = type =&gt; (clientIds, rootClientId) =&gt; ({
  select,
  dispatch
}) =&gt; {
  // If one of the blocks is locked or the parent is locked, we cannot move any block.
  const canMoveBlocks = select.canMoveBlocks(clientIds);
  if (!canMoveBlocks) {
    return;
  }
  dispatch({
    type,
    clientIds: actions_castArray(clientIds),
    rootClientId
  });
};
const moveBlocksDown = createOnMove(&#039;MOVE_BLOCKS_DOWN&#039;);
const moveBlocksUp = createOnMove(&#039;MOVE_BLOCKS_UP&#039;);

/**
 * Action that moves given blocks to a new position.
 *
 * @param {?string} clientIds        The client IDs of the blocks.
 * @param {?string} fromRootClientId Root client ID source.
 * @param {?string} toRootClientId   Root client ID destination.
 * @param {number}  index            The index to move the blocks to.
 */
const moveBlocksToPosition = (clientIds, fromRootClientId = &#039;&#039;, toRootClientId = &#039;&#039;, index) =&gt; ({
  select,
  dispatch
}) =&gt; {
  const canMoveBlocks = select.canMoveBlocks(clientIds);

  // If one of the blocks is locked or the parent is locked, we cannot move any block.
  if (!canMoveBlocks) {
    return;
  }

  // If moving inside the same root block the move is always possible.
  if (fromRootClientId !== toRootClientId) {
    const canRemoveBlocks = select.canRemoveBlocks(clientIds);

    // If we&#039;re moving to another block, it means we&#039;re deleting blocks from
    // the original block, so we need to check if removing is possible.
    if (!canRemoveBlocks) {
      return;
    }
    const canInsertBlocks = select.canInsertBlocks(clientIds, toRootClientId);

    // 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.
    if (!canInsertBlocks) {
      return;
    }
  }
  dispatch({
    type: &#039;MOVE_BLOCKS_TO_POSITION&#039;,
    fromRootClientId,
    toRootClientId,
    clientIds,
    index
  });
};

/**
 * Action that moves given block to a new position.
 *
 * @param {?string} clientId         The client ID of the block.
 * @param {?string} fromRootClientId Root client ID source.
 * @param {?string} toRootClientId   Root client ID destination.
 * @param {number}  index            The index to move the block to.
 */
function moveBlockToPosition(clientId, fromRootClientId = &#039;&#039;, toRootClientId = &#039;&#039;, index) {
  return moveBlocksToPosition([clientId], fromRootClientId, toRootClientId, index);
}

/**
 * Action that inserts a single block, optionally at a specific index respective a root block list.
 *
 * Only allowed blocks are inserted. The action may fail silently for blocks that are not allowed or if
 * a templateLock is active on the block list.
 *
 * @param {Object}   block           Block object to insert.
 * @param {?number}  index           Index at which block should be inserted.
 * @param {?string}  rootClientId    Optional root client ID of block list on which to insert.
 * @param {?boolean} updateSelection If true block selection will be updated. If false, block selection will not change. Defaults to true.
 * @param {?Object}  meta            Optional Meta values to be passed to the action object.
 *
 * @return {Object} Action object.
 */
function insertBlock(block, index, rootClientId, updateSelection, meta) {
  return insertBlocks([block], index, rootClientId, updateSelection, 0, meta);
}

/* eslint-disable jsdoc/valid-types */
/**
 * Action that inserts an array of blocks, optionally at a specific index respective a root block list.
 *
 * Only allowed blocks are inserted. The action may fail silently for blocks that are not allowed or if
 * a templateLock is active on the block list.
 *
 * @param {Object[]}  blocks          Block objects to insert.
 * @param {?number}   index           Index at which block should be inserted.
 * @param {?string}   rootClientId    Optional root client ID of block list on which to insert.
 * @param {?boolean}  updateSelection If true block selection will be updated.  If false, block selection will not change. Defaults to true.
 * @param {0|-1|null} initialPosition Initial focus position. Setting it to null prevent focusing the inserted block.
 * @param {?Object}   meta            Optional Meta values to be passed to the action object.
 *
 * @return {Object} Action object.
 */
const insertBlocks = (blocks, index, rootClientId, updateSelection = true, initialPosition = 0, meta) =&gt; ({
  select,
  dispatch
}) =&gt; {
  /* eslint-enable jsdoc/valid-types */
  if (initialPosition !== null &amp;&amp; typeof initialPosition === &#039;object&#039;) {
    meta = initialPosition;
    initialPosition = 0;
    external_wp_deprecated_default()(&quot;meta argument in wp.data.dispatch(&#039;core/block-editor&#039;)&quot;, {
      since: &#039;5.8&#039;,
      hint: &#039;The meta argument is now the 6th argument of the function&#039;
    });
  }
  blocks = actions_castArray(blocks);
  const allowedBlocks = [];
  for (const block of blocks) {
    const isValid = select.canInsertBlockType(block.name, rootClientId);
    if (isValid) {
      allowedBlocks.push(block);
    }
  }
  if (allowedBlocks.length) {
    dispatch({
      type: &#039;INSERT_BLOCKS&#039;,
      blocks: allowedBlocks,
      index,
      rootClientId,
      time: Date.now(),
      updateSelection,
      initialPosition: updateSelection ? initialPosition : null,
      meta
    });
  }
};

/**
 * Action that shows the insertion point.
 *
 * @param    {?string}         rootClientId           Optional root client ID of block list on
 *                                                    which to insert.
 * @param    {?number}         index                  Index at which block should be inserted.
 * @param    {?Object}         __unstableOptions      Additional options.
 * @property {boolean}         __unstableWithInserter Whether or not to show an inserter button.
 * @property {WPDropOperation} operation              The operation to perform when applied,
 *                                                    either &#039;insert&#039; or &#039;replace&#039; for now.
 *
 * @return {Object} Action object.
 */
function showInsertionPoint(rootClientId, index, __unstableOptions = {}) {
  const {
    __unstableWithInserter,
    operation,
    nearestSide
  } = __unstableOptions;
  return {
    type: &#039;SHOW_INSERTION_POINT&#039;,
    rootClientId,
    index,
    __unstableWithInserter,
    operation,
    nearestSide
  };
}
/**
 * Action that hides the insertion point.
 */
const hideInsertionPoint = () =&gt; ({
  select,
  dispatch
}) =&gt; {
  if (!select.isBlockInsertionPointVisible()) {
    return;
  }
  dispatch({
    type: &#039;HIDE_INSERTION_POINT&#039;
  });
};

/**
 * Action that resets the template validity.
 *
 * @param {boolean} isValid template validity flag.
 *
 * @return {Object} Action object.
 */
function setTemplateValidity(isValid) {
  return {
    type: &#039;SET_TEMPLATE_VALIDITY&#039;,
    isValid
  };
}

/**
 * Action that synchronizes the template with the list of blocks.
 *
 * @return {Object} Action object.
 */
const synchronizeTemplate = () =&gt; ({
  select,
  dispatch
}) =&gt; {
  dispatch({
    type: &#039;SYNCHRONIZE_TEMPLATE&#039;
  });
  const blocks = select.getBlocks();
  const template = select.getTemplate();
  const updatedBlockList = (0,external_wp_blocks_namespaceObject.synchronizeBlocksWithTemplate)(blocks, template);
  dispatch.resetBlocks(updatedBlockList);
};

/**
 * Delete the current selection.
 *
 * @param {boolean} isForward
 */
const __unstableDeleteSelection = isForward =&gt; ({
  registry,
  select,
  dispatch
}) =&gt; {
  const selectionAnchor = select.getSelectionStart();
  const selectionFocus = select.getSelectionEnd();
  if (selectionAnchor.clientId === selectionFocus.clientId) {
    return;
  }

  // It&#039;s not mergeable if there&#039;s no rich text selection.
  if (!selectionAnchor.attributeKey || !selectionFocus.attributeKey || typeof selectionAnchor.offset === &#039;undefined&#039; || typeof selectionFocus.offset === &#039;undefined&#039;) {
    return false;
  }
  const anchorRootClientId = select.getBlockRootClientId(selectionAnchor.clientId);
  const focusRootClientId = select.getBlockRootClientId(selectionFocus.clientId);

  // It&#039;s not mergeable if the selection doesn&#039;t start and end in the same
  // block list. Maybe in the future it should be allowed.
  if (anchorRootClientId !== focusRootClientId) {
    return;
  }
  const blockOrder = select.getBlockOrder(anchorRootClientId);
  const anchorIndex = blockOrder.indexOf(selectionAnchor.clientId);
  const focusIndex = blockOrder.indexOf(selectionFocus.clientId);

  // Reassign selection start and end based on order.
  let selectionStart, selectionEnd;
  if (anchorIndex &gt; focusIndex) {
    selectionStart = selectionFocus;
    selectionEnd = selectionAnchor;
  } else {
    selectionStart = selectionAnchor;
    selectionEnd = selectionFocus;
  }
  const targetSelection = isForward ? selectionEnd : selectionStart;
  const targetBlock = select.getBlock(targetSelection.clientId);
  const targetBlockType = (0,external_wp_blocks_namespaceObject.getBlockType)(targetBlock.name);
  if (!targetBlockType.merge) {
    return;
  }
  const selectionA = selectionStart;
  const selectionB = selectionEnd;
  const blockA = select.getBlock(selectionA.clientId);
  const blockB = select.getBlock(selectionB.clientId);
  const htmlA = blockA.attributes[selectionA.attributeKey];
  const htmlB = blockB.attributes[selectionB.attributeKey];
  let valueA = (0,external_wp_richText_namespaceObject.create)({
    html: htmlA
  });
  let valueB = (0,external_wp_richText_namespaceObject.create)({
    html: htmlB
  });
  valueA = (0,external_wp_richText_namespaceObject.remove)(valueA, selectionA.offset, valueA.text.length);
  valueB = (0,external_wp_richText_namespaceObject.insert)(valueB, START_OF_SELECTED_AREA, 0, selectionB.offset);

  // Clone the blocks so we don&#039;t manipulate the original.
  const cloneA = (0,external_wp_blocks_namespaceObject.cloneBlock)(blockA, {
    [selectionA.attributeKey]: (0,external_wp_richText_namespaceObject.toHTMLString)({
      value: valueA
    })
  });
  const cloneB = (0,external_wp_blocks_namespaceObject.cloneBlock)(blockB, {
    [selectionB.attributeKey]: (0,external_wp_richText_namespaceObject.toHTMLString)({
      value: valueB
    })
  });
  const followingBlock = isForward ? cloneA : cloneB;

  // We can only merge blocks with similar types
  // thus, we transform the block to merge first
  const blocksWithTheSameType = blockA.name === blockB.name ? [followingBlock] : (0,external_wp_blocks_namespaceObject.switchToBlockType)(followingBlock, targetBlockType.name);

  // If the block types can not match, do nothing
  if (!blocksWithTheSameType || !blocksWithTheSameType.length) {
    return;
  }
  let updatedAttributes;
  if (isForward) {
    const blockToMerge = blocksWithTheSameType.pop();
    updatedAttributes = targetBlockType.merge(blockToMerge.attributes, cloneB.attributes);
  } else {
    const blockToMerge = blocksWithTheSameType.shift();
    updatedAttributes = targetBlockType.merge(cloneA.attributes, blockToMerge.attributes);
  }
  const newAttributeKey = retrieveSelectedAttribute(updatedAttributes);
  const convertedHtml = updatedAttributes[newAttributeKey];
  const convertedValue = (0,external_wp_richText_namespaceObject.create)({
    html: convertedHtml
  });
  const newOffset = convertedValue.text.indexOf(START_OF_SELECTED_AREA);
  const newValue = (0,external_wp_richText_namespaceObject.remove)(convertedValue, newOffset, newOffset + 1);
  const newHtml = (0,external_wp_richText_namespaceObject.toHTMLString)({
    value: newValue
  });
  updatedAttributes[newAttributeKey] = newHtml;
  const selectedBlockClientIds = select.getSelectedBlockClientIds();
  const replacement = [...(isForward ? blocksWithTheSameType : []), {
    // Preserve the original client ID.
    ...targetBlock,
    attributes: {
      ...targetBlock.attributes,
      ...updatedAttributes
    }
  }, ...(isForward ? [] : blocksWithTheSameType)];
  registry.batch(() =&gt; {
    dispatch.selectionChange(targetBlock.clientId, newAttributeKey, newOffset, newOffset);
    dispatch.replaceBlocks(selectedBlockClientIds, replacement, 0,
    // If we don&#039;t pass the `indexToSelect` it will default to the last block.
    select.getSelectedBlocksInitialCaretPosition());
  });
};

/**
 * Split the current selection.
 * @param {?Array} blocks
 */
const __unstableSplitSelection = (blocks = []) =&gt; ({
  registry,
  select,
  dispatch
}) =&gt; {
  const selectionAnchor = select.getSelectionStart();
  const selectionFocus = select.getSelectionEnd();
  const anchorRootClientId = select.getBlockRootClientId(selectionAnchor.clientId);
  const focusRootClientId = select.getBlockRootClientId(selectionFocus.clientId);

  // It&#039;s not splittable if the selection doesn&#039;t start and end in the same
  // block list. Maybe in the future it should be allowed.
  if (anchorRootClientId !== focusRootClientId) {
    return;
  }
  const blockOrder = select.getBlockOrder(anchorRootClientId);
  const anchorIndex = blockOrder.indexOf(selectionAnchor.clientId);
  const focusIndex = blockOrder.indexOf(selectionFocus.clientId);

  // Reassign selection start and end based on order.
  let selectionStart, selectionEnd;
  if (anchorIndex &gt; focusIndex) {
    selectionStart = selectionFocus;
    selectionEnd = selectionAnchor;
  } else {
    selectionStart = selectionAnchor;
    selectionEnd = selectionFocus;
  }
  const selectionA = selectionStart;
  const selectionB = selectionEnd;
  const blockA = select.getBlock(selectionA.clientId);
  const blockB = select.getBlock(selectionB.clientId);
  const blockAType = (0,external_wp_blocks_namespaceObject.getBlockType)(blockA.name);
  const blockBType = (0,external_wp_blocks_namespaceObject.getBlockType)(blockB.name);
  const attributeKeyA = typeof selectionA.attributeKey === &#039;string&#039; ? selectionA.attributeKey : findRichTextAttributeKey(blockAType);
  const attributeKeyB = typeof selectionB.attributeKey === &#039;string&#039; ? selectionB.attributeKey : findRichTextAttributeKey(blockBType);
  const blockAttributes = select.getBlockAttributes(selectionA.clientId);
  const bindings = blockAttributes?.metadata?.bindings;

  // If the attribute is bound, don&#039;t split the selection and insert a new block instead.
  if (bindings?.[attributeKeyA]) {
    // Show warning if user tries to insert a block into another block with bindings.
    if (blocks.length) {
      const {
        createWarningNotice
      } = registry.dispatch(external_wp_notices_namespaceObject.store);
      createWarningNotice((0,external_wp_i18n_namespaceObject.__)(&quot;Blocks can&#039;t be inserted into other blocks with bindings&quot;), {
        type: &#039;snackbar&#039;
      });
      return;
    }
    dispatch.insertAfterBlock(selectionA.clientId);
    return;
  }

  // Can&#039;t split if the selection is not set.
  if (!attributeKeyA || !attributeKeyB || typeof selectionAnchor.offset === &#039;undefined&#039; || typeof selectionFocus.offset === &#039;undefined&#039;) {
    return;
  }

  // We can do some short-circuiting if the selection is collapsed.
  if (selectionA.clientId === selectionB.clientId &amp;&amp; attributeKeyA === attributeKeyB &amp;&amp; selectionA.offset === selectionB.offset) {
    // If an unmodified default block is selected, replace it. We don&#039;t
    // want to be converting into a default block.
    if (blocks.length) {
      if ((0,external_wp_blocks_namespaceObject.isUnmodifiedDefaultBlock)(blockA)) {
        dispatch.replaceBlocks([selectionA.clientId], blocks, blocks.length - 1, -1);
        return;
      }
    }

    // If selection is at the start or end, we can simply insert an
    // empty block, provided this block has no inner blocks.
    else if (!select.getBlockOrder(selectionA.clientId).length) {
      function createEmpty() {
        const defaultBlockName = (0,external_wp_blocks_namespaceObject.getDefaultBlockName)();
        return select.canInsertBlockType(defaultBlockName, anchorRootClientId) ? (0,external_wp_blocks_namespaceObject.createBlock)(defaultBlockName) : (0,external_wp_blocks_namespaceObject.createBlock)(select.getBlockName(selectionA.clientId));
      }
      const length = blockAttributes[attributeKeyA].length;
      if (selectionA.offset === 0 &amp;&amp; length) {
        dispatch.insertBlocks([createEmpty()], select.getBlockIndex(selectionA.clientId), anchorRootClientId, false);
        return;
      }
      if (selectionA.offset === length) {
        dispatch.insertBlocks([createEmpty()], select.getBlockIndex(selectionA.clientId) + 1, anchorRootClientId);
        return;
      }
    }
  }
  const htmlA = blockA.attributes[attributeKeyA];
  const htmlB = blockB.attributes[attributeKeyB];
  let valueA = (0,external_wp_richText_namespaceObject.create)({
    html: htmlA
  });
  let valueB = (0,external_wp_richText_namespaceObject.create)({
    html: htmlB
  });
  valueA = (0,external_wp_richText_namespaceObject.remove)(valueA, selectionA.offset, valueA.text.length);
  valueB = (0,external_wp_richText_namespaceObject.remove)(valueB, 0, selectionB.offset);
  let head = {
    // Preserve the original client ID.
    ...blockA,
    // If both start and end are the same, should only copy innerBlocks
    // once.
    innerBlocks: blockA.clientId === blockB.clientId ? [] : blockA.innerBlocks,
    attributes: {
      ...blockA.attributes,
      [attributeKeyA]: (0,external_wp_richText_namespaceObject.toHTMLString)({
        value: valueA
      })
    }
  };
  let tail = {
    ...blockB,
    // Only preserve the original client ID if the end is different.
    clientId: blockA.clientId === blockB.clientId ? (0,external_wp_blocks_namespaceObject.createBlock)(blockB.name).clientId : blockB.clientId,
    attributes: {
      ...blockB.attributes,
      [attributeKeyB]: (0,external_wp_richText_namespaceObject.toHTMLString)({
        value: valueB
      })
    }
  };

  // When splitting a block, attempt to convert the tail block to the
  // default block type. For example, when splitting a heading block, the
  // tail block will be converted to a paragraph block. Note that for
  // blocks such as a list item and button, this will be skipped because
  // the default block type cannot be inserted.
  const defaultBlockName = (0,external_wp_blocks_namespaceObject.getDefaultBlockName)();
  if (
  // A block is only split when the selection is within the same
  // block.
  blockA.clientId === blockB.clientId &amp;&amp; defaultBlockName &amp;&amp; tail.name !== defaultBlockName &amp;&amp; select.canInsertBlockType(defaultBlockName, anchorRootClientId)) {
    const switched = (0,external_wp_blocks_namespaceObject.switchToBlockType)(tail, defaultBlockName);
    if (switched?.length === 1) {
      tail = switched[0];
    }
  }
  if (!blocks.length) {
    dispatch.replaceBlocks(select.getSelectedBlockClientIds(), [head, tail]);
    return;
  }
  let selection;
  const output = [];
  const clonedBlocks = [...blocks];
  const firstBlock = clonedBlocks.shift();
  const headType = (0,external_wp_blocks_namespaceObject.getBlockType)(head.name);
  const firstBlocks = headType.merge &amp;&amp; firstBlock.name === headType.name ? [firstBlock] : (0,external_wp_blocks_namespaceObject.switchToBlockType)(firstBlock, headType.name);
  if (firstBlocks?.length) {
    const first = firstBlocks.shift();
    head = {
      ...head,
      attributes: {
        ...head.attributes,
        ...headType.merge(head.attributes, first.attributes)
      }
    };
    output.push(head);
    selection = {
      clientId: head.clientId,
      attributeKey: attributeKeyA,
      offset: (0,external_wp_richText_namespaceObject.create)({
        html: head.attributes[attributeKeyA]
      }).text.length
    };
    clonedBlocks.unshift(...firstBlocks);
  } else {
    if (!(0,external_wp_blocks_namespaceObject.isUnmodifiedBlock)(head)) {
      output.push(head);
    }
    output.push(firstBlock);
  }
  const lastBlock = clonedBlocks.pop();
  const tailType = (0,external_wp_blocks_namespaceObject.getBlockType)(tail.name);
  if (clonedBlocks.length) {
    output.push(...clonedBlocks);
  }
  if (lastBlock) {
    const lastBlocks = tailType.merge &amp;&amp; tailType.name === lastBlock.name ? [lastBlock] : (0,external_wp_blocks_namespaceObject.switchToBlockType)(lastBlock, tailType.name);
    if (lastBlocks?.length) {
      const last = lastBlocks.pop();
      output.push({
        ...tail,
        attributes: {
          ...tail.attributes,
          ...tailType.merge(last.attributes, tail.attributes)
        }
      });
      output.push(...lastBlocks);
      selection = {
        clientId: tail.clientId,
        attributeKey: attributeKeyB,
        offset: (0,external_wp_richText_namespaceObject.create)({
          html: last.attributes[attributeKeyB]
        }).text.length
      };
    } else {
      output.push(lastBlock);
      if (!(0,external_wp_blocks_namespaceObject.isUnmodifiedBlock)(tail)) {
        output.push(tail);
      }
    }
  } else if (!(0,external_wp_blocks_namespaceObject.isUnmodifiedBlock)(tail)) {
    output.push(tail);
  }
  registry.batch(() =&gt; {
    dispatch.replaceBlocks(select.getSelectedBlockClientIds(), output, output.length - 1, 0);
    if (selection) {
      dispatch.selectionChange(selection.clientId, selection.attributeKey, selection.offset, selection.offset);
    }
  });
};

/**
 * Expand the selection to cover the entire blocks, removing partial selection.
 */
const __unstableExpandSelection = () =&gt; ({
  select,
  dispatch
}) =&gt; {
  const selectionAnchor = select.getSelectionStart();
  const selectionFocus = select.getSelectionEnd();
  dispatch.selectionChange({
    start: {
      clientId: selectionAnchor.clientId
    },
    end: {
      clientId: selectionFocus.clientId
    }
  });
};

/**
 * Action that merges two blocks.
 *
 * @param {string} firstBlockClientId  Client ID of the first block to merge.
 * @param {string} secondBlockClientId Client ID of the second block to merge.
 */
const mergeBlocks = (firstBlockClientId, secondBlockClientId) =&gt; ({
  registry,
  select,
  dispatch
}) =&gt; {
  const clientIdA = firstBlockClientId;
  const clientIdB = secondBlockClientId;
  const blockA = select.getBlock(clientIdA);
  const blockAType = (0,external_wp_blocks_namespaceObject.getBlockType)(blockA.name);
  if (!blockAType) {
    return;
  }
  const blockB = select.getBlock(clientIdB);
  if (!blockAType.merge &amp;&amp; (0,external_wp_blocks_namespaceObject.getBlockSupport)(blockA.name, &#039;__experimentalOnMerge&#039;)) {
    // If there&#039;s no merge function defined, attempt merging inner
    // blocks.
    const blocksWithTheSameType = (0,external_wp_blocks_namespaceObject.switchToBlockType)(blockB, blockAType.name);
    // Only focus the previous block if it&#039;s not mergeable.
    if (blocksWithTheSameType?.length !== 1) {
      dispatch.selectBlock(blockA.clientId);
      return;
    }
    const [blockWithSameType] = blocksWithTheSameType;
    if (blockWithSameType.innerBlocks.length &lt; 1) {
      dispatch.selectBlock(blockA.clientId);
      return;
    }
    registry.batch(() =&gt; {
      dispatch.insertBlocks(blockWithSameType.innerBlocks, undefined, clientIdA);
      dispatch.removeBlock(clientIdB);
      dispatch.selectBlock(blockWithSameType.innerBlocks[0].clientId);

      // Attempt to merge the next block if it&#039;s the same type and
      // same attributes. This is useful when merging a paragraph into
      // a list, and the next block is also a list. If we don&#039;t merge,
      // it looks like one list, but it&#039;s actually two lists. The same
      // applies to other blocks such as a group with the same
      // attributes.
      const nextBlockClientId = select.getNextBlockClientId(clientIdA);
      if (nextBlockClientId &amp;&amp; select.getBlockName(clientIdA) === select.getBlockName(nextBlockClientId)) {
        const rootAttributes = select.getBlockAttributes(clientIdA);
        const previousRootAttributes = select.getBlockAttributes(nextBlockClientId);
        if (Object.keys(rootAttributes).every(key =&gt; rootAttributes[key] === previousRootAttributes[key])) {
          dispatch.moveBlocksToPosition(select.getBlockOrder(nextBlockClientId), nextBlockClientId, clientIdA);
          dispatch.removeBlock(nextBlockClientId, false);
        }
      }
    });
    return;
  }
  if ((0,external_wp_blocks_namespaceObject.isUnmodifiedDefaultBlock)(blockA)) {
    dispatch.removeBlock(clientIdA, select.isBlockSelected(clientIdA));
    return;
  }
  if ((0,external_wp_blocks_namespaceObject.isUnmodifiedDefaultBlock)(blockB)) {
    dispatch.removeBlock(clientIdB, select.isBlockSelected(clientIdB));
    return;
  }
  if (!blockAType.merge) {
    dispatch.selectBlock(blockA.clientId);
    return;
  }
  const blockBType = (0,external_wp_blocks_namespaceObject.getBlockType)(blockB.name);
  const {
    clientId,
    attributeKey,
    offset
  } = select.getSelectionStart();
  const selectedBlockType = clientId === clientIdA ? blockAType : blockBType;
  const attributeDefinition = selectedBlockType.attributes[attributeKey];
  const canRestoreTextSelection = (clientId === clientIdA || clientId === clientIdB) &amp;&amp; attributeKey !== undefined &amp;&amp; offset !== undefined &amp;&amp;
  // We cannot restore text selection if the RichText identifier
  // is not a defined block attribute key. This can be the case if the
  // fallback instance ID is used to store selection (and no RichText
  // identifier is set), or when the identifier is wrong.
  !!attributeDefinition;
  if (!attributeDefinition) {
    if (typeof attributeKey === &#039;number&#039;) {
      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}`);
    } else {
      window.console.error(&#039;The RichText identifier prop does not match any attributes defined by the block.&#039;);
    }
  }

  // Clone the blocks so we don&#039;t insert the character in a &quot;live&quot; block.
  const cloneA = (0,external_wp_blocks_namespaceObject.cloneBlock)(blockA);
  const cloneB = (0,external_wp_blocks_namespaceObject.cloneBlock)(blockB);
  if (canRestoreTextSelection) {
    const selectedBlock = clientId === clientIdA ? cloneA : cloneB;
    const html = selectedBlock.attributes[attributeKey];
    const value = (0,external_wp_richText_namespaceObject.insert)((0,external_wp_richText_namespaceObject.create)({
      html
    }), START_OF_SELECTED_AREA, offset, offset);
    selectedBlock.attributes[attributeKey] = (0,external_wp_richText_namespaceObject.toHTMLString)({
      value
    });
  }

  // We can only merge blocks with similar types
  // thus, we transform the block to merge first.
  const blocksWithTheSameType = blockA.name === blockB.name ? [cloneB] : (0,external_wp_blocks_namespaceObject.switchToBlockType)(cloneB, blockA.name);

  // If the block types can not match, do nothing.
  if (!blocksWithTheSameType || !blocksWithTheSameType.length) {
    return;
  }

  // Calling the merge to update the attributes and remove the block to be merged.
  const updatedAttributes = blockAType.merge(cloneA.attributes, blocksWithTheSameType[0].attributes);
  if (canRestoreTextSelection) {
    const newAttributeKey = retrieveSelectedAttribute(updatedAttributes);
    const convertedHtml = updatedAttributes[newAttributeKey];
    const convertedValue = (0,external_wp_richText_namespaceObject.create)({
      html: convertedHtml
    });
    const newOffset = convertedValue.text.indexOf(START_OF_SELECTED_AREA);
    const newValue = (0,external_wp_richText_namespaceObject.remove)(convertedValue, newOffset, newOffset + 1);
    const newHtml = (0,external_wp_richText_namespaceObject.toHTMLString)({
      value: newValue
    });
    updatedAttributes[newAttributeKey] = newHtml;
    dispatch.selectionChange(blockA.clientId, newAttributeKey, newOffset, newOffset);
  }
  dispatch.replaceBlocks([blockA.clientId, blockB.clientId], [{
    ...blockA,
    attributes: {
      ...blockA.attributes,
      ...updatedAttributes
    }
  }, ...blocksWithTheSameType.slice(1)], 0 // If we don&#039;t pass the `indexToSelect` it will default to the last block.
  );
};

/**
 * Yields action objects used in signalling that the blocks corresponding to
 * the set of specified client IDs are to be removed.
 *
 * @param {string|string[]} clientIds      Client IDs of blocks to remove.
 * @param {boolean}         selectPrevious True if the previous block
 *                                         or the immediate parent
 *                                         (if no previous block exists)
 *                                         should be selected
 *                                         when a block is removed.
 */
const removeBlocks = (clientIds, selectPrevious = true) =&gt; privateRemoveBlocks(clientIds, selectPrevious);

/**
 * Returns an action object used in signalling that the block with the
 * specified client ID is to be removed.
 *
 * @param {string}  clientId       Client ID of block to remove.
 * @param {boolean} selectPrevious True if the previous block should be
 *                                 selected when a block is removed.
 *
 * @return {Object} Action object.
 */
function removeBlock(clientId, selectPrevious) {
  return removeBlocks([clientId], selectPrevious);
}

/* eslint-disable jsdoc/valid-types */
/**
 * Returns an action object used in signalling that the inner blocks with the
 * specified client ID should be replaced.
 *
 * @param {string}    rootClientId    Client ID of the block whose InnerBlocks will re replaced.
 * @param {Object[]}  blocks          Block objects to insert as new InnerBlocks
 * @param {?boolean}  updateSelection If true block selection will be updated. If false, block selection will not change. Defaults to false.
 * @param {0|-1|null} initialPosition Initial block position.
 * @return {Object} Action object.
 */
function replaceInnerBlocks(rootClientId, blocks, updateSelection = false, initialPosition = 0) {
  /* eslint-enable jsdoc/valid-types */
  return {
    type: &#039;REPLACE_INNER_BLOCKS&#039;,
    rootClientId,
    blocks,
    updateSelection,
    initialPosition: updateSelection ? initialPosition : null,
    time: Date.now()
  };
}

/**
 * Returns an action object used to toggle the block editing mode between
 * visual and HTML modes.
 *
 * @param {string} clientId Block client ID.
 *
 * @return {Object} Action object.
 */
function toggleBlockMode(clientId) {
  return {
    type: &#039;TOGGLE_BLOCK_MODE&#039;,
    clientId
  };
}

/**
 * Returns an action object used in signalling that the user has begun to type.
 *
 * @return {Object} Action object.
 */
function startTyping() {
  return {
    type: &#039;START_TYPING&#039;
  };
}

/**
 * Returns an action object used in signalling that the user has stopped typing.
 *
 * @return {Object} Action object.
 */
function stopTyping() {
  return {
    type: &#039;STOP_TYPING&#039;
  };
}

/**
 * Returns an action object used in signalling that the user has begun to drag blocks.
 *
 * @param {string[]} clientIds An array of client ids being dragged
 *
 * @return {Object} Action object.
 */
function startDraggingBlocks(clientIds = []) {
  return {
    type: &#039;START_DRAGGING_BLOCKS&#039;,
    clientIds
  };
}

/**
 * Returns an action object used in signalling that the user has stopped dragging blocks.
 *
 * @return {Object} Action object.
 */
function stopDraggingBlocks() {
  return {
    type: &#039;STOP_DRAGGING_BLOCKS&#039;
  };
}

/**
 * Returns an action object used in signalling that the caret has entered formatted text.
 *
 * @deprecated
 *
 * @return {Object} Action object.
 */
function enterFormattedText() {
  external_wp_deprecated_default()(&#039;wp.data.dispatch( &quot;core/block-editor&quot; ).enterFormattedText&#039;, {
    since: &#039;6.1&#039;,
    version: &#039;6.3&#039;
  });
  return {
    type: &#039;DO_NOTHING&#039;
  };
}

/**
 * Returns an action object used in signalling that the user caret has exited formatted text.
 *
 * @deprecated
 *
 * @return {Object} Action object.
 */
function exitFormattedText() {
  external_wp_deprecated_default()(&#039;wp.data.dispatch( &quot;core/block-editor&quot; ).exitFormattedText&#039;, {
    since: &#039;6.1&#039;,
    version: &#039;6.3&#039;
  });
  return {
    type: &#039;DO_NOTHING&#039;
  };
}

/**
 * Action that changes the position of the user caret.
 *
 * @param {string|WPSelection} clientId     The selected block client ID.
 * @param {string}             attributeKey The selected block attribute key.
 * @param {number}             startOffset  The start offset.
 * @param {number}             endOffset    The end offset.
 *
 * @return {Object} Action object.
 */
function selectionChange(clientId, attributeKey, startOffset, endOffset) {
  if (typeof clientId === &#039;string&#039;) {
    return {
      type: &#039;SELECTION_CHANGE&#039;,
      clientId,
      attributeKey,
      startOffset,
      endOffset
    };
  }
  return {
    type: &#039;SELECTION_CHANGE&#039;,
    ...clientId
  };
}

/**
 * Action that adds a new block of the default type to the block list.
 *
 * @param {?Object} attributes   Optional attributes of the block to assign.
 * @param {?string} rootClientId Optional root client ID of block list on which
 *                               to append.
 * @param {?number} index        Optional index where to insert the default block.
 */
const insertDefaultBlock = (attributes, rootClientId, index) =&gt; ({
  dispatch
}) =&gt; {
  // Abort if there is no default block type (if it has been unregistered).
  const defaultBlockName = (0,external_wp_blocks_namespaceObject.getDefaultBlockName)();
  if (!defaultBlockName) {
    return;
  }
  const block = (0,external_wp_blocks_namespaceObject.createBlock)(defaultBlockName, attributes);
  return dispatch.insertBlock(block, index, rootClientId);
};

/**
 * @typedef {Object&lt; string, Object &gt;} SettingsByClientId
 */

/**
 * Action that changes the nested settings of the given block(s).
 *
 * @param {string | SettingsByClientId} clientId Client ID of the block whose
 *                                               nested setting are being
 *                                               received, or object of settings
 *                                               by client ID.
 * @param {Object}                      settings Object with the new settings
 *                                               for the nested block.
 *
 * @return {Object} Action object
 */
function updateBlockListSettings(clientId, settings) {
  return {
    type: &#039;UPDATE_BLOCK_LIST_SETTINGS&#039;,
    clientId,
    settings
  };
}

/**
 * Action that updates the block editor settings.
 *
 * @param {Object} settings Updated settings
 *
 * @return {Object} Action object
 */
function updateSettings(settings) {
  return __experimentalUpdateSettings(settings, {
    stripExperimentalSettings: true
  });
}

/**
 * Action that signals that a temporary reusable block has been saved
 * in order to switch its temporary id with the real id.
 *
 * @param {string} id        Reusable block&#039;s id.
 * @param {string} updatedId Updated block&#039;s id.
 *
 * @return {Object} Action object.
 */
function __unstableSaveReusableBlock(id, updatedId) {
  return {
    type: &#039;SAVE_REUSABLE_BLOCK_SUCCESS&#039;,
    id,
    updatedId
  };
}

/**
 * Action that marks the last block change explicitly as persistent.
 *
 * @return {Object} Action object.
 */
function __unstableMarkLastChangeAsPersistent() {
  return {
    type: &#039;MARK_LAST_CHANGE_AS_PERSISTENT&#039;
  };
}

/**
 * Action that signals that the next block change should be marked explicitly as not persistent.
 *
 * @return {Object} Action object.
 */
function __unstableMarkNextChangeAsNotPersistent() {
  return {
    type: &#039;MARK_NEXT_CHANGE_AS_NOT_PERSISTENT&#039;
  };
}

/**
 * Action that marks the last block change as an automatic change, meaning it was not
 * performed by the user, and can be undone using the `Escape` and `Backspace` keys.
 * This action must be called after the change was made, and any actions that are a
 * consequence of it, so it is recommended to be called at the next idle period to ensure all
 * selection changes have been recorded.
 */
const __unstableMarkAutomaticChange = () =&gt; ({
  dispatch
}) =&gt; {
  dispatch({
    type: &#039;MARK_AUTOMATIC_CHANGE&#039;
  });
  const {
    requestIdleCallback = cb =&gt; setTimeout(cb, 100)
  } = window;
  requestIdleCallback(() =&gt; {
    dispatch({
      type: &#039;MARK_AUTOMATIC_CHANGE_FINAL&#039;
    });
  });
};

/**
 * Action that enables or disables the navigation mode.
 *
 * @param {boolean} isNavigationMode Enable/Disable navigation mode.
 */
const setNavigationMode = (isNavigationMode = true) =&gt; ({
  dispatch
}) =&gt; {
  dispatch.__unstableSetEditorMode(isNavigationMode ? &#039;navigation&#039; : &#039;edit&#039;);
};

/**
 * Action that sets the editor mode
 *
 * @param {string} mode Editor mode
 */
const __unstableSetEditorMode = mode =&gt; ({
  registry
}) =&gt; {
  registry.dispatch(external_wp_preferences_namespaceObject.store).set(&#039;core&#039;, &#039;editorTool&#039;, mode);
  if (mode === &#039;navigation&#039;) {
    (0,external_wp_a11y_namespaceObject.speak)((0,external_wp_i18n_namespaceObject.__)(&#039;You are currently in Write mode.&#039;));
  } else if (mode === &#039;edit&#039;) {
    (0,external_wp_a11y_namespaceObject.speak)((0,external_wp_i18n_namespaceObject.__)(&#039;You are currently in Design mode.&#039;));
  }
};

/**
 * Set the block moving client ID.
 *
 * @deprecated
 *
 * @return {Object} Action object.
 */
function setBlockMovingClientId() {
  external_wp_deprecated_default()(&#039;wp.data.dispatch( &quot;core/block-editor&quot; ).setBlockMovingClientId&#039;, {
    since: &#039;6.7&#039;,
    hint: &#039;Block moving mode feature has been removed&#039;
  });
  return {
    type: &#039;DO_NOTHING&#039;
  };
}

/**
 * Action that duplicates a list of blocks.
 *
 * @param {string[]} clientIds
 * @param {boolean}  updateSelection
 */
const duplicateBlocks = (clientIds, updateSelection = true) =&gt; ({
  select,
  dispatch
}) =&gt; {
  if (!clientIds || !clientIds.length) {
    return;
  }

  // Return early if blocks don&#039;t exist.
  const blocks = select.getBlocksByClientId(clientIds);
  if (blocks.some(block =&gt; !block)) {
    return;
  }

  // Return early if blocks don&#039;t support multiple usage.
  const blockNames = blocks.map(block =&gt; block.name);
  if (blockNames.some(blockName =&gt; !(0,external_wp_blocks_namespaceObject.hasBlockSupport)(blockName, &#039;multiple&#039;, true))) {
    return;
  }
  const rootClientId = select.getBlockRootClientId(clientIds[0]);
  const clientIdsArray = actions_castArray(clientIds);
  const lastSelectedIndex = select.getBlockIndex(clientIdsArray[clientIdsArray.length - 1]);
  const clonedBlocks = blocks.map(block =&gt; (0,external_wp_blocks_namespaceObject.__experimentalCloneSanitizedBlock)(block));
  dispatch.insertBlocks(clonedBlocks, lastSelectedIndex + 1, rootClientId, updateSelection);
  if (clonedBlocks.length &gt; 1 &amp;&amp; updateSelection) {
    dispatch.multiSelect(clonedBlocks[0].clientId, clonedBlocks[clonedBlocks.length - 1].clientId);
  }
  return clonedBlocks.map(block =&gt; block.clientId);
};

/**
 * Action that inserts a default block before a given block.
 *
 * @param {string} clientId
 */
const insertBeforeBlock = clientId =&gt; ({
  select,
  dispatch
}) =&gt; {
  if (!clientId) {
    return;
  }
  const rootClientId = select.getBlockRootClientId(clientId);
  const isLocked = select.getTemplateLock(rootClientId);
  if (isLocked) {
    return;
  }
  const blockIndex = select.getBlockIndex(clientId);
  const directInsertBlock = rootClientId ? select.getDirectInsertBlock(rootClientId) : null;
  if (!directInsertBlock) {
    return dispatch.insertDefaultBlock({}, rootClientId, blockIndex);
  }
  const copiedAttributes = {};
  if (directInsertBlock.attributesToCopy) {
    const attributes = select.getBlockAttributes(clientId);
    directInsertBlock.attributesToCopy.forEach(key =&gt; {
      if (attributes[key]) {
        copiedAttributes[key] = attributes[key];
      }
    });
  }
  const block = (0,external_wp_blocks_namespaceObject.createBlock)(directInsertBlock.name, {
    ...directInsertBlock.attributes,
    ...copiedAttributes
  });
  return dispatch.insertBlock(block, blockIndex, rootClientId);
};

/**
 * Action that inserts a default block after a given block.
 *
 * @param {string} clientId
 */
const insertAfterBlock = clientId =&gt; ({
  select,
  dispatch
}) =&gt; {
  if (!clientId) {
    return;
  }
  const rootClientId = select.getBlockRootClientId(clientId);
  const isLocked = select.getTemplateLock(rootClientId);
  if (isLocked) {
    return;
  }
  const blockIndex = select.getBlockIndex(clientId);
  const directInsertBlock = rootClientId ? select.getDirectInsertBlock(rootClientId) : null;
  if (!directInsertBlock) {
    return dispatch.insertDefaultBlock({}, rootClientId, blockIndex + 1);
  }
  const copiedAttributes = {};
  if (directInsertBlock.attributesToCopy) {
    const attributes = select.getBlockAttributes(clientId);
    directInsertBlock.attributesToCopy.forEach(key =&gt; {
      if (attributes[key]) {
        copiedAttributes[key] = attributes[key];
      }
    });
  }
  const block = (0,external_wp_blocks_namespaceObject.createBlock)(directInsertBlock.name, {
    ...directInsertBlock.attributes,
    ...copiedAttributes
  });
  return dispatch.insertBlock(block, blockIndex + 1, rootClientId);
};

/**
 * Action that toggles the highlighted block state.
 *
 * @param {string}  clientId      The block&#039;s clientId.
 * @param {boolean} isHighlighted The highlight state.
 */
function toggleBlockHighlight(clientId, isHighlighted) {
  return {
    type: &#039;TOGGLE_BLOCK_HIGHLIGHT&#039;,
    clientId,
    isHighlighted
  };
}

/**
 * Action that &quot;flashes&quot; the block with a given `clientId` by rhythmically highlighting it.
 *
 * @param {string} clientId Target block client ID.
 */
const flashBlock = clientId =&gt; async ({
  dispatch
}) =&gt; {
  dispatch(toggleBlockHighlight(clientId, true));
  await new Promise(resolve =&gt; setTimeout(resolve, 150));
  dispatch(toggleBlockHighlight(clientId, false));
};

/**
 * Action that sets whether a block has controlled inner blocks.
 *
 * @param {string}  clientId                 The block&#039;s clientId.
 * @param {boolean} hasControlledInnerBlocks True if the block&#039;s inner blocks are controlled.
 */
function setHasControlledInnerBlocks(clientId, hasControlledInnerBlocks) {
  return {
    type: &#039;SET_HAS_CONTROLLED_INNER_BLOCKS&#039;,
    hasControlledInnerBlocks,
    clientId
  };
}

/**
 * Action that sets whether given blocks are visible on the canvas.
 *
 * @param {Record&lt;string,boolean&gt;} updates For each block&#039;s clientId, its new visibility setting.
 */
function setBlockVisibility(updates) {
  return {
    type: &#039;SET_BLOCK_VISIBILITY&#039;,
    updates
  };
}

/**
 * Action that sets whether a block is being temporarily edited as blocks.
 *
 * DO-NOT-USE in production.
 * This action is created for internal/experimental only usage and may be
 * removed anytime without any warning, causing breakage on any plugin or theme invoking it.
 *
 * @param {?string} temporarilyEditingAsBlocks The block&#039;s clientId being temporarily edited as blocks.
 * @param {?string} focusModeToRevert          The focus mode to revert after temporarily edit as blocks finishes.
 */
function __unstableSetTemporarilyEditingAsBlocks(temporarilyEditingAsBlocks, focusModeToRevert) {
  return {
    type: &#039;SET_TEMPORARILY_EDITING_AS_BLOCKS&#039;,
    temporarilyEditingAsBlocks,
    focusModeToRevert
  };
}

/**
 * Interface for inserter media requests.
 *
 * @typedef {Object} InserterMediaRequest
 * @property {number} per_page How many items to fetch per page.
 * @property {string} search   The search term to use for filtering the results.
 */

/**
 * Interface for inserter media responses. Any media resource should
 * map their response to this interface, in order to create the core
 * WordPress media blocks (image, video, audio).
 *
 * @typedef {Object} InserterMediaItem
 * @property {string}        title        The title of the media item.
 * @property {string}        url          The source url of the media item.
 * @property {string}        [previewUrl] The preview source url of the media item to display in the media list.
 * @property {number}        [id]         The WordPress id of the media item.
 * @property {number|string} [sourceId]   The id of the media item from external source.
 * @property {string}        [alt]        The alt text of the media item.
 * @property {string}        [caption]    The caption of the media item.
 */

/**
 * Registers a new inserter media category. Once registered, the media category is
 * available in the inserter&#039;s media tab.
 *
 * The following interfaces are used:
 *
 * _Type Definition_
 *
 * - _InserterMediaRequest_ `Object`: Interface for inserter media requests.
 *
 * _Properties_
 *
 * - _per_page_ `number`: How many items to fetch per page.
 * - _search_ `string`: The search term to use for filtering the results.
 *
 * _Type Definition_
 *
 * - _InserterMediaItem_ `Object`: Interface for inserter media responses. Any media resource should
 * map their response to this interface, in order to create the core
 * WordPress media blocks (image, video, audio).
 *
 * _Properties_
 *
 * - _title_ `string`: The title of the media item.
 * - _url_ `string: The source url of the media item.
 * - _previewUrl_ `[string]`: The preview source url of the media item to display in the media list.
 * - _id_ `[number]`: The WordPress id of the media item.
 * - _sourceId_ `[number|string]`: The id of the media item from external source.
 * - _alt_ `[string]`: The alt text of the media item.
 * - _caption_ `[string]`: The caption of the media item.
 *
 * @param    {InserterMediaCategory}                                  category                       The inserter media category to register.
 *
 * @example
 * ```js
 *
 * wp.data.dispatch(&#039;core/block-editor&#039;).registerInserterMediaCategory( {
 * 	 name: &#039;openverse&#039;,
 * 	 labels: {
 * 	 	name: &#039;Openverse&#039;,
 * 	 	search_items: &#039;Search Openverse&#039;,
 * 	 },
 * 	 mediaType: &#039;image&#039;,
 * 	 async fetch( query = {} ) {
 * 	 	const defaultArgs = {
 * 	 		mature: false,
 * 	 		excluded_source: &#039;flickr,inaturalist,wikimedia&#039;,
 * 	 		license: &#039;pdm,cc0&#039;,
 * 	 	};
 * 	 	const finalQuery = { ...query, ...defaultArgs };
 * 	 	// Sometimes you might need to map the supported request params according to `InserterMediaRequest`.
 * 	 	// interface. In this example the `search` query param is named `q`.
 * 	 	const mapFromInserterMediaRequest = {
 * 	 		per_page: &#039;page_size&#039;,
 * 	 		search: &#039;q&#039;,
 * 	 	};
 * 	 	const url = new URL( &#039;https://api.openverse.org/v1/images/&#039; );
 * 	 	Object.entries( finalQuery ).forEach( ( [ key, value ] ) =&gt; {
 * 	 		const queryKey = mapFromInserterMediaRequest[ key ] || key;
 * 	 		url.searchParams.set( queryKey, value );
 * 	 	} );
 * 	 	const response = await window.fetch( url, {
 * 	 		headers: {
 * 	 			&#039;User-Agent&#039;: &#039;WordPress/inserter-media-fetch&#039;,
 * 	 		},
 * 	 	} );
 * 	 	const jsonResponse = await response.json();
 * 	 	const results = jsonResponse.results;
 * 	 	return results.map( ( result ) =&gt; ( {
 * 	 		...result,
 * 	 		// If your response result includes an `id` prop that you want to access later, it should
 * 	 		// be mapped to `InserterMediaItem`&#039;s `sourceId` prop. This can be useful if you provide
 * 	 		// a report URL getter.
 * 	 		// Additionally you should always clear the `id` value of your response results because
 * 	 		// it is used to identify WordPress media items.
 * 	 		sourceId: result.id,
 * 	 		id: undefined,
 * 	 		caption: result.caption,
 * 	 		previewUrl: result.thumbnail,
 * 	 	} ) );
 * 	 },
 * 	 getReportUrl: ( { sourceId } ) =&gt;
 * 	 	`https://wordpress.org/openverse/image/${ sourceId }/report/`,
 * 	 isExternalResource: true,
 * } );
 * ```
 *
 * @typedef {Object} InserterMediaCategory Interface for inserter media category.
 * @property {string}                                                 name                           The name of the media category, that should be unique among all media categories.
 * @property {Object}                                                 labels                         Labels for the media category.
 * @property {string}                                                 labels.name                    General name of the media category. It&#039;s used in the inserter media items list.
 * @property {string}                                                 [labels.search_items=&#039;Search&#039;] Label for searching items. Default is ‘Search Posts’ / ‘Search Pages’.
 * @property {(&#039;image&#039;|&#039;audio&#039;|&#039;video&#039;)}                              mediaType                      The media type of the media category.
 * @property {(InserterMediaRequest) =&gt; Promise&lt;InserterMediaItem[]&gt;} fetch                          The function to fetch media items for the category.
 * @property {(InserterMediaItem) =&gt; string}                          [getReportUrl]                 If the media category supports reporting media items, this function should return
 *                                                                                                   the report url for the media item. It accepts the `InserterMediaItem` as an argument.
 * @property {boolean}                                                [isExternalResource]           If the media category is an external resource, this should be set to true.
 *                                                                                                   This is used to avoid making a request to the external resource when the user
 */
const registerInserterMediaCategory = category =&gt; ({
  select,
  dispatch
}) =&gt; {
  if (!category || typeof category !== &#039;object&#039;) {
    console.error(&#039;Category should be an `InserterMediaCategory` object.&#039;);
    return;
  }
  if (!category.name) {
    console.error(&#039;Category should have a `name` that should be unique among all media categories.&#039;);
    return;
  }
  if (!category.labels?.name) {
    console.error(&#039;Category should have a `labels.name`.&#039;);
    return;
  }
  if (![&#039;image&#039;, &#039;audio&#039;, &#039;video&#039;].includes(category.mediaType)) {
    console.error(&#039;Category should have `mediaType` property that is one of `image|audio|video`.&#039;);
    return;
  }
  if (!category.fetch || typeof category.fetch !== &#039;function&#039;) {
    console.error(&#039;Category should have a `fetch` function defined with the following signature `(InserterMediaRequest) =&gt; Promise&lt;InserterMediaItem[]&gt;`.&#039;);
    return;
  }
  const registeredInserterMediaCategories = select.getRegisteredInserterMediaCategories();
  if (registeredInserterMediaCategories.some(({
    name
  }) =&gt; name === category.name)) {
    console.error(`A category is already registered with the same name: &quot;${category.name}&quot;.`);
    return;
  }
  if (registeredInserterMediaCategories.some(({
    labels: {
      name
    } = {}
  }) =&gt; name === category.labels?.name)) {
    console.error(`A category is already registered with the same labels.name: &quot;${category.labels.name}&quot;.`);
    return;
  }
  // `inserterMediaCategories` is a private block editor setting, which means it cannot
  // be updated through the public `updateSettings` action. We preserve this setting as
  // private, so extenders can only add new inserter media categories and don&#039;t have any
  // control over the core media categories.
  dispatch({
    type: &#039;REGISTER_INSERTER_MEDIA_CATEGORY&#039;,
    category: {
      ...category,
      isExternalResource: true
    }
  });
};

/**
 * @typedef {import(&#039;../components/block-editing-mode&#039;).BlockEditingMode} BlockEditingMode
 */

/**
 * Sets the block editing mode for a given block.
 *
 * @see useBlockEditingMode
 *
 * @param {string}           clientId The block client ID, or `&#039;&#039;` for the root container.
 * @param {BlockEditingMode} mode     The block editing mode. One of `&#039;disabled&#039;`,
 *                                    `&#039;contentOnly&#039;`, or `&#039;default&#039;`.
 *
 * @return {Object} Action object.
 */
function setBlockEditingMode(clientId = &#039;&#039;, mode) {
  return {
    type: &#039;SET_BLOCK_EDITING_MODE&#039;,
    clientId,
    mode
  };
}

/**
 * Clears the block editing mode for a given block.
 *
 * @see useBlockEditingMode
 *
 * @param {string} clientId The block client ID, or `&#039;&#039;` for the root container.
 *
 * @return {Object} Action object.
 */
function unsetBlockEditingMode(clientId = &#039;&#039;) {
  return {
    type: &#039;UNSET_BLOCK_EDITING_MODE&#039;,
    clientId
  };
}

;// ./node_modules/@wordpress/block-editor/build-module/store/index.js
/**
 * WordPress dependencies
 */


/**
 * Internal dependencies
 */








/**
 * Block editor data store configuration.
 *
 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/data/README.md#registerStore
 */
const storeConfig = {
  reducer: reducer,
  selectors: selectors_namespaceObject,
  actions: actions_namespaceObject
};

/**
 * Store definition for the block editor namespace.
 *
 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/data/README.md#createReduxStore
 */
const store = (0,external_wp_data_namespaceObject.createReduxStore)(STORE_NAME, {
  ...storeConfig,
  persist: [&#039;preferences&#039;]
});

// We will be able to use the `register` function once we switch
// the &quot;preferences&quot; persistence to use the new preferences package.
const registeredStore = (0,external_wp_data_namespaceObject.registerStore)(STORE_NAME, {
  ...storeConfig,
  persist: [&#039;preferences&#039;]
});
unlock(registeredStore).registerPrivateActions(private_actions_namespaceObject);
unlock(registeredStore).registerPrivateSelectors(private_selectors_namespaceObject);

// TODO: Remove once we switch to the `register` function (see above).
//
// Until then, private functions also need to be attached to the original
// `store` descriptor in order to avoid unit tests failing, which could happen
// when tests create new registries in which they register stores.
//
// @see https://github.com/WordPress/gutenberg/pull/51145#discussion_r1239999590
unlock(store).registerPrivateActions(private_actions_namespaceObject);
unlock(store).registerPrivateSelectors(private_selectors_namespaceObject);

;// ./node_modules/@wordpress/block-editor/build-module/components/use-settings/index.js
/**
 * WordPress dependencies
 */



/**
 * Internal dependencies
 */




/**
 * Hook that retrieves the given settings for the block instance in use.
 *
 * It looks up the settings first in the block instance hierarchy.
 * If none are found, it&#039;ll look them up in the block editor settings.
 *
 * @param {string[]} paths The paths to the settings.
 * @return {any[]} Returns the values defined for the settings.
 * @example
 * ```js
 * const [ fixed, sticky ] = useSettings( &#039;position.fixed&#039;, &#039;position.sticky&#039; );
 * ```
 */
function use_settings_useSettings(...paths) {
  const {
    clientId = null
  } = useBlockEditContext();
  return (0,external_wp_data_namespaceObject.useSelect)(select =&gt; unlock(select(store)).getBlockSettings(clientId, ...paths), [clientId, ...paths]);
}

/**
 * Hook that retrieves the given setting for the block instance in use.
 *
 * It looks up the setting first in the block instance hierarchy.
 * If none is found, it&#039;ll look it up in the block editor settings.
 *
 * @deprecated 6.5.0 Use useSettings instead.
 *
 * @param {string} path The path to the setting.
 * @return {any} Returns the value defined for the setting.
 * @example
 * ```js
 * const isEnabled = useSetting( &#039;typography.dropCap&#039; );
 * ```
 */
function useSetting(path) {
  external_wp_deprecated_default()(&#039;wp.blockEditor.useSetting&#039;, {
    since: &#039;6.5&#039;,
    alternative: &#039;wp.blockEditor.useSettings&#039;,
    note: &#039;The new useSettings function can retrieve multiple settings at once, with better performance.&#039;
  });
  const [value] = use_settings_useSettings(path);
  return value;
}

;// external [&quot;wp&quot;,&quot;styleEngine&quot;]
const external_wp_styleEngine_namespaceObject = window[&quot;wp&quot;][&quot;styleEngine&quot;];
;// ./node_modules/@wordpress/block-editor/build-module/components/font-sizes/fluid-utils.js
/**
 * The fluid utilities must match the backend equivalent.
 * See: gutenberg_get_typography_font_size_value() in lib/block-supports/typography.php
 * ---------------------------------------------------------------
 */

// Defaults.
const DEFAULT_MAXIMUM_VIEWPORT_WIDTH = &#039;1600px&#039;;
const DEFAULT_MINIMUM_VIEWPORT_WIDTH = &#039;320px&#039;;
const DEFAULT_SCALE_FACTOR = 1;
const DEFAULT_MINIMUM_FONT_SIZE_FACTOR_MIN = 0.25;
const DEFAULT_MINIMUM_FONT_SIZE_FACTOR_MAX = 0.75;
const DEFAULT_MINIMUM_FONT_SIZE_LIMIT = &#039;14px&#039;;

/**
 * Computes a fluid font-size value that uses clamp(). A minimum and maximum
 * font size OR a single font size can be specified.
 *
 * If a single font size is specified, it is scaled up and down using a logarithmic scale.
 *
 * @example
 * ```js
 * // Calculate fluid font-size value from a minimum and maximum value.
 * const fontSize = getComputedFluidTypographyValue( {
 *     minimumFontSize: &#039;20px&#039;,
 *     maximumFontSize: &#039;45px&#039;
 * } );
 * // Calculate fluid font-size value from a single font size.
 * const fontSize = getComputedFluidTypographyValue( {
 *     fontSize: &#039;30px&#039;,
 * } );
 * ```
 *
 * @param {Object}        args
 * @param {?string}       args.minimumViewportWidth Minimum viewport size from which type will have fluidity. Optional if fontSize is specified.
 * @param {?string}       args.maximumViewportWidth Maximum size up to which type will have fluidity. Optional if fontSize is specified.
 * @param {string|number} [args.fontSize]           Size to derive maximumFontSize and minimumFontSize from, if necessary. Optional if minimumFontSize and maximumFontSize are specified.
 * @param {?string}       args.maximumFontSize      Maximum font size for any clamp() calculation. Optional.
 * @param {?string}       args.minimumFontSize      Minimum font size for any clamp() calculation. Optional.
 * @param {?number}       args.scaleFactor          A scale factor to determine how fast a font scales within boundaries. Optional.
 * @param {?string}       args.minimumFontSizeLimit The smallest a calculated font size may be. Optional.
 *
 * @return {string|null} A font-size value using clamp().
 */
function getComputedFluidTypographyValue({
  minimumFontSize,
  maximumFontSize,
  fontSize,
  minimumViewportWidth = DEFAULT_MINIMUM_VIEWPORT_WIDTH,
  maximumViewportWidth = DEFAULT_MAXIMUM_VIEWPORT_WIDTH,
  scaleFactor = DEFAULT_SCALE_FACTOR,
  minimumFontSizeLimit
}) {
  // Validate incoming settings and set defaults.
  minimumFontSizeLimit = !!getTypographyValueAndUnit(minimumFontSizeLimit) ? minimumFontSizeLimit : DEFAULT_MINIMUM_FONT_SIZE_LIMIT;

  /*
   * Calculates missing minimumFontSize and maximumFontSize from
   * defaultFontSize if provided.
   */
  if (fontSize) {
    // Parses default font size.
    const fontSizeParsed = getTypographyValueAndUnit(fontSize);

    // Protect against invalid units.
    if (!fontSizeParsed?.unit) {
      return null;
    }

    // Parses the minimum font size limit, so we can perform checks using it.
    const minimumFontSizeLimitParsed = getTypographyValueAndUnit(minimumFontSizeLimit, {
      coerceTo: fontSizeParsed.unit
    });

    // Don&#039;t enforce minimum font size if a font size has explicitly set a min and max value.
    if (!!minimumFontSizeLimitParsed?.value &amp;&amp; !minimumFontSize &amp;&amp; !maximumFontSize) {
      /*
       * If a minimum size was not passed to this function
       * and the user-defined font size is lower than $minimum_font_size_limit,
       * do not calculate a fluid value.
       */
      if (fontSizeParsed?.value &lt;= minimumFontSizeLimitParsed?.value) {
        return null;
      }
    }

    // If no fluid max font size is available use the incoming value.
    if (!maximumFontSize) {
      maximumFontSize = `${fontSizeParsed.value}${fontSizeParsed.unit}`;
    }

    /*
     * If no minimumFontSize is provided, create one using
     * the given font size multiplied by the min font size scale factor.
     */
    if (!minimumFontSize) {
      const fontSizeValueInPx = fontSizeParsed.unit === &#039;px&#039; ? fontSizeParsed.value : fontSizeParsed.value * 16;

      /*
       * The scale factor is a multiplier that affects how quickly the curve will move towards the minimum,
       * that is, how quickly the size factor reaches 0 given increasing font size values.
       * For a - b * log2(), lower values of b will make the curve move towards the minimum faster.
       * The scale factor is constrained between min and max values.
       */
      const minimumFontSizeFactor = Math.min(Math.max(1 - 0.075 * Math.log2(fontSizeValueInPx), DEFAULT_MINIMUM_FONT_SIZE_FACTOR_MIN), DEFAULT_MINIMUM_FONT_SIZE_FACTOR_MAX);

      // Calculates the minimum font size.
      const calculatedMinimumFontSize = roundToPrecision(fontSizeParsed.value * minimumFontSizeFactor, 3);

      // Only use calculated min font size if it&#039;s &gt; $minimum_font_size_limit value.
      if (!!minimumFontSizeLimitParsed?.value &amp;&amp; calculatedMinimumFontSize &lt; minimumFontSizeLimitParsed?.value) {
        minimumFontSize = `${minimumFontSizeLimitParsed.value}${minimumFontSizeLimitParsed.unit}`;
      } else {
        minimumFontSize = `${calculatedMinimumFontSize}${fontSizeParsed.unit}`;
      }
    }
  }

  // Grab the minimum font size and normalize it in order to use the value for calculations.
  const minimumFontSizeParsed = getTypographyValueAndUnit(minimumFontSize);

  // We get a &#039;preferred&#039; unit to keep units consistent when calculating,
  // otherwise the result will not be accurate.
  const fontSizeUnit = minimumFontSizeParsed?.unit || &#039;rem&#039;;

  // Grabs the maximum font size and normalize it in order to use the value for calculations.
  const maximumFontSizeParsed = getTypographyValueAndUnit(maximumFontSize, {
    coerceTo: fontSizeUnit
  });

  // Checks for mandatory min and max sizes, and protects against unsupported units.
  if (!minimumFontSizeParsed || !maximumFontSizeParsed) {
    return null;
  }

  // Uses rem for accessible fluid target font scaling.
  const minimumFontSizeRem = getTypographyValueAndUnit(minimumFontSize, {
    coerceTo: &#039;rem&#039;
  });

  // Viewport widths defined for fluid typography. Normalize units
  const maximumViewportWidthParsed = getTypographyValueAndUnit(maximumViewportWidth, {
    coerceTo: fontSizeUnit
  });
  const minimumViewportWidthParsed = getTypographyValueAndUnit(minimumViewportWidth, {
    coerceTo: fontSizeUnit
  });

  // Protect against unsupported units.
  if (!maximumViewportWidthParsed || !minimumViewportWidthParsed || !minimumFontSizeRem) {
    return null;
  }

  // Calculates the linear factor denominator. If it&#039;s 0, we cannot calculate a fluid value.
  const linearDenominator = maximumViewportWidthParsed.value - minimumViewportWidthParsed.value;
  if (!linearDenominator) {
    return null;
  }

  // Build CSS rule.
  // Borrowed from https://websemantics.uk/tools/responsive-font-calculator/.
  const minViewportWidthOffsetValue = roundToPrecision(minimumViewportWidthParsed.value / 100, 3);
  const viewportWidthOffset = roundToPrecision(minViewportWidthOffsetValue, 3) + fontSizeUnit;
  const linearFactor = 100 * ((maximumFontSizeParsed.value - minimumFontSizeParsed.value) / linearDenominator);
  const linearFactorScaled = roundToPrecision((linearFactor || 1) * scaleFactor, 3);
  const fluidTargetFontSize = `${minimumFontSizeRem.value}${minimumFontSizeRem.unit} + ((1vw - ${viewportWidthOffset}) * ${linearFactorScaled})`;
  return `clamp(${minimumFontSize}, ${fluidTargetFontSize}, ${maximumFontSize})`;
}

/**
 * Internal method that checks a string for a unit and value and returns an array consisting of `&#039;value&#039;` and `&#039;unit&#039;`, e.g., [ &#039;42&#039;, &#039;rem&#039; ].
 * A raw font size of `value + unit` is expected. If the value is an integer, it will convert to `value + &#039;px&#039;`.
 *
 * @param {string|number}    rawValue Raw size value from theme.json.
 * @param {Object|undefined} options  Calculation options.
 *
 * @return {{ unit: string, value: number }|null} An object consisting of `&#039;value&#039;` and `&#039;unit&#039;` properties.
 */
function getTypographyValueAndUnit(rawValue, options = {}) {
  if (typeof rawValue !== &#039;string&#039; &amp;&amp; typeof rawValue !== &#039;number&#039;) {
    return null;
  }

  // Converts numeric values to pixel values by default.
  if (isFinite(rawValue)) {
    rawValue = `${rawValue}px`;
  }
  const {
    coerceTo,
    rootSizeValue,
    acceptableUnits
  } = {
    coerceTo: &#039;&#039;,
    // Default browser font size. Later we could inject some JS to compute this `getComputedStyle( document.querySelector( &quot;html&quot; ) ).fontSize`.
    rootSizeValue: 16,
    acceptableUnits: [&#039;rem&#039;, &#039;px&#039;, &#039;em&#039;],
    ...options
  };
  const acceptableUnitsGroup = acceptableUnits?.join(&#039;|&#039;);
  const regexUnits = new RegExp(`^(\\d*\\.?\\d+)(${acceptableUnitsGroup}){1,1}$`);
  const matches = rawValue.match(regexUnits);

  // We need a number value and a unit.
  if (!matches || matches.length &lt; 3) {
    return null;
  }
  let [, value, unit] = matches;
  let returnValue = parseFloat(value);
  if (&#039;px&#039; === coerceTo &amp;&amp; (&#039;em&#039; === unit || &#039;rem&#039; === unit)) {
    returnValue = returnValue * rootSizeValue;
    unit = coerceTo;
  }
  if (&#039;px&#039; === unit &amp;&amp; (&#039;em&#039; === coerceTo || &#039;rem&#039; === coerceTo)) {
    returnValue = returnValue / rootSizeValue;
    unit = coerceTo;
  }

  /*
   * No calculation is required if swapping between em and rem yet,
   * since we assume a root size value. Later we might like to differentiate between
   * :root font size (rem) and parent element font size (em) relativity.
   */
  if ((&#039;em&#039; === coerceTo || &#039;rem&#039; === coerceTo) &amp;&amp; (&#039;em&#039; === unit || &#039;rem&#039; === unit)) {
    unit = coerceTo;
  }
  return {
    value: roundToPrecision(returnValue, 3),
    unit
  };
}

/**
 * Returns a value rounded to defined precision.
 * Returns `undefined` if the value is not a valid finite number.
 *
 * @param {number} value  Raw value.
 * @param {number} digits The number of digits to appear after the decimal point
 *
 * @return {number|undefined} Value rounded to standard precision.
 */
function roundToPrecision(value, digits = 3) {
  const base = Math.pow(10, digits);
  return Number.isFinite(value) ? parseFloat(Math.round(value * base) / base) : undefined;
}

;// ./node_modules/@wordpress/block-editor/build-module/utils/format-font-style.js
/**
 * WordPress dependencies
 */


/**
 * Formats font styles to human readable names.
 *
 * @param {string} fontStyle font style string
 * @return {Object} new object with formatted font style
 */
function formatFontStyle(fontStyle) {
  if (!fontStyle) {
    return {};
  }
  if (typeof fontStyle === &#039;object&#039;) {
    return fontStyle;
  }
  let name;
  switch (fontStyle) {
    case &#039;normal&#039;:
      name = (0,external_wp_i18n_namespaceObject._x)(&#039;Regular&#039;, &#039;font style&#039;);
      break;
    case &#039;italic&#039;:
      name = (0,external_wp_i18n_namespaceObject._x)(&#039;Italic&#039;, &#039;font style&#039;);
      break;
    case &#039;oblique&#039;:
      name = (0,external_wp_i18n_namespaceObject._x)(&#039;Oblique&#039;, &#039;font style&#039;);
      break;
    default:
      name = fontStyle;
      break;
  }
  return {
    name,
    value: fontStyle
  };
}

;// ./node_modules/@wordpress/block-editor/build-module/utils/format-font-weight.js
/**
 * WordPress dependencies
 */


/**
 * Formats font weights to human readable names.
 *
 * @param {string} fontWeight font weight string
 * @return {Object} new object with formatted font weight
 */
function formatFontWeight(fontWeight) {
  if (!fontWeight) {
    return {};
  }
  if (typeof fontWeight === &#039;object&#039;) {
    return fontWeight;
  }
  let name;
  switch (fontWeight) {
    case &#039;normal&#039;:
    case &#039;400&#039;:
      name = (0,external_wp_i18n_namespaceObject._x)(&#039;Regular&#039;, &#039;font weight&#039;);
      break;
    case &#039;bold&#039;:
    case &#039;700&#039;:
      name = (0,external_wp_i18n_namespaceObject._x)(&#039;Bold&#039;, &#039;font weight&#039;);
      break;
    case &#039;100&#039;:
      name = (0,external_wp_i18n_namespaceObject._x)(&#039;Thin&#039;, &#039;font weight&#039;);
      break;
    case &#039;200&#039;:
      name = (0,external_wp_i18n_namespaceObject._x)(&#039;Extra Light&#039;, &#039;font weight&#039;);
      break;
    case &#039;300&#039;:
      name = (0,external_wp_i18n_namespaceObject._x)(&#039;Light&#039;, &#039;font weight&#039;);
      break;
    case &#039;500&#039;:
      name = (0,external_wp_i18n_namespaceObject._x)(&#039;Medium&#039;, &#039;font weight&#039;);
      break;
    case &#039;600&#039;:
      name = (0,external_wp_i18n_namespaceObject._x)(&#039;Semi Bold&#039;, &#039;font weight&#039;);
      break;
    case &#039;800&#039;:
      name = (0,external_wp_i18n_namespaceObject._x)(&#039;Extra Bold&#039;, &#039;font weight&#039;);
      break;
    case &#039;900&#039;:
      name = (0,external_wp_i18n_namespaceObject._x)(&#039;Black&#039;, &#039;font weight&#039;);
      break;
    case &#039;1000&#039;:
      name = (0,external_wp_i18n_namespaceObject._x)(&#039;Extra Black&#039;, &#039;font weight&#039;);
      break;
    default:
      name = fontWeight;
      break;
  }
  return {
    name,
    value: fontWeight
  };
}

;// ./node_modules/@wordpress/block-editor/build-module/utils/get-font-styles-and-weights.js
/**
 * WordPress dependencies
 */


/**
 * Internal dependencies
 */


const FONT_STYLES = [{
  name: (0,external_wp_i18n_namespaceObject._x)(&#039;Regular&#039;, &#039;font style&#039;),
  value: &#039;normal&#039;
}, {
  name: (0,external_wp_i18n_namespaceObject._x)(&#039;Italic&#039;, &#039;font style&#039;),
  value: &#039;italic&#039;
}];
const FONT_WEIGHTS = [{
  name: (0,external_wp_i18n_namespaceObject._x)(&#039;Thin&#039;, &#039;font weight&#039;),
  value: &#039;100&#039;
}, {
  name: (0,external_wp_i18n_namespaceObject._x)(&#039;Extra Light&#039;, &#039;font weight&#039;),
  value: &#039;200&#039;
}, {
  name: (0,external_wp_i18n_namespaceObject._x)(&#039;Light&#039;, &#039;font weight&#039;),
  value: &#039;300&#039;
}, {
  name: (0,external_wp_i18n_namespaceObject._x)(&#039;Regular&#039;, &#039;font weight&#039;),
  value: &#039;400&#039;
}, {
  name: (0,external_wp_i18n_namespaceObject._x)(&#039;Medium&#039;, &#039;font weight&#039;),
  value: &#039;500&#039;
}, {
  name: (0,external_wp_i18n_namespaceObject._x)(&#039;Semi Bold&#039;, &#039;font weight&#039;),
  value: &#039;600&#039;
}, {
  name: (0,external_wp_i18n_namespaceObject._x)(&#039;Bold&#039;, &#039;font weight&#039;),
  value: &#039;700&#039;
}, {
  name: (0,external_wp_i18n_namespaceObject._x)(&#039;Extra Bold&#039;, &#039;font weight&#039;),
  value: &#039;800&#039;
}, {
  name: (0,external_wp_i18n_namespaceObject._x)(&#039;Black&#039;, &#039;font weight&#039;),
  value: &#039;900&#039;
}, {
  name: (0,external_wp_i18n_namespaceObject._x)(&#039;Extra Black&#039;, &#039;font weight&#039;),
  value: &#039;1000&#039;
}];

/**
 * Builds a list of font style and weight options based on font family faces.
 * Defaults to the standard font styles and weights if no font family faces are provided.
 *
 * @param {Array} fontFamilyFaces font family faces array
 * @return {Object} new object with combined and separated font style and weight properties
 */
function getFontStylesAndWeights(fontFamilyFaces) {
  let fontStyles = [];
  let fontWeights = [];
  const combinedStyleAndWeightOptions = [];
  const isSystemFont = !fontFamilyFaces || fontFamilyFaces?.length === 0;
  let isVariableFont = false;
  fontFamilyFaces?.forEach(face =&gt; {
    // Check for variable font by looking for a space in the font weight value. e.g. &quot;100 900&quot;
    if (&#039;string&#039; === typeof face.fontWeight &amp;&amp; /\s/.test(face.fontWeight.trim())) {
      isVariableFont = true;

      // Find font weight start and end values.
      let [startValue, endValue] = face.fontWeight.split(&#039; &#039;);
      startValue = parseInt(startValue.slice(0, 1));
      if (endValue === &#039;1000&#039;) {
        endValue = 10;
      } else {
        endValue = parseInt(endValue.slice(0, 1));
      }

      // Create font weight options for available variable weights.
      for (let i = startValue; i &lt;= endValue; i++) {
        const fontWeightValue = `${i.toString()}00`;
        if (!fontWeights.some(weight =&gt; weight.value === fontWeightValue)) {
          fontWeights.push(formatFontWeight(fontWeightValue));
        }
      }
    }

    // Format font style and weight values.
    const fontWeight = formatFontWeight(&#039;number&#039; === typeof face.fontWeight ? face.fontWeight.toString() : face.fontWeight);
    const fontStyle = formatFontStyle(face.fontStyle);

    // Create font style and font weight lists without duplicates.
    if (fontStyle &amp;&amp; Object.keys(fontStyle).length) {
      if (!fontStyles.some(style =&gt; style.value === fontStyle.value)) {
        fontStyles.push(fontStyle);
      }
    }
    if (fontWeight &amp;&amp; Object.keys(fontWeight).length) {
      if (!fontWeights.some(weight =&gt; weight.value === fontWeight.value)) {
        if (!isVariableFont) {
          fontWeights.push(fontWeight);
        }
      }
    }
  });

  // If there is no font weight of 600 or above, then include faux bold as an option.
  if (!fontWeights.some(weight =&gt; weight.value &gt;= &#039;600&#039;)) {
    fontWeights.push({
      name: (0,external_wp_i18n_namespaceObject._x)(&#039;Bold&#039;, &#039;font weight&#039;),
      value: &#039;700&#039;
    });
  }

  // If there is no italic font style, then include faux italic as an option.
  if (!fontStyles.some(style =&gt; style.value === &#039;italic&#039;)) {
    fontStyles.push({
      name: (0,external_wp_i18n_namespaceObject._x)(&#039;Italic&#039;, &#039;font style&#039;),
      value: &#039;italic&#039;
    });
  }

  // Use default font styles and weights for system fonts.
  if (isSystemFont) {
    fontStyles = FONT_STYLES;
    fontWeights = FONT_WEIGHTS;
  }

  // Use default styles and weights if there are no available styles or weights from the provided font faces.
  fontStyles = fontStyles.length === 0 ? FONT_STYLES : fontStyles;
  fontWeights = fontWeights.length === 0 ? FONT_WEIGHTS : fontWeights;

  // Generate combined font style and weight options for available fonts.
  fontStyles.forEach(({
    name: styleName,
    value: styleValue
  }) =&gt; {
    fontWeights.forEach(({
      name: weightName,
      value: weightValue
    }) =&gt; {
      const optionName = styleValue === &#039;normal&#039; ? weightName : (0,external_wp_i18n_namespaceObject.sprintf)(/* translators: 1: Font weight name. 2: Font style name. */
      (0,external_wp_i18n_namespaceObject._x)(&#039;%1$s %2$s&#039;, &#039;font&#039;), weightName, styleName);
      combinedStyleAndWeightOptions.push({
        key: `${styleValue}-${weightValue}`,
        name: optionName,
        style: {
          fontStyle: styleValue,
          fontWeight: weightValue
        }
      });
    });
  });
  return {
    fontStyles,
    fontWeights,
    combinedStyleAndWeightOptions,
    isSystemFont,
    isVariableFont
  };
}

;// ./node_modules/@wordpress/block-editor/build-module/components/global-styles/typography-utils.js
/**
 * The fluid utilities must match the backend equivalent.
 * See: gutenberg_get_typography_font_size_value() in lib/block-supports/typography.php
 * ---------------------------------------------------------------
 */

/**
 * Internal dependencies
 */



/**
 * @typedef {Object} FluidPreset
 * @property {string|undefined}  max A maximum font size value.
 * @property {?string|undefined} min A minimum font size value.
 */

/**
 * @typedef {Object} Preset
 * @property {?string|?number}               size  A default font size.
 * @property {string}                        name  A font size name, displayed in the UI.
 * @property {string}                        slug  A font size slug
 * @property {boolean|FluidPreset|undefined} fluid Specifies the minimum and maximum font size value of a fluid font size.
 */

/**
 * @typedef {Object} TypographySettings
 * @property {?string} minViewportWidth  Minimum viewport size from which type will have fluidity. Optional if size is specified.
 * @property {?string} maxViewportWidth  Maximum size up to which type will have fluidity. Optional if size is specified.
 * @property {?number} scaleFactor       A scale factor to determine how fast a font scales within boundaries. Optional.
 * @property {?number} minFontSizeFactor How much to scale defaultFontSize by to derive minimumFontSize. Optional.
 * @property {?string} minFontSize       The smallest a calculated font size may be. Optional.
 */

/**
 * Returns a font-size value based on a given font-size preset.
 * Takes into account fluid typography parameters and attempts to return a css formula depending on available, valid values.
 *
 * The Core PHP equivalent is wp_get_typography_font_size_value().
 *
 * @param {Preset}                     preset
 * @param {Object}                     settings
 * @param {boolean|TypographySettings} settings.typography.fluid  Whether fluid typography is enabled, and, optionally, fluid font size options.
 * @param {?Object}                    settings.typography.layout Layout options.
 *
 * @return {string|*} A font-size value or the value of preset.size.
 */
function getTypographyFontSizeValue(preset, settings) {
  const {
    size: defaultSize
  } = preset;

  /*
   * Catch falsy values and 0/&#039;0&#039;. Fluid calculations cannot be performed on `0`.
   * Also return early when a preset font size explicitly disables fluid typography with `false`.
   */
  if (!defaultSize || &#039;0&#039; === defaultSize || false === preset?.fluid) {
    return defaultSize;
  }

  /*
   * Return early when fluid typography is disabled in the settings, and there
   * are no local settings to enable it for the individual preset.
   *
   * If this condition isn&#039;t met, either the settings or individual preset settings
   * have enabled fluid typography.
   */
  if (!isFluidTypographyEnabled(settings?.typography) &amp;&amp; !isFluidTypographyEnabled(preset)) {
    return defaultSize;
  }
  let fluidTypographySettings = getFluidTypographyOptionsFromSettings(settings);
  fluidTypographySettings = typeof fluidTypographySettings?.fluid === &#039;object&#039; ? fluidTypographySettings?.fluid : {};
  const fluidFontSizeValue = getComputedFluidTypographyValue({
    minimumFontSize: preset?.fluid?.min,
    maximumFontSize: preset?.fluid?.max,
    fontSize: defaultSize,
    minimumFontSizeLimit: fluidTypographySettings?.minFontSize,
    maximumViewportWidth: fluidTypographySettings?.maxViewportWidth,
    minimumViewportWidth: fluidTypographySettings?.minViewportWidth
  });
  if (!!fluidFontSizeValue) {
    return fluidFontSizeValue;
  }
  return defaultSize;
}
function isFluidTypographyEnabled(typographySettings) {
  const fluidSettings = typographySettings?.fluid;
  return true === fluidSettings || fluidSettings &amp;&amp; typeof fluidSettings === &#039;object&#039; &amp;&amp; Object.keys(fluidSettings).length &gt; 0;
}

/**
 * Returns fluid typography settings from theme.json setting object.
 *
 * @param {Object} settings            Theme.json settings
 * @param {Object} settings.typography Theme.json typography settings
 * @param {Object} settings.layout     Theme.json layout settings
 * @return {TypographySettings} Fluid typography settings
 */
function getFluidTypographyOptionsFromSettings(settings) {
  const typographySettings = settings?.typography;
  const layoutSettings = settings?.layout;
  const defaultMaxViewportWidth = getTypographyValueAndUnit(layoutSettings?.wideSize) ? layoutSettings?.wideSize : null;
  return isFluidTypographyEnabled(typographySettings) &amp;&amp; defaultMaxViewportWidth ? {
    fluid: {
      maxViewportWidth: defaultMaxViewportWidth,
      ...typographySettings.fluid
    }
  } : {
    fluid: typographySettings?.fluid
  };
}

/**
 * Returns an object of merged font families and the font faces from the selected font family
 * based on the theme.json settings object and the currently selected font family.
 *
 * @param {Object} settings           Theme.json settings.
 * @param {string} selectedFontFamily Decoded font family string.
 * @return {Object} Merged font families and font faces from the selected font family.
 */
function getMergedFontFamiliesAndFontFamilyFaces(settings, selectedFontFamily) {
  var _fontFamilies$find$fo;
  const fontFamiliesFromSettings = settings?.typography?.fontFamilies;
  const fontFamilies = [&#039;default&#039;, &#039;theme&#039;, &#039;custom&#039;].flatMap(key =&gt; {
    var _fontFamiliesFromSett;
    return (_fontFamiliesFromSett = fontFamiliesFromSettings?.[key]) !== null &amp;&amp; _fontFamiliesFromSett !== void 0 ? _fontFamiliesFromSett : [];
  });
  const fontFamilyFaces = (_fontFamilies$find$fo = fontFamilies.find(family =&gt; family.fontFamily === selectedFontFamily)?.fontFace) !== null &amp;&amp; _fontFamilies$find$fo !== void 0 ? _fontFamilies$find$fo : [];
  return {
    fontFamilies,
    fontFamilyFaces
  };
}

/**
 * Returns the nearest font weight value from the available font weight list based on the new font weight.
 * The nearest font weight is the one with the smallest difference from the new font weight.
 *
 * @param {Array}  availableFontWeights Array of available font weights.
 * @param {string} newFontWeightValue   New font weight value.
 * @return {string} Nearest font weight.
 */
function findNearestFontWeight(availableFontWeights, newFontWeightValue) {
  newFontWeightValue = &#039;number&#039; === typeof newFontWeightValue ? newFontWeightValue.toString() : newFontWeightValue;
  if (!newFontWeightValue || typeof newFontWeightValue !== &#039;string&#039;) {
    return &#039;&#039;;
  }
  if (!availableFontWeights || availableFontWeights.length === 0) {
    return newFontWeightValue;
  }
  const nearestFontWeight = availableFontWeights?.reduce((nearest, {
    value: fw
  }) =&gt; {
    const currentDiff = Math.abs(parseInt(fw) - parseInt(newFontWeightValue));
    const nearestDiff = Math.abs(parseInt(nearest) - parseInt(newFontWeightValue));
    return currentDiff &lt; nearestDiff ? fw : nearest;
  }, availableFontWeights[0]?.value);
  return nearestFontWeight;
}

/**
 * Returns the nearest font style based on the new font style.
 * Defaults to an empty string if the new font style is not valid or available.
 *
 * @param {Array}  availableFontStyles Array of available font weights.
 * @param {string} newFontStyleValue   New font style value.
 * @return {string} Nearest font style or an empty string.
 */
function findNearestFontStyle(availableFontStyles, newFontStyleValue) {
  if (typeof newFontStyleValue !== &#039;string&#039; || !newFontStyleValue) {
    return &#039;&#039;;
  }
  const validStyles = [&#039;normal&#039;, &#039;italic&#039;, &#039;oblique&#039;];
  if (!validStyles.includes(newFontStyleValue)) {
    return &#039;&#039;;
  }
  if (!availableFontStyles || availableFontStyles.length === 0 || availableFontStyles.find(style =&gt; style.value === newFontStyleValue)) {
    return newFontStyleValue;
  }
  if (newFontStyleValue === &#039;oblique&#039; &amp;&amp; !availableFontStyles.find(style =&gt; style.value === &#039;oblique&#039;)) {
    return &#039;italic&#039;;
  }
  return &#039;&#039;;
}

/**
 * Returns the nearest font style and weight based on the available font family faces and the new font style and weight.
 *
 * @param {Array}  fontFamilyFaces Array of available font family faces.
 * @param {string} fontStyle       New font style. Defaults to previous value.
 * @param {string} fontWeight      New font weight. Defaults to previous value.
 * @return {Object} Nearest font style and font weight.
 */
function findNearestStyleAndWeight(fontFamilyFaces, fontStyle, fontWeight) {
  let nearestFontStyle = fontStyle;
  let nearestFontWeight = fontWeight;
  const {
    fontStyles,
    fontWeights,
    combinedStyleAndWeightOptions
  } = getFontStylesAndWeights(fontFamilyFaces);

  // Check if the new font style and weight are available in the font family faces.
  const hasFontStyle = fontStyles?.some(({
    value: fs
  }) =&gt; fs === fontStyle);
  const hasFontWeight = fontWeights?.some(({
    value: fw
  }) =&gt; fw?.toString() === fontWeight?.toString());
  if (!hasFontStyle) {
    /*
     * Default to italic if oblique is not available.
     * Or find the nearest font style based on the nearest font weight.
     */
    nearestFontStyle = fontStyle ? findNearestFontStyle(fontStyles, fontStyle) : combinedStyleAndWeightOptions?.find(option =&gt; option.style.fontWeight === findNearestFontWeight(fontWeights, fontWeight))?.style?.fontStyle;
  }
  if (!hasFontWeight) {
    /*
     * Find the nearest font weight based on available weights.
     * Or find the nearest font weight based on the nearest font style.
     */
    nearestFontWeight = fontWeight ? findNearestFontWeight(fontWeights, fontWeight) : combinedStyleAndWeightOptions?.find(option =&gt; option.style.fontStyle === (nearestFontStyle || fontStyle))?.style?.fontWeight;
  }
  return {
    nearestFontStyle,
    nearestFontWeight
  };
}

;// ./node_modules/@wordpress/block-editor/build-module/components/global-styles/utils.js
/**
 * External dependencies
 */


/**
 * WordPress dependencies
 */



/**
 * Internal dependencies
 */



/* Supporting data. */
const ROOT_BLOCK_SELECTOR = &#039;body&#039;;
const ROOT_CSS_PROPERTIES_SELECTOR = &#039;:root&#039;;
const PRESET_METADATA = [{
  path: [&#039;color&#039;, &#039;palette&#039;],
  valueKey: &#039;color&#039;,
  cssVarInfix: &#039;color&#039;,
  classes: [{
    classSuffix: &#039;color&#039;,
    propertyName: &#039;color&#039;
  }, {
    classSuffix: &#039;background-color&#039;,
    propertyName: &#039;background-color&#039;
  }, {
    classSuffix: &#039;border-color&#039;,
    propertyName: &#039;border-color&#039;
  }]
}, {
  path: [&#039;color&#039;, &#039;gradients&#039;],
  valueKey: &#039;gradient&#039;,
  cssVarInfix: &#039;gradient&#039;,
  classes: [{
    classSuffix: &#039;gradient-background&#039;,
    propertyName: &#039;background&#039;
  }]
}, {
  path: [&#039;color&#039;, &#039;duotone&#039;],
  valueKey: &#039;colors&#039;,
  cssVarInfix: &#039;duotone&#039;,
  valueFunc: ({
    slug
  }) =&gt; `url( &#039;#wp-duotone-${slug}&#039; )`,
  classes: []
}, {
  path: [&#039;shadow&#039;, &#039;presets&#039;],
  valueKey: &#039;shadow&#039;,
  cssVarInfix: &#039;shadow&#039;,
  classes: []
}, {
  path: [&#039;typography&#039;, &#039;fontSizes&#039;],
  valueFunc: (preset, settings) =&gt; getTypographyFontSizeValue(preset, settings),
  valueKey: &#039;size&#039;,
  cssVarInfix: &#039;font-size&#039;,
  classes: [{
    classSuffix: &#039;font-size&#039;,
    propertyName: &#039;font-size&#039;
  }]
}, {
  path: [&#039;typography&#039;, &#039;fontFamilies&#039;],
  valueKey: &#039;fontFamily&#039;,
  cssVarInfix: &#039;font-family&#039;,
  classes: [{
    classSuffix: &#039;font-family&#039;,
    propertyName: &#039;font-family&#039;
  }]
}, {
  path: [&#039;spacing&#039;, &#039;spacingSizes&#039;],
  valueKey: &#039;size&#039;,
  cssVarInfix: &#039;spacing&#039;,
  valueFunc: ({
    size
  }) =&gt; size,
  classes: []
}];
const STYLE_PATH_TO_CSS_VAR_INFIX = {
  &#039;color.background&#039;: &#039;color&#039;,
  &#039;color.text&#039;: &#039;color&#039;,
  &#039;filter.duotone&#039;: &#039;duotone&#039;,
  &#039;elements.link.color.text&#039;: &#039;color&#039;,
  &#039;elements.link.:hover.color.text&#039;: &#039;color&#039;,
  &#039;elements.link.typography.fontFamily&#039;: &#039;font-family&#039;,
  &#039;elements.link.typography.fontSize&#039;: &#039;font-size&#039;,
  &#039;elements.button.color.text&#039;: &#039;color&#039;,
  &#039;elements.button.color.background&#039;: &#039;color&#039;,
  &#039;elements.caption.color.text&#039;: &#039;color&#039;,
  &#039;elements.button.typography.fontFamily&#039;: &#039;font-family&#039;,
  &#039;elements.button.typography.fontSize&#039;: &#039;font-size&#039;,
  &#039;elements.heading.color&#039;: &#039;color&#039;,
  &#039;elements.heading.color.background&#039;: &#039;color&#039;,
  &#039;elements.heading.typography.fontFamily&#039;: &#039;font-family&#039;,
  &#039;elements.heading.gradient&#039;: &#039;gradient&#039;,
  &#039;elements.heading.color.gradient&#039;: &#039;gradient&#039;,
  &#039;elements.h1.color&#039;: &#039;color&#039;,
  &#039;elements.h1.color.background&#039;: &#039;color&#039;,
  &#039;elements.h1.typography.fontFamily&#039;: &#039;font-family&#039;,
  &#039;elements.h1.color.gradient&#039;: &#039;gradient&#039;,
  &#039;elements.h2.color&#039;: &#039;color&#039;,
  &#039;elements.h2.color.background&#039;: &#039;color&#039;,
  &#039;elements.h2.typography.fontFamily&#039;: &#039;font-family&#039;,
  &#039;elements.h2.color.gradient&#039;: &#039;gradient&#039;,
  &#039;elements.h3.color&#039;: &#039;color&#039;,
  &#039;elements.h3.color.background&#039;: &#039;color&#039;,
  &#039;elements.h3.typography.fontFamily&#039;: &#039;font-family&#039;,
  &#039;elements.h3.color.gradient&#039;: &#039;gradient&#039;,
  &#039;elements.h4.color&#039;: &#039;color&#039;,
  &#039;elements.h4.color.background&#039;: &#039;color&#039;,
  &#039;elements.h4.typography.fontFamily&#039;: &#039;font-family&#039;,
  &#039;elements.h4.color.gradient&#039;: &#039;gradient&#039;,
  &#039;elements.h5.color&#039;: &#039;color&#039;,
  &#039;elements.h5.color.background&#039;: &#039;color&#039;,
  &#039;elements.h5.typography.fontFamily&#039;: &#039;font-family&#039;,
  &#039;elements.h5.color.gradient&#039;: &#039;gradient&#039;,
  &#039;elements.h6.color&#039;: &#039;color&#039;,
  &#039;elements.h6.color.background&#039;: &#039;color&#039;,
  &#039;elements.h6.typography.fontFamily&#039;: &#039;font-family&#039;,
  &#039;elements.h6.color.gradient&#039;: &#039;gradient&#039;,
  &#039;color.gradient&#039;: &#039;gradient&#039;,
  shadow: &#039;shadow&#039;,
  &#039;typography.fontSize&#039;: &#039;font-size&#039;,
  &#039;typography.fontFamily&#039;: &#039;font-family&#039;
};

// A static list of block attributes that store global style preset slugs.
const STYLE_PATH_TO_PRESET_BLOCK_ATTRIBUTE = {
  &#039;color.background&#039;: &#039;backgroundColor&#039;,
  &#039;color.text&#039;: &#039;textColor&#039;,
  &#039;color.gradient&#039;: &#039;gradient&#039;,
  &#039;typography.fontSize&#039;: &#039;fontSize&#039;,
  &#039;typography.fontFamily&#039;: &#039;fontFamily&#039;
};
function useToolsPanelDropdownMenuProps() {
  const isMobile = (0,external_wp_compose_namespaceObject.useViewportMatch)(&#039;medium&#039;, &#039;&lt;&#039;);
  return !isMobile ? {
    popoverProps: {
      placement: &#039;left-start&#039;,
      // For non-mobile, inner sidebar width (248px) - button width (24px) - border (1px) + padding (16px) + spacing (20px)
      offset: 259
    }
  } : {};
}
function findInPresetsBy(features, blockName, presetPath, presetProperty, presetValueValue) {
  // Block presets take priority above root level presets.
  const orderedPresetsByOrigin = [getValueFromObjectPath(features, [&#039;blocks&#039;, blockName, ...presetPath]), getValueFromObjectPath(features, presetPath)];
  for (const presetByOrigin of orderedPresetsByOrigin) {
    if (presetByOrigin) {
      // Preset origins ordered by priority.
      const origins = [&#039;custom&#039;, &#039;theme&#039;, &#039;default&#039;];
      for (const origin of origins) {
        const presets = presetByOrigin[origin];
        if (presets) {
          const presetObject = presets.find(preset =&gt; preset[presetProperty] === presetValueValue);
          if (presetObject) {
            if (presetProperty === &#039;slug&#039;) {
              return presetObject;
            }
            // If there is a highest priority preset with the same slug but different value the preset we found was overwritten and should be ignored.
            const highestPresetObjectWithSameSlug = findInPresetsBy(features, blockName, presetPath, &#039;slug&#039;, presetObject.slug);
            if (highestPresetObjectWithSameSlug[presetProperty] === presetObject[presetProperty]) {
              return presetObject;
            }
            return undefined;
          }
        }
      }
    }
  }
}
function getPresetVariableFromValue(features, blockName, variableStylePath, presetPropertyValue) {
  if (!presetPropertyValue) {
    return presetPropertyValue;
  }
  const cssVarInfix = STYLE_PATH_TO_CSS_VAR_INFIX[variableStylePath];
  const metadata = PRESET_METADATA.find(data =&gt; data.cssVarInfix === cssVarInfix);
  if (!metadata) {
    // The property doesn&#039;t have preset data
    // so the value should be returned as it is.
    return presetPropertyValue;
  }
  const {
    valueKey,
    path
  } = metadata;
  const presetObject = findInPresetsBy(features, blockName, path, valueKey, presetPropertyValue);
  if (!presetObject) {
    // Value wasn&#039;t found in the presets,
    // so it must be a custom value.
    return presetPropertyValue;
  }
  return `var:preset|${cssVarInfix}|${presetObject.slug}`;
}
function getValueFromPresetVariable(features, blockName, variable, [presetType, slug]) {
  const metadata = PRESET_METADATA.find(data =&gt; data.cssVarInfix === presetType);
  if (!metadata) {
    return variable;
  }
  const presetObject = findInPresetsBy(features.settings, blockName, metadata.path, &#039;slug&#039;, slug);
  if (presetObject) {
    const {
      valueKey
    } = metadata;
    const result = presetObject[valueKey];
    return getValueFromVariable(features, blockName, result);
  }
  return variable;
}
function getValueFromCustomVariable(features, blockName, variable, path) {
  var _getValueFromObjectPa;
  const result = (_getValueFromObjectPa = getValueFromObjectPath(features.settings, [&#039;blocks&#039;, blockName, &#039;custom&#039;, ...path])) !== null &amp;&amp; _getValueFromObjectPa !== void 0 ? _getValueFromObjectPa : getValueFromObjectPath(features.settings, [&#039;custom&#039;, ...path]);
  if (!result) {
    return variable;
  }
  // A variable may reference another variable so we need recursion until we find the value.
  return getValueFromVariable(features, blockName, result);
}

/**
 * Attempts to fetch the value of a theme.json CSS variable.
 *
 * @param {Object}   features  GlobalStylesContext config, e.g., user, base or merged. Represents the theme.json tree.
 * @param {string}   blockName The name of a block as represented in the styles property. E.g., &#039;root&#039; for root-level, and &#039;core/${blockName}&#039; for blocks.
 * @param {string|*} variable  An incoming style value. A CSS var value is expected, but it could be any value.
 * @return {string|*|{ref}} The value of the CSS var, if found. If not found, the passed variable argument.
 */
function getValueFromVariable(features, blockName, variable) {
  if (!variable || typeof variable !== &#039;string&#039;) {
    if (typeof variable?.ref === &#039;string&#039;) {
      variable = getValueFromObjectPath(features, variable.ref);
      // Presence of another ref indicates a reference to another dynamic value.
      // Pointing to another dynamic value is not supported.
      if (!variable || !!variable?.ref) {
        return variable;
      }
    } else {
      return variable;
    }
  }
  const USER_VALUE_PREFIX = &#039;var:&#039;;
  const THEME_VALUE_PREFIX = &#039;var(--wp--&#039;;
  const THEME_VALUE_SUFFIX = &#039;)&#039;;
  let parsedVar;
  if (variable.startsWith(USER_VALUE_PREFIX)) {
    parsedVar = variable.slice(USER_VALUE_PREFIX.length).split(&#039;|&#039;);
  } else if (variable.startsWith(THEME_VALUE_PREFIX) &amp;&amp; variable.endsWith(THEME_VALUE_SUFFIX)) {
    parsedVar = variable.slice(THEME_VALUE_PREFIX.length, -THEME_VALUE_SUFFIX.length).split(&#039;--&#039;);
  } else {
    // We don&#039;t know how to parse the value: either is raw of uses complex CSS such as `calc(1px * var(--wp--variable) )`
    return variable;
  }
  const [type, ...path] = parsedVar;
  if (type === &#039;preset&#039;) {
    return getValueFromPresetVariable(features, blockName, variable, path);
  }
  if (type === &#039;custom&#039;) {
    return getValueFromCustomVariable(features, blockName, variable, path);
  }
  return variable;
}

/**
 * Function that scopes a selector with another one. This works a bit like
 * SCSS nesting except the `&amp;` operator isn&#039;t supported.
 *
 * @example
 * ```js
 * const scope = &#039;.a, .b .c&#039;;
 * const selector = &#039;&gt; .x, .y&#039;;
 * const merged = scopeSelector( scope, selector );
 * // merged is &#039;.a &gt; .x, .a .y, .b .c &gt; .x, .b .c .y&#039;
 * ```
 *
 * @param {string} scope    Selector to scope to.
 * @param {string} selector Original selector.
 *
 * @return {string} Scoped selector.
 */
function scopeSelector(scope, selector) {
  if (!scope || !selector) {
    return selector;
  }
  const scopes = scope.split(&#039;,&#039;);
  const selectors = selector.split(&#039;,&#039;);
  const selectorsScoped = [];
  scopes.forEach(outer =&gt; {
    selectors.forEach(inner =&gt; {
      selectorsScoped.push(`${outer.trim()} ${inner.trim()}`);
    });
  });
  return selectorsScoped.join(&#039;, &#039;);
}

/**
 * Scopes a collection of selectors for features and subfeatures.
 *
 * @example
 * ```js
 * const scope = &#039;.custom-scope&#039;;
 * const selectors = {
 *     color: &#039;.wp-my-block p&#039;,
 *     typography: { fontSize: &#039;.wp-my-block caption&#039; },
 * };
 * const result = scopeFeatureSelector( scope, selectors );
 * // result is {
 * //     color: &#039;.custom-scope .wp-my-block p&#039;,
 * //     typography: { fonSize: &#039;.custom-scope .wp-my-block caption&#039; },
 * // }
 * ```
 *
 * @param {string} scope     Selector to scope collection of selectors with.
 * @param {Object} selectors Collection of feature selectors e.g.
 *
 * @return {Object|undefined} Scoped collection of feature selectors.
 */
function scopeFeatureSelectors(scope, selectors) {
  if (!scope || !selectors) {
    return;
  }
  const featureSelectors = {};
  Object.entries(selectors).forEach(([feature, selector]) =&gt; {
    if (typeof selector === &#039;string&#039;) {
      featureSelectors[feature] = scopeSelector(scope, selector);
    }
    if (typeof selector === &#039;object&#039;) {
      featureSelectors[feature] = {};
      Object.entries(selector).forEach(([subfeature, subfeatureSelector]) =&gt; {
        featureSelectors[feature][subfeature] = scopeSelector(scope, subfeatureSelector);
      });
    }
  });
  return featureSelectors;
}

/**
 * Appends a sub-selector to an existing one.
 *
 * Given the compounded `selector` &quot;h1, h2, h3&quot;
 * and the `toAppend` selector &quot;.some-class&quot; the result will be
 * &quot;h1.some-class, h2.some-class, h3.some-class&quot;.
 *
 * @param {string} selector Original selector.
 * @param {string} toAppend Selector to append.
 *
 * @return {string} The new selector.
 */
function appendToSelector(selector, toAppend) {
  if (!selector.includes(&#039;,&#039;)) {
    return selector + toAppend;
  }
  const selectors = selector.split(&#039;,&#039;);
  const newSelectors = selectors.map(sel =&gt; sel + toAppend);
  return newSelectors.join(&#039;,&#039;);
}

/**
 * Compares global style variations according to their styles and settings properties.
 *
 * @example
 * ```js
 * const globalStyles = { styles: { typography: { fontSize: &#039;10px&#039; } }, settings: {} };
 * const variation = { styles: { typography: { fontSize: &#039;10000px&#039; } }, settings: {} };
 * const isEqual = areGlobalStyleConfigsEqual( globalStyles, variation );
 * // false
 * ```
 *
 * @param {Object} original  A global styles object.
 * @param {Object} variation A global styles object.
 *
 * @return {boolean} Whether `original` and `variation` match.
 */
function areGlobalStyleConfigsEqual(original, variation) {
  if (typeof original !== &#039;object&#039; || typeof variation !== &#039;object&#039;) {
    return original === variation;
  }
  return es6_default()(original?.styles, variation?.styles) &amp;&amp; es6_default()(original?.settings, variation?.settings);
}

/**
 * Generates the selector for a block style variation by creating the
 * appropriate CSS class and adding it to the ancestor portion of the block&#039;s
 * selector.
 *
 * For example, take the Button block which has a compound selector:
 * `.wp-block-button .wp-block-button__link`. With a variation named &#039;custom&#039;,
 * the class `.is-style-custom` should be added to the `.wp-block-button`
 * ancestor only.
 *
 * This function will take into account comma separated and complex selectors.
 *
 * @param {string} variation     Name for the variation.
 * @param {string} blockSelector CSS selector for the block.
 *
 * @return {string} CSS selector for the block style variation.
 */
function getBlockStyleVariationSelector(variation, blockSelector) {
  const variationClass = `.is-style-${variation}`;
  if (!blockSelector) {
    return variationClass;
  }
  const ancestorRegex = /((?::\([^)]+\))?\s*)([^\s:]+)/;
  const addVariationClass = (_match, group1, group2) =&gt; {
    return group1 + group2 + variationClass;
  };
  const result = blockSelector.split(&#039;,&#039;).map(part =&gt; part.replace(ancestorRegex, addVariationClass));
  return result.join(&#039;,&#039;);
}

/**
 * Looks up a theme file URI based on a relative path.
 *
 * @param {string}        file          A relative path.
 * @param {Array&lt;Object&gt;} themeFileURIs A collection of absolute theme file URIs and their corresponding file paths.
 * @return {string} A resolved theme file URI, if one is found in the themeFileURIs collection.
 */
function getResolvedThemeFilePath(file, themeFileURIs) {
  if (!file || !themeFileURIs || !Array.isArray(themeFileURIs)) {
    return file;
  }
  const uri = themeFileURIs.find(themeFileUri =&gt; themeFileUri?.name === file);
  if (!uri?.href) {
    return file;
  }
  return uri?.href;
}

/**
 * Resolves ref values in theme JSON.
 *
 * @param {Object|string} ruleValue A block style value that may contain a reference to a theme.json value.
 * @param {Object}        tree      A theme.json object.
 * @return {*} The resolved value or incoming ruleValue.
 */
function getResolvedRefValue(ruleValue, tree) {
  if (!ruleValue || !tree) {
    return ruleValue;
  }

  /*
   * Where the rule value is an object with a &#039;ref&#039; property pointing
   * to a path, this converts that path into the value at that path.
   * For example: { &quot;ref&quot;: &quot;style.color.background&quot; } =&gt; &quot;#fff&quot;.
   */
  if (typeof ruleValue !== &#039;string&#039; &amp;&amp; ruleValue?.ref) {
    const resolvedRuleValue = (0,external_wp_styleEngine_namespaceObject.getCSSValueFromRawStyle)(getValueFromObjectPath(tree, ruleValue.ref));

    /*
     * Presence of another ref indicates a reference to another dynamic value.
     * Pointing to another dynamic value is not supported.
     */
    if (resolvedRuleValue?.ref) {
      return undefined;
    }
    if (resolvedRuleValue === undefined) {
      return ruleValue;
    }
    return resolvedRuleValue;
  }
  return ruleValue;
}

/**
 * Resolves ref and relative path values in theme JSON.
 *
 * @param {Object|string} ruleValue A block style value that may contain a reference to a theme.json value.
 * @param {Object}        tree      A theme.json object.
 * @return {*} The resolved value or incoming ruleValue.
 */
function getResolvedValue(ruleValue, tree) {
  if (!ruleValue || !tree) {
    return ruleValue;
  }

  // Resolve ref values.
  const resolvedValue = getResolvedRefValue(ruleValue, tree);

  // Resolve relative paths.
  if (resolvedValue?.url) {
    resolvedValue.url = getResolvedThemeFilePath(resolvedValue.url, tree?._links?.[&#039;wp:theme-file&#039;]);
  }
  return resolvedValue;
}

;// ./node_modules/@wordpress/block-editor/build-module/components/global-styles/context.js
/**
 * WordPress dependencies
 */

const DEFAULT_GLOBAL_STYLES_CONTEXT = {
  user: {},
  base: {},
  merged: {},
  setUserConfig: () =&gt; {}
};
const GlobalStylesContext = (0,external_wp_element_namespaceObject.createContext)(DEFAULT_GLOBAL_STYLES_CONTEXT);

;// ./node_modules/@wordpress/block-editor/build-module/components/global-styles/hooks.js
/**
 * External dependencies
 */


/**
 * WordPress dependencies
 */





/**
 * Internal dependencies
 */




const EMPTY_CONFIG = {
  settings: {},
  styles: {}
};
const VALID_SETTINGS = [&#039;appearanceTools&#039;, &#039;useRootPaddingAwareAlignments&#039;, &#039;background.backgroundImage&#039;, &#039;background.backgroundRepeat&#039;, &#039;background.backgroundSize&#039;, &#039;background.backgroundPosition&#039;, &#039;border.color&#039;, &#039;border.radius&#039;, &#039;border.style&#039;, &#039;border.width&#039;, &#039;shadow.presets&#039;, &#039;shadow.defaultPresets&#039;, &#039;color.background&#039;, &#039;color.button&#039;, &#039;color.caption&#039;, &#039;color.custom&#039;, &#039;color.customDuotone&#039;, &#039;color.customGradient&#039;, &#039;color.defaultDuotone&#039;, &#039;color.defaultGradients&#039;, &#039;color.defaultPalette&#039;, &#039;color.duotone&#039;, &#039;color.gradients&#039;, &#039;color.heading&#039;, &#039;color.link&#039;, &#039;color.palette&#039;, &#039;color.text&#039;, &#039;custom&#039;, &#039;dimensions.aspectRatio&#039;, &#039;dimensions.minHeight&#039;, &#039;layout.contentSize&#039;, &#039;layout.definitions&#039;, &#039;layout.wideSize&#039;, &#039;lightbox.enabled&#039;, &#039;lightbox.allowEditing&#039;, &#039;position.fixed&#039;, &#039;position.sticky&#039;, &#039;spacing.customSpacingSize&#039;, &#039;spacing.defaultSpacingSizes&#039;, &#039;spacing.spacingSizes&#039;, &#039;spacing.spacingScale&#039;, &#039;spacing.blockGap&#039;, &#039;spacing.margin&#039;, &#039;spacing.padding&#039;, &#039;spacing.units&#039;, &#039;typography.fluid&#039;, &#039;typography.customFontSize&#039;, &#039;typography.defaultFontSizes&#039;, &#039;typography.dropCap&#039;, &#039;typography.fontFamilies&#039;, &#039;typography.fontSizes&#039;, &#039;typography.fontStyle&#039;, &#039;typography.fontWeight&#039;, &#039;typography.letterSpacing&#039;, &#039;typography.lineHeight&#039;, &#039;typography.textAlign&#039;, &#039;typography.textColumns&#039;, &#039;typography.textDecoration&#039;, &#039;typography.textTransform&#039;, &#039;typography.writingMode&#039;];
const useGlobalStylesReset = () =&gt; {
  const {
    user,
    setUserConfig
  } = (0,external_wp_element_namespaceObject.useContext)(GlobalStylesContext);
  const config = {
    settings: user.settings,
    styles: user.styles
  };
  const canReset = !!config &amp;&amp; !es6_default()(config, EMPTY_CONFIG);
  return [canReset, (0,external_wp_element_namespaceObject.useCallback)(() =&gt; setUserConfig(EMPTY_CONFIG), [setUserConfig])];
};
function useGlobalSetting(propertyPath, blockName, source = &#039;all&#039;) {
  const {
    setUserConfig,
    ...configs
  } = (0,external_wp_element_namespaceObject.useContext)(GlobalStylesContext);
  const appendedBlockPath = blockName ? &#039;.blocks.&#039; + blockName : &#039;&#039;;
  const appendedPropertyPath = propertyPath ? &#039;.&#039; + propertyPath : &#039;&#039;;
  const contextualPath = `settings${appendedBlockPath}${appendedPropertyPath}`;
  const globalPath = `settings${appendedPropertyPath}`;
  const sourceKey = source === &#039;all&#039; ? &#039;merged&#039; : source;
  const settingValue = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; {
    const configToUse = configs[sourceKey];
    if (!configToUse) {
      throw &#039;Unsupported source&#039;;
    }
    if (propertyPath) {
      var _getValueFromObjectPa;
      return (_getValueFromObjectPa = getValueFromObjectPath(configToUse, contextualPath)) !== null &amp;&amp; _getValueFromObjectPa !== void 0 ? _getValueFromObjectPa : getValueFromObjectPath(configToUse, globalPath);
    }
    let result = {};
    VALID_SETTINGS.forEach(setting =&gt; {
      var _getValueFromObjectPa2;
      const value = (_getValueFromObjectPa2 = getValueFromObjectPath(configToUse, `settings${appendedBlockPath}.${setting}`)) !== null &amp;&amp; _getValueFromObjectPa2 !== void 0 ? _getValueFromObjectPa2 : getValueFromObjectPath(configToUse, `settings.${setting}`);
      if (value !== undefined) {
        result = setImmutably(result, setting.split(&#039;.&#039;), value);
      }
    });
    return result;
  }, [configs, sourceKey, propertyPath, contextualPath, globalPath, appendedBlockPath]);
  const setSetting = newValue =&gt; {
    setUserConfig(currentConfig =&gt; setImmutably(currentConfig, contextualPath.split(&#039;.&#039;), newValue));
  };
  return [settingValue, setSetting];
}
function useGlobalStyle(path, blockName, source = &#039;all&#039;, {
  shouldDecodeEncode = true
} = {}) {
  const {
    merged: mergedConfig,
    base: baseConfig,
    user: userConfig,
    setUserConfig
  } = (0,external_wp_element_namespaceObject.useContext)(GlobalStylesContext);
  const appendedPath = path ? &#039;.&#039; + path : &#039;&#039;;
  const finalPath = !blockName ? `styles${appendedPath}` : `styles.blocks.${blockName}${appendedPath}`;
  const setStyle = newValue =&gt; {
    setUserConfig(currentConfig =&gt; setImmutably(currentConfig, finalPath.split(&#039;.&#039;), shouldDecodeEncode ? getPresetVariableFromValue(mergedConfig.settings, blockName, path, newValue) : newValue));
  };
  let rawResult, result;
  switch (source) {
    case &#039;all&#039;:
      rawResult = getValueFromObjectPath(mergedConfig, finalPath);
      result = shouldDecodeEncode ? getValueFromVariable(mergedConfig, blockName, rawResult) : rawResult;
      break;
    case &#039;user&#039;:
      rawResult = getValueFromObjectPath(userConfig, finalPath);
      result = shouldDecodeEncode ? getValueFromVariable(mergedConfig, blockName, rawResult) : rawResult;
      break;
    case &#039;base&#039;:
      rawResult = getValueFromObjectPath(baseConfig, finalPath);
      result = shouldDecodeEncode ? getValueFromVariable(baseConfig, blockName, rawResult) : rawResult;
      break;
    default:
      throw &#039;Unsupported source&#039;;
  }
  return [result, setStyle];
}

/**
 * React hook that overrides a global settings object with block and element specific settings.
 *
 * @param {Object}     parentSettings Settings object.
 * @param {blockName?} blockName      Block name.
 * @param {element?}   element        Element name.
 *
 * @return {Object} Merge of settings and supports.
 */
function useSettingsForBlockElement(parentSettings, blockName, element) {
  const {
    supportedStyles,
    supports
  } = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    return {
      supportedStyles: unlock(select(external_wp_blocks_namespaceObject.store)).getSupportedStyles(blockName, element),
      supports: select(external_wp_blocks_namespaceObject.store).getBlockType(blockName)?.supports
    };
  }, [blockName, element]);
  return (0,external_wp_element_namespaceObject.useMemo)(() =&gt; {
    const updatedSettings = {
      ...parentSettings
    };
    if (!supportedStyles.includes(&#039;fontSize&#039;)) {
      updatedSettings.typography = {
        ...updatedSettings.typography,
        fontSizes: {},
        customFontSize: false,
        defaultFontSizes: false
      };
    }
    if (!supportedStyles.includes(&#039;fontFamily&#039;)) {
      updatedSettings.typography = {
        ...updatedSettings.typography,
        fontFamilies: {}
      };
    }
    updatedSettings.color = {
      ...updatedSettings.color,
      text: updatedSettings.color?.text &amp;&amp; supportedStyles.includes(&#039;color&#039;),
      background: updatedSettings.color?.background &amp;&amp; (supportedStyles.includes(&#039;background&#039;) || supportedStyles.includes(&#039;backgroundColor&#039;)),
      button: updatedSettings.color?.button &amp;&amp; supportedStyles.includes(&#039;buttonColor&#039;),
      heading: updatedSettings.color?.heading &amp;&amp; supportedStyles.includes(&#039;headingColor&#039;),
      link: updatedSettings.color?.link &amp;&amp; supportedStyles.includes(&#039;linkColor&#039;),
      caption: updatedSettings.color?.caption &amp;&amp; supportedStyles.includes(&#039;captionColor&#039;)
    };

    // Some blocks can enable background colors but disable gradients.
    if (!supportedStyles.includes(&#039;background&#039;)) {
      updatedSettings.color.gradients = [];
      updatedSettings.color.customGradient = false;
    }

    // If filters are not supported by the block/element, disable duotone.
    if (!supportedStyles.includes(&#039;filter&#039;)) {
      updatedSettings.color.defaultDuotone = false;
      updatedSettings.color.customDuotone = false;
    }
    [&#039;lineHeight&#039;, &#039;fontStyle&#039;, &#039;fontWeight&#039;, &#039;letterSpacing&#039;, &#039;textAlign&#039;, &#039;textTransform&#039;, &#039;textDecoration&#039;, &#039;writingMode&#039;].forEach(key =&gt; {
      if (!supportedStyles.includes(key)) {
        updatedSettings.typography = {
          ...updatedSettings.typography,
          [key]: false
        };
      }
    });

    // The column-count style is named text column to reduce confusion with
    // the columns block and manage expectations from the support.
    // See: https://github.com/WordPress/gutenberg/pull/33587
    if (!supportedStyles.includes(&#039;columnCount&#039;)) {
      updatedSettings.typography = {
        ...updatedSettings.typography,
        textColumns: false
      };
    }
    [&#039;contentSize&#039;, &#039;wideSize&#039;].forEach(key =&gt; {
      if (!supportedStyles.includes(key)) {
        updatedSettings.layout = {
          ...updatedSettings.layout,
          [key]: false
        };
      }
    });
    [&#039;padding&#039;, &#039;margin&#039;, &#039;blockGap&#039;].forEach(key =&gt; {
      if (!supportedStyles.includes(key)) {
        updatedSettings.spacing = {
          ...updatedSettings.spacing,
          [key]: false
        };
      }
      const sides = Array.isArray(supports?.spacing?.[key]) ? supports?.spacing?.[key] : supports?.spacing?.[key]?.sides;
      // Check if spacing type is supported before adding sides.
      if (sides?.length &amp;&amp; updatedSettings.spacing?.[key]) {
        updatedSettings.spacing = {
          ...updatedSettings.spacing,
          [key]: {
            ...updatedSettings.spacing?.[key],
            sides
          }
        };
      }
    });
    [&#039;aspectRatio&#039;, &#039;minHeight&#039;].forEach(key =&gt; {
      if (!supportedStyles.includes(key)) {
        updatedSettings.dimensions = {
          ...updatedSettings.dimensions,
          [key]: false
        };
      }
    });
    [&#039;radius&#039;, &#039;color&#039;, &#039;style&#039;, &#039;width&#039;].forEach(key =&gt; {
      if (!supportedStyles.includes(&#039;border&#039; + key.charAt(0).toUpperCase() + key.slice(1))) {
        updatedSettings.border = {
          ...updatedSettings.border,
          [key]: false
        };
      }
    });
    [&#039;backgroundImage&#039;, &#039;backgroundSize&#039;].forEach(key =&gt; {
      if (!supportedStyles.includes(key)) {
        updatedSettings.background = {
          ...updatedSettings.background,
          [key]: false
        };
      }
    });
    updatedSettings.shadow = supportedStyles.includes(&#039;shadow&#039;) ? updatedSettings.shadow : false;

    // Text alignment is only available for blocks.
    if (element) {
      updatedSettings.typography.textAlign = false;
    }
    return updatedSettings;
  }, [parentSettings, supportedStyles, supports, element]);
}
function useColorsPerOrigin(settings) {
  const customColors = settings?.color?.palette?.custom;
  const themeColors = settings?.color?.palette?.theme;
  const defaultColors = settings?.color?.palette?.default;
  const shouldDisplayDefaultColors = settings?.color?.defaultPalette;
  return (0,external_wp_element_namespaceObject.useMemo)(() =&gt; {
    const result = [];
    if (themeColors &amp;&amp; themeColors.length) {
      result.push({
        name: (0,external_wp_i18n_namespaceObject._x)(&#039;Theme&#039;, &#039;Indicates this palette comes from the theme.&#039;),
        colors: themeColors
      });
    }
    if (shouldDisplayDefaultColors &amp;&amp; defaultColors &amp;&amp; defaultColors.length) {
      result.push({
        name: (0,external_wp_i18n_namespaceObject._x)(&#039;Default&#039;, &#039;Indicates this palette comes from WordPress.&#039;),
        colors: defaultColors
      });
    }
    if (customColors &amp;&amp; customColors.length) {
      result.push({
        name: (0,external_wp_i18n_namespaceObject._x)(&#039;Custom&#039;, &#039;Indicates this palette is created by the user.&#039;),
        colors: customColors
      });
    }
    return result;
  }, [customColors, themeColors, defaultColors, shouldDisplayDefaultColors]);
}
function useGradientsPerOrigin(settings) {
  const customGradients = settings?.color?.gradients?.custom;
  const themeGradients = settings?.color?.gradients?.theme;
  const defaultGradients = settings?.color?.gradients?.default;
  const shouldDisplayDefaultGradients = settings?.color?.defaultGradients;
  return (0,external_wp_element_namespaceObject.useMemo)(() =&gt; {
    const result = [];
    if (themeGradients &amp;&amp; themeGradients.length) {
      result.push({
        name: (0,external_wp_i18n_namespaceObject._x)(&#039;Theme&#039;, &#039;Indicates this palette comes from the theme.&#039;),
        gradients: themeGradients
      });
    }
    if (shouldDisplayDefaultGradients &amp;&amp; defaultGradients &amp;&amp; defaultGradients.length) {
      result.push({
        name: (0,external_wp_i18n_namespaceObject._x)(&#039;Default&#039;, &#039;Indicates this palette comes from WordPress.&#039;),
        gradients: defaultGradients
      });
    }
    if (customGradients &amp;&amp; customGradients.length) {
      result.push({
        name: (0,external_wp_i18n_namespaceObject._x)(&#039;Custom&#039;, &#039;Indicates this palette is created by the user.&#039;),
        gradients: customGradients
      });
    }
    return result;
  }, [customGradients, themeGradients, defaultGradients, shouldDisplayDefaultGradients]);
}

;// ./node_modules/clsx/dist/clsx.mjs
function r(e){var t,f,n=&quot;&quot;;if(&quot;string&quot;==typeof e||&quot;number&quot;==typeof e)n+=e;else if(&quot;object&quot;==typeof e)if(Array.isArray(e)){var o=e.length;for(t=0;t&lt;o;t++)e[t]&amp;&amp;(f=r(e[t]))&amp;&amp;(n&amp;&amp;(n+=&quot; &quot;),n+=f)}else for(f in e)e[f]&amp;&amp;(n&amp;&amp;(n+=&quot; &quot;),n+=f);return n}function clsx(){for(var e,t,f=0,n=&quot;&quot;,o=arguments.length;f&lt;o;f++)(e=arguments[f])&amp;&amp;(t=r(e))&amp;&amp;(n&amp;&amp;(n+=&quot; &quot;),n+=t);return n}/* harmony default export */ const dist_clsx = (clsx);
;// ./node_modules/@wordpress/block-editor/build-module/hooks/utils.js
/**
 * WordPress dependencies
 */






/**
 * Internal dependencies
 */






/**
 * External dependencies
 */


/**
 * Removed falsy values from nested object.
 *
 * @param {*} object
 * @return {*} Object cleaned from falsy values
 */

const utils_cleanEmptyObject = object =&gt; {
  if (object === null || typeof object !== &#039;object&#039; || Array.isArray(object)) {
    return object;
  }
  const cleanedNestedObjects = Object.entries(object).map(([key, value]) =&gt; [key, utils_cleanEmptyObject(value)]).filter(([, value]) =&gt; value !== undefined);
  return !cleanedNestedObjects.length ? undefined : Object.fromEntries(cleanedNestedObjects);
};
function transformStyles(activeSupports, migrationPaths, result, source, index, results) {
  // If there are no active supports return early.
  if (Object.values(activeSupports !== null &amp;&amp; activeSupports !== void 0 ? activeSupports : {}).every(isActive =&gt; !isActive)) {
    return result;
  }
  // If the condition verifies we are probably in the presence of a wrapping transform
  // e.g: nesting paragraphs in a group or columns and in that case the styles should not be transformed.
  if (results.length === 1 &amp;&amp; result.innerBlocks.length === source.length) {
    return result;
  }
  // For cases where we have a transform from one block to multiple blocks
  // or multiple blocks to one block we apply the styles of the first source block
  // to the result(s).
  let referenceBlockAttributes = source[0]?.attributes;
  // If we are in presence of transform between more than one block in the source
  // that has more than one block in the result
  // we apply the styles on source N to the result N,
  // if source N does not exists we do nothing.
  if (results.length &gt; 1 &amp;&amp; source.length &gt; 1) {
    if (source[index]) {
      referenceBlockAttributes = source[index]?.attributes;
    } else {
      return result;
    }
  }
  let returnBlock = result;
  Object.entries(activeSupports).forEach(([support, isActive]) =&gt; {
    if (isActive) {
      migrationPaths[support].forEach(path =&gt; {
        const styleValue = getValueFromObjectPath(referenceBlockAttributes, path);
        if (styleValue) {
          returnBlock = {
            ...returnBlock,
            attributes: setImmutably(returnBlock.attributes, path, styleValue)
          };
        }
      });
    }
  });
  return returnBlock;
}

/**
 * Check whether serialization of specific block support feature or set should
 * be skipped.
 *
 * @param {string|Object} blockNameOrType Block name or block type object.
 * @param {string}        featureSet      Name of block support feature set.
 * @param {string}        feature         Name of the individual feature to check.
 *
 * @return {boolean} Whether serialization should occur.
 */
function shouldSkipSerialization(blockNameOrType, featureSet, feature) {
  const support = (0,external_wp_blocks_namespaceObject.getBlockSupport)(blockNameOrType, featureSet);
  const skipSerialization = support?.__experimentalSkipSerialization;
  if (Array.isArray(skipSerialization)) {
    return skipSerialization.includes(feature);
  }
  return skipSerialization;
}
const pendingStyleOverrides = new WeakMap();

/**
 * Override a block editor settings style. Leave the ID blank to create a new
 * style.
 *
 * @param {Object}  override     Override object.
 * @param {?string} override.id  Id of the style override, leave blank to create
 *                               a new style.
 * @param {string}  override.css CSS to apply.
 */
function useStyleOverride({
  id,
  css
}) {
  return usePrivateStyleOverride({
    id,
    css
  });
}
function usePrivateStyleOverride({
  id,
  css,
  assets,
  __unstableType,
  variation,
  clientId
} = {}) {
  const {
    setStyleOverride,
    deleteStyleOverride
  } = unlock((0,external_wp_data_namespaceObject.useDispatch)(store));
  const registry = (0,external_wp_data_namespaceObject.useRegistry)();
  const fallbackId = (0,external_wp_element_namespaceObject.useId)();
  (0,external_wp_element_namespaceObject.useEffect)(() =&gt; {
    // Unmount if there is CSS and assets are empty.
    if (!css &amp;&amp; !assets) {
      return;
    }
    const _id = id || fallbackId;
    const override = {
      id,
      css,
      assets,
      __unstableType,
      variation,
      clientId
    };
    // Batch updates to style overrides to avoid triggering cascading renders
    // for each style override block included in a tree and optimize initial render.
    if (!pendingStyleOverrides.get(registry)) {
      pendingStyleOverrides.set(registry, []);
    }
    pendingStyleOverrides.get(registry).push([_id, override]);
    window.queueMicrotask(() =&gt; {
      if (pendingStyleOverrides.get(registry)?.length) {
        registry.batch(() =&gt; {
          pendingStyleOverrides.get(registry).forEach(args =&gt; {
            setStyleOverride(...args);
          });
          pendingStyleOverrides.set(registry, []);
        });
      }
    });
    return () =&gt; {
      const isPending = pendingStyleOverrides.get(registry)?.find(([currentId]) =&gt; currentId === _id);
      if (isPending) {
        pendingStyleOverrides.set(registry, pendingStyleOverrides.get(registry).filter(([currentId]) =&gt; currentId !== _id));
      } else {
        deleteStyleOverride(_id);
      }
    };
  }, [id, css, clientId, assets, __unstableType, fallbackId, setStyleOverride, deleteStyleOverride, registry]);
}

/**
 * Based on the block and its context, returns an object of all the block settings.
 * This object can be passed as a prop to all the Styles UI components
 * (TypographyPanel, DimensionsPanel...).
 *
 * @param {string} name         Block name.
 * @param {*}      parentLayout Parent layout.
 *
 * @return {Object} Settings object.
 */
function useBlockSettings(name, parentLayout) {
  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(&#039;background.backgroundImage&#039;, &#039;background.backgroundSize&#039;, &#039;typography.fontFamilies.custom&#039;, &#039;typography.fontFamilies.default&#039;, &#039;typography.fontFamilies.theme&#039;, &#039;typography.defaultFontSizes&#039;, &#039;typography.fontSizes.custom&#039;, &#039;typography.fontSizes.default&#039;, &#039;typography.fontSizes.theme&#039;, &#039;typography.customFontSize&#039;, &#039;typography.fontStyle&#039;, &#039;typography.fontWeight&#039;, &#039;typography.lineHeight&#039;, &#039;typography.textAlign&#039;, &#039;typography.textColumns&#039;, &#039;typography.textDecoration&#039;, &#039;typography.writingMode&#039;, &#039;typography.textTransform&#039;, &#039;typography.letterSpacing&#039;, &#039;spacing.padding&#039;, &#039;spacing.margin&#039;, &#039;spacing.blockGap&#039;, &#039;spacing.defaultSpacingSizes&#039;, &#039;spacing.customSpacingSize&#039;, &#039;spacing.spacingSizes.custom&#039;, &#039;spacing.spacingSizes.default&#039;, &#039;spacing.spacingSizes.theme&#039;, &#039;spacing.units&#039;, &#039;dimensions.aspectRatio&#039;, &#039;dimensions.minHeight&#039;, &#039;layout&#039;, &#039;border.color&#039;, &#039;border.radius&#039;, &#039;border.style&#039;, &#039;border.width&#039;, &#039;color.custom&#039;, &#039;color.palette.custom&#039;, &#039;color.customDuotone&#039;, &#039;color.palette.theme&#039;, &#039;color.palette.default&#039;, &#039;color.defaultPalette&#039;, &#039;color.defaultDuotone&#039;, &#039;color.duotone.custom&#039;, &#039;color.duotone.theme&#039;, &#039;color.duotone.default&#039;, &#039;color.gradients.custom&#039;, &#039;color.gradients.theme&#039;, &#039;color.gradients.default&#039;, &#039;color.defaultGradients&#039;, &#039;color.customGradient&#039;, &#039;color.background&#039;, &#039;color.link&#039;, &#039;color.text&#039;, &#039;color.heading&#039;, &#039;color.button&#039;, &#039;shadow&#039;);
  const rawSettings = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; {
    return {
      background: {
        backgroundImage,
        backgroundSize
      },
      color: {
        palette: {
          custom: customColors,
          theme: themeColors,
          default: defaultColors
        },
        gradients: {
          custom: userGradientPalette,
          theme: themeGradientPalette,
          default: defaultGradientPalette
        },
        duotone: {
          custom: userDuotonePalette,
          theme: themeDuotonePalette,
          default: defaultDuotonePalette
        },
        defaultGradients,
        defaultPalette,
        defaultDuotone,
        custom: customColorsEnabled,
        customGradient: areCustomGradientsEnabled,
        customDuotone,
        background: isBackgroundEnabled,
        link: isLinkEnabled,
        heading: isHeadingEnabled,
        button: isButtonEnabled,
        text: isTextEnabled
      },
      typography: {
        fontFamilies: {
          custom: customFontFamilies,
          default: defaultFontFamilies,
          theme: themeFontFamilies
        },
        fontSizes: {
          custom: customFontSizes,
          default: defaultFontSizes,
          theme: themeFontSizes
        },
        customFontSize,
        defaultFontSizes: defaultFontSizesEnabled,
        fontStyle,
        fontWeight,
        lineHeight,
        textAlign,
        textColumns,
        textDecoration,
        textTransform,
        letterSpacing,
        writingMode
      },
      spacing: {
        spacingSizes: {
          custom: userSpacingSizes,
          default: defaultSpacingSizes,
          theme: themeSpacingSizes
        },
        customSpacingSize,
        defaultSpacingSizes: defaultSpacingSizesEnabled,
        padding,
        margin,
        blockGap,
        units
      },
      border: {
        color: borderColor,
        radius: borderRadius,
        style: borderStyle,
        width: borderWidth
      },
      dimensions: {
        aspectRatio,
        minHeight
      },
      layout,
      parentLayout,
      shadow
    };
  }, [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]);
  return useSettingsForBlockElement(rawSettings, name);
}
function createBlockEditFilter(features) {
  // We don&#039;t want block controls to re-render when typing inside a block.
  // `memo` will prevent re-renders unless props change, so only pass the
  // needed props and not the whole attributes object.
  features = features.map(settings =&gt; {
    return {
      ...settings,
      Edit: (0,external_wp_element_namespaceObject.memo)(settings.edit)
    };
  });
  const withBlockEditHooks = (0,external_wp_compose_namespaceObject.createHigherOrderComponent)(OriginalBlockEdit =&gt; props =&gt; {
    const context = useBlockEditContext();
    // CAUTION: code added before this line will be executed for all
    // blocks, not just those that support the feature! Code added
    // above this line should be carefully evaluated for its impact on
    // performance.
    return [...features.map((feature, i) =&gt; {
      const {
        Edit,
        hasSupport,
        attributeKeys = [],
        shareWithChildBlocks
      } = feature;
      const shouldDisplayControls = context[mayDisplayControlsKey] || context[mayDisplayParentControlsKey] &amp;&amp; shareWithChildBlocks;
      if (!shouldDisplayControls || !hasSupport(props.name)) {
        return null;
      }
      const neededProps = {};
      for (const key of attributeKeys) {
        if (props.attributes[key]) {
          neededProps[key] = props.attributes[key];
        }
      }
      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Edit
      // We can use the index because the array length
      // is fixed per page load right now.
      , {
        name: props.name,
        isSelected: props.isSelected,
        clientId: props.clientId,
        setAttributes: props.setAttributes,
        __unstableParentLayout: props.__unstableParentLayout
        // This component is pure, so only pass needed
        // props!!!
        ,
        ...neededProps
      }, i);
    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(OriginalBlockEdit, {
      ...props
    }, &quot;edit&quot;)];
  }, &#039;withBlockEditHooks&#039;);
  (0,external_wp_hooks_namespaceObject.addFilter)(&#039;editor.BlockEdit&#039;, &#039;core/editor/hooks&#039;, withBlockEditHooks);
}
function BlockProps({
  index,
  useBlockProps: hook,
  setAllWrapperProps,
  ...props
}) {
  const wrapperProps = hook(props);
  const setWrapperProps = next =&gt; setAllWrapperProps(prev =&gt; {
    const nextAll = [...prev];
    nextAll[index] = next;
    return nextAll;
  });
  // Setting state after every render is fine because this component is
  // pure and will only re-render when needed props change.
  (0,external_wp_element_namespaceObject.useEffect)(() =&gt; {
    // We could shallow compare the props, but since this component only
    // changes when needed attributes change, the benefit is probably small.
    setWrapperProps(wrapperProps);
    return () =&gt; {
      setWrapperProps(undefined);
    };
  });
  return null;
}
const BlockPropsPure = (0,external_wp_element_namespaceObject.memo)(BlockProps);
function createBlockListBlockFilter(features) {
  const withBlockListBlockHooks = (0,external_wp_compose_namespaceObject.createHigherOrderComponent)(BlockListBlock =&gt; props =&gt; {
    const [allWrapperProps, setAllWrapperProps] = (0,external_wp_element_namespaceObject.useState)(Array(features.length).fill(undefined));
    return [...features.map((feature, i) =&gt; {
      const {
        hasSupport,
        attributeKeys = [],
        useBlockProps,
        isMatch
      } = feature;
      const neededProps = {};
      for (const key of attributeKeys) {
        if (props.attributes[key]) {
          neededProps[key] = props.attributes[key];
        }
      }
      if (
      // Skip rendering if none of the needed attributes are
      // set.
      !Object.keys(neededProps).length || !hasSupport(props.name) || isMatch &amp;&amp; !isMatch(neededProps)) {
        return null;
      }
      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockPropsPure
      // We can use the index because the array length
      // is fixed per page load right now.
      , {
        index: i,
        useBlockProps: useBlockProps
        // This component is pure, so we must pass a stable
        // function reference.
        ,
        setAllWrapperProps: setAllWrapperProps,
        name: props.name,
        clientId: props.clientId
        // This component is pure, so only pass needed
        // props!!!
        ,
        ...neededProps
      }, i);
    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockListBlock, {
      ...props,
      wrapperProps: allWrapperProps.filter(Boolean).reduce((acc, wrapperProps) =&gt; {
        return {
          ...acc,
          ...wrapperProps,
          className: dist_clsx(acc.className, wrapperProps.className),
          style: {
            ...acc.style,
            ...wrapperProps.style
          }
        };
      }, props.wrapperProps || {})
    }, &quot;edit&quot;)];
  }, &#039;withBlockListBlockHooks&#039;);
  (0,external_wp_hooks_namespaceObject.addFilter)(&#039;editor.BlockListBlock&#039;, &#039;core/editor/hooks&#039;, withBlockListBlockHooks);
}
function createBlockSaveFilter(features) {
  function extraPropsFromHooks(props, name, attributes) {
    return features.reduce((accu, feature) =&gt; {
      const {
        hasSupport,
        attributeKeys = [],
        addSaveProps
      } = feature;
      const neededAttributes = {};
      for (const key of attributeKeys) {
        if (attributes[key]) {
          neededAttributes[key] = attributes[key];
        }
      }
      if (
      // Skip rendering if none of the needed attributes are
      // set.
      !Object.keys(neededAttributes).length || !hasSupport(name)) {
        return accu;
      }
      return addSaveProps(accu, name, neededAttributes);
    }, props);
  }
  (0,external_wp_hooks_namespaceObject.addFilter)(&#039;blocks.getSaveContent.extraProps&#039;, &#039;core/editor/hooks&#039;, extraPropsFromHooks, 0);
  (0,external_wp_hooks_namespaceObject.addFilter)(&#039;blocks.getSaveContent.extraProps&#039;, &#039;core/editor/hooks&#039;, props =&gt; {
    // Previously we had a filter deleting the className if it was an empty
    // string. That filter is no longer running, so now we need to delete it
    // here.
    if (props.hasOwnProperty(&#039;className&#039;) &amp;&amp; !props.className) {
      delete props.className;
    }
    return props;
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/hooks/compat.js
/**
 * WordPress dependencies
 */


function migrateLightBlockWrapper(settings) {
  const {
    apiVersion = 1
  } = settings;
  if (apiVersion &lt; 2 &amp;&amp; (0,external_wp_blocks_namespaceObject.hasBlockSupport)(settings, &#039;lightBlockWrapper&#039;, false)) {
    settings.apiVersion = 2;
  }
  return settings;
}
(0,external_wp_hooks_namespaceObject.addFilter)(&#039;blocks.registerBlockType&#039;, &#039;core/compat/migrateLightBlockWrapper&#039;, migrateLightBlockWrapper);

;// external [&quot;wp&quot;,&quot;components&quot;]
const external_wp_components_namespaceObject = window[&quot;wp&quot;][&quot;components&quot;];
;// ./node_modules/@wordpress/block-editor/build-module/components/block-controls/groups.js
/**
 * WordPress dependencies
 */

const BlockControlsDefault = (0,external_wp_components_namespaceObject.createSlotFill)(&#039;BlockControls&#039;);
const BlockControlsBlock = (0,external_wp_components_namespaceObject.createSlotFill)(&#039;BlockControlsBlock&#039;);
const BlockControlsInline = (0,external_wp_components_namespaceObject.createSlotFill)(&#039;BlockFormatControls&#039;);
const BlockControlsOther = (0,external_wp_components_namespaceObject.createSlotFill)(&#039;BlockControlsOther&#039;);
const BlockControlsParent = (0,external_wp_components_namespaceObject.createSlotFill)(&#039;BlockControlsParent&#039;);
const groups = {
  default: BlockControlsDefault,
  block: BlockControlsBlock,
  inline: BlockControlsInline,
  other: BlockControlsOther,
  parent: BlockControlsParent
};
/* harmony default export */ const block_controls_groups = (groups);

;// ./node_modules/@wordpress/block-editor/build-module/components/block-controls/hook.js
/**
 * WordPress dependencies
 */

/**
 * Internal dependencies
 */


function useBlockControlsFill(group, shareWithChildBlocks) {
  const context = useBlockEditContext();
  if (context[mayDisplayControlsKey]) {
    return block_controls_groups[group]?.Fill;
  }
  if (context[mayDisplayParentControlsKey] &amp;&amp; shareWithChildBlocks) {
    return block_controls_groups.parent.Fill;
  }
  return null;
}

;// ./node_modules/@wordpress/block-editor/build-module/components/block-controls/fill.js
/**
 * WordPress dependencies
 */


/**
 * Internal dependencies
 */


function BlockControlsFill({
  group = &#039;default&#039;,
  controls,
  children,
  __experimentalShareWithChildBlocks = false
}) {
  const Fill = useBlockControlsFill(group, __experimentalShareWithChildBlocks);
  if (!Fill) {
    return null;
  }
  const innerMarkup = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
    children: [group === &#039;default&#039; &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarGroup, {
      controls: controls
    }), children]
  });
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalStyleProvider, {
    document: document,
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Fill, {
      children: fillProps =&gt; {
        // `fillProps.forwardedContext` is an array of context provider entries, provided by slot,
        // that should wrap the fill markup.
        const {
          forwardedContext = []
        } = fillProps;
        return forwardedContext.reduce((inner, [Provider, props]) =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Provider, {
          ...props,
          children: inner
        }), innerMarkup);
      }
    })
  });
}

;// external [&quot;wp&quot;,&quot;warning&quot;]
const external_wp_warning_namespaceObject = window[&quot;wp&quot;][&quot;warning&quot;];
var external_wp_warning_default = /*#__PURE__*/__webpack_require__.n(external_wp_warning_namespaceObject);
;// ./node_modules/@wordpress/block-editor/build-module/components/block-controls/slot.js
/**
 * WordPress dependencies
 */




/**
 * Internal dependencies
 */



const {
  ComponentsContext
} = unlock(external_wp_components_namespaceObject.privateApis);
function BlockControlsSlot({
  group = &#039;default&#039;,
  ...props
}) {
  const toolbarState = (0,external_wp_element_namespaceObject.useContext)(external_wp_components_namespaceObject.__experimentalToolbarContext);
  const contextState = (0,external_wp_element_namespaceObject.useContext)(ComponentsContext);
  const fillProps = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; ({
    forwardedContext: [[external_wp_components_namespaceObject.__experimentalToolbarContext.Provider, {
      value: toolbarState
    }], [ComponentsContext.Provider, {
      value: contextState
    }]]
  }), [toolbarState, contextState]);
  const slotFill = block_controls_groups[group];
  const fills = (0,external_wp_components_namespaceObject.__experimentalUseSlotFills)(slotFill.name);
  if (!slotFill) {
     true ? external_wp_warning_default()(`Unknown BlockControls group &quot;${group}&quot; provided.`) : 0;
    return null;
  }
  if (!fills?.length) {
    return null;
  }
  const {
    Slot
  } = slotFill;
  const slot = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Slot, {
    ...props,
    bubblesVirtually: true,
    fillProps: fillProps
  });
  if (group === &#039;default&#039;) {
    return slot;
  }
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarGroup, {
    children: slot
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/block-controls/index.js
/**
 * Internal dependencies
 */



const BlockControls = BlockControlsFill;
BlockControls.Slot = BlockControlsSlot;

// This is just here for backward compatibility.
const BlockFormatControls = props =&gt; {
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockControlsFill, {
    group: &quot;inline&quot;,
    ...props
  });
};
BlockFormatControls.Slot = props =&gt; {
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockControlsSlot, {
    group: &quot;inline&quot;,
    ...props
  });
};
/* harmony default export */ const block_controls = (BlockControls);

;// ./node_modules/@wordpress/icons/build-module/library/justify-left.js
/**
 * WordPress dependencies
 */


const justifyLeft = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;M9 9v6h11V9H9zM4 20h1.5V4H4v16z&quot;
  })
});
/* harmony default export */ const justify_left = (justifyLeft);

;// ./node_modules/@wordpress/icons/build-module/library/justify-center.js
/**
 * WordPress dependencies
 */


const justifyCenter = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;M12.5 15v5H11v-5H4V9h7V4h1.5v5h7v6h-7Z&quot;
  })
});
/* harmony default export */ const justify_center = (justifyCenter);

;// ./node_modules/@wordpress/icons/build-module/library/justify-right.js
/**
 * WordPress dependencies
 */


const justifyRight = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;M4 15h11V9H4v6zM18.5 4v16H20V4h-1.5z&quot;
  })
});
/* harmony default export */ const justify_right = (justifyRight);

;// ./node_modules/@wordpress/icons/build-module/library/justify-space-between.js
/**
 * WordPress dependencies
 */


const justifySpaceBetween = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;M9 15h6V9H9v6zm-5 5h1.5V4H4v16zM18.5 4v16H20V4h-1.5z&quot;
  })
});
/* harmony default export */ const justify_space_between = (justifySpaceBetween);

;// ./node_modules/@wordpress/icons/build-module/library/justify-stretch.js
/**
 * WordPress dependencies
 */


const justifyStretch = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;M4 4H5.5V20H4V4ZM7 10L17 10V14L7 14V10ZM20 4H18.5V20H20V4Z&quot;
  })
});
/* harmony default export */ const justify_stretch = (justifyStretch);

;// ./node_modules/@wordpress/icons/build-module/library/arrow-right.js
/**
 * WordPress dependencies
 */


const arrowRight = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;m14.5 6.5-1 1 3.7 3.7H4v1.6h13.2l-3.7 3.7 1 1 5.6-5.5z&quot;
  })
});
/* harmony default export */ const arrow_right = (arrowRight);

;// ./node_modules/@wordpress/icons/build-module/library/arrow-down.js
/**
 * WordPress dependencies
 */


const arrowDown = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;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&quot;
  })
});
/* harmony default export */ const arrow_down = (arrowDown);

;// ./node_modules/@wordpress/block-editor/build-module/layouts/definitions.js
// Layout definitions keyed by layout type.
// Provides a common definition of slugs, classnames, base styles, and spacing styles for each layout type.
// If making changes or additions to layout definitions, be sure to update the corresponding PHP definitions in
// `block-supports/layout.php` so that the server-side and client-side definitions match.
const LAYOUT_DEFINITIONS = {
  default: {
    name: &#039;default&#039;,
    slug: &#039;flow&#039;,
    className: &#039;is-layout-flow&#039;,
    baseStyles: [{
      selector: &#039; &gt; .alignleft&#039;,
      rules: {
        float: &#039;left&#039;,
        &#039;margin-inline-start&#039;: &#039;0&#039;,
        &#039;margin-inline-end&#039;: &#039;2em&#039;
      }
    }, {
      selector: &#039; &gt; .alignright&#039;,
      rules: {
        float: &#039;right&#039;,
        &#039;margin-inline-start&#039;: &#039;2em&#039;,
        &#039;margin-inline-end&#039;: &#039;0&#039;
      }
    }, {
      selector: &#039; &gt; .aligncenter&#039;,
      rules: {
        &#039;margin-left&#039;: &#039;auto !important&#039;,
        &#039;margin-right&#039;: &#039;auto !important&#039;
      }
    }],
    spacingStyles: [{
      selector: &#039; &gt; :first-child&#039;,
      rules: {
        &#039;margin-block-start&#039;: &#039;0&#039;
      }
    }, {
      selector: &#039; &gt; :last-child&#039;,
      rules: {
        &#039;margin-block-end&#039;: &#039;0&#039;
      }
    }, {
      selector: &#039; &gt; *&#039;,
      rules: {
        &#039;margin-block-start&#039;: null,
        &#039;margin-block-end&#039;: &#039;0&#039;
      }
    }]
  },
  constrained: {
    name: &#039;constrained&#039;,
    slug: &#039;constrained&#039;,
    className: &#039;is-layout-constrained&#039;,
    baseStyles: [{
      selector: &#039; &gt; .alignleft&#039;,
      rules: {
        float: &#039;left&#039;,
        &#039;margin-inline-start&#039;: &#039;0&#039;,
        &#039;margin-inline-end&#039;: &#039;2em&#039;
      }
    }, {
      selector: &#039; &gt; .alignright&#039;,
      rules: {
        float: &#039;right&#039;,
        &#039;margin-inline-start&#039;: &#039;2em&#039;,
        &#039;margin-inline-end&#039;: &#039;0&#039;
      }
    }, {
      selector: &#039; &gt; .aligncenter&#039;,
      rules: {
        &#039;margin-left&#039;: &#039;auto !important&#039;,
        &#039;margin-right&#039;: &#039;auto !important&#039;
      }
    }, {
      selector: &#039; &gt; :where(:not(.alignleft):not(.alignright):not(.alignfull))&#039;,
      rules: {
        &#039;max-width&#039;: &#039;var(--wp--style--global--content-size)&#039;,
        &#039;margin-left&#039;: &#039;auto !important&#039;,
        &#039;margin-right&#039;: &#039;auto !important&#039;
      }
    }, {
      selector: &#039; &gt; .alignwide&#039;,
      rules: {
        &#039;max-width&#039;: &#039;var(--wp--style--global--wide-size)&#039;
      }
    }],
    spacingStyles: [{
      selector: &#039; &gt; :first-child&#039;,
      rules: {
        &#039;margin-block-start&#039;: &#039;0&#039;
      }
    }, {
      selector: &#039; &gt; :last-child&#039;,
      rules: {
        &#039;margin-block-end&#039;: &#039;0&#039;
      }
    }, {
      selector: &#039; &gt; *&#039;,
      rules: {
        &#039;margin-block-start&#039;: null,
        &#039;margin-block-end&#039;: &#039;0&#039;
      }
    }]
  },
  flex: {
    name: &#039;flex&#039;,
    slug: &#039;flex&#039;,
    className: &#039;is-layout-flex&#039;,
    displayMode: &#039;flex&#039;,
    baseStyles: [{
      selector: &#039;&#039;,
      rules: {
        &#039;flex-wrap&#039;: &#039;wrap&#039;,
        &#039;align-items&#039;: &#039;center&#039;
      }
    }, {
      selector: &#039; &gt; :is(*, div)&#039;,
      // :is(*, div) instead of just * increases the specificity by 001.
      rules: {
        margin: &#039;0&#039;
      }
    }],
    spacingStyles: [{
      selector: &#039;&#039;,
      rules: {
        gap: null
      }
    }]
  },
  grid: {
    name: &#039;grid&#039;,
    slug: &#039;grid&#039;,
    className: &#039;is-layout-grid&#039;,
    displayMode: &#039;grid&#039;,
    baseStyles: [{
      selector: &#039; &gt; :is(*, div)&#039;,
      // :is(*, div) instead of just * increases the specificity by 001.
      rules: {
        margin: &#039;0&#039;
      }
    }],
    spacingStyles: [{
      selector: &#039;&#039;,
      rules: {
        gap: null
      }
    }]
  }
};

;// ./node_modules/@wordpress/block-editor/build-module/layouts/utils.js
/**
 * WordPress dependencies
 */


/**
 * Internal dependencies
 */


/**
 * Utility to generate the proper CSS selector for layout styles.
 *
 * @param {string} selectors CSS selector, also supports multiple comma-separated selectors.
 * @param {string} append    The string to append.
 *
 * @return {string} - CSS selector.
 */
function appendSelectors(selectors, append = &#039;&#039;) {
  return selectors.split(&#039;,&#039;).map(subselector =&gt; `${subselector}${append ? ` ${append}` : &#039;&#039;}`).join(&#039;,&#039;);
}

/**
 * Get generated blockGap CSS rules based on layout definitions provided in theme.json
 * Falsy values in the layout definition&#039;s spacingStyles rules will be swapped out
 * with the provided `blockGapValue`.
 *
 * @param {string} selector          The CSS selector to target for the generated rules.
 * @param {Object} layoutDefinitions Layout definitions object.
 * @param {string} layoutType        The layout type (e.g. `default` or `flex`).
 * @param {string} blockGapValue     The current blockGap value to be applied.
 * @return {string} The generated CSS rules.
 */
function getBlockGapCSS(selector, layoutDefinitions = LAYOUT_DEFINITIONS, layoutType, blockGapValue) {
  let output = &#039;&#039;;
  if (layoutDefinitions?.[layoutType]?.spacingStyles?.length &amp;&amp; blockGapValue) {
    layoutDefinitions[layoutType].spacingStyles.forEach(gapStyle =&gt; {
      output += `${appendSelectors(selector, gapStyle.selector.trim())} { `;
      output += Object.entries(gapStyle.rules).map(([cssProperty, value]) =&gt; `${cssProperty}: ${value ? value : blockGapValue}`).join(&#039;; &#039;);
      output += &#039;; }&#039;;
    });
  }
  return output;
}

/**
 * Helper method to assign contextual info to clarify
 * alignment settings.
 *
 * Besides checking if `contentSize` and `wideSize` have a
 * value, we now show this information only if their values
 * are not a `css var`. This needs to change when parsing
 * css variables land.
 *
 * @see https://github.com/WordPress/gutenberg/pull/34710#issuecomment-918000752
 *
 * @param {Object} layout The layout object.
 * @return {Object} An object with contextual info per alignment.
 */
function getAlignmentsInfo(layout) {
  const {
    contentSize,
    wideSize,
    type = &#039;default&#039;
  } = layout;
  const alignmentInfo = {};
  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;
  if (sizeRegex.test(contentSize) &amp;&amp; type === &#039;constrained&#039;) {
    // translators: %s: container size (i.e. 600px etc)
    alignmentInfo.none = (0,external_wp_i18n_namespaceObject.sprintf)((0,external_wp_i18n_namespaceObject.__)(&#039;Max %s wide&#039;), contentSize);
  }
  if (sizeRegex.test(wideSize)) {
    // translators: %s: container size (i.e. 600px etc)
    alignmentInfo.wide = (0,external_wp_i18n_namespaceObject.sprintf)((0,external_wp_i18n_namespaceObject.__)(&#039;Max %s wide&#039;), wideSize);
  }
  return alignmentInfo;
}

;// ./node_modules/@wordpress/icons/build-module/library/sides-all.js
/**
 * WordPress dependencies
 */


const sidesAll = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;m7.5 6h9v-1.5h-9zm0 13.5h9v-1.5h-9zm-3-3h1.5v-9h-1.5zm13.5-9v9h1.5v-9z&quot;
  })
});
/* harmony default export */ const sides_all = (sidesAll);

;// ./node_modules/@wordpress/icons/build-module/library/sides-horizontal.js
/**
 * WordPress dependencies
 */


const sidesHorizontal = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;m7.5 6h9v-1.5h-9zm0 13.5h9v-1.5h-9zm-3-3h1.5v-9h-1.5zm13.5-9v9h1.5v-9z&quot;,
    style: {
      opacity: 0.25
    }
  }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;m4.5 7.5v9h1.5v-9z&quot;
  }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;m18 7.5v9h1.5v-9z&quot;
  })]
});
/* harmony default export */ const sides_horizontal = (sidesHorizontal);

;// ./node_modules/@wordpress/icons/build-module/library/sides-vertical.js
/**
 * WordPress dependencies
 */


const sidesVertical = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;m7.5 6h9v-1.5h-9zm0 13.5h9v-1.5h-9zm-3-3h1.5v-9h-1.5zm13.5-9v9h1.5v-9z&quot;,
    style: {
      opacity: 0.25
    }
  }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;m7.5 6h9v-1.5h-9z&quot;
  }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;m7.5 19.5h9v-1.5h-9z&quot;
  })]
});
/* harmony default export */ const sides_vertical = (sidesVertical);

;// ./node_modules/@wordpress/icons/build-module/library/sides-top.js
/**
 * WordPress dependencies
 */


const sidesTop = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;m7.5 6h9v-1.5h-9zm0 13.5h9v-1.5h-9zm-3-3h1.5v-9h-1.5zm13.5-9v9h1.5v-9z&quot;,
    style: {
      opacity: 0.25
    }
  }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;m16.5 6h-9v-1.5h9z&quot;
  })]
});
/* harmony default export */ const sides_top = (sidesTop);

;// ./node_modules/@wordpress/icons/build-module/library/sides-right.js
/**
 * WordPress dependencies
 */


const sidesRight = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;m7.5 6h9v-1.5h-9zm0 13.5h9v-1.5h-9zm-3-3h1.5v-9h-1.5zm13.5-9v9h1.5v-9z&quot;,
    style: {
      opacity: 0.25
    }
  }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;m18 16.5v-9h1.5v9z&quot;
  })]
});
/* harmony default export */ const sides_right = (sidesRight);

;// ./node_modules/@wordpress/icons/build-module/library/sides-bottom.js
/**
 * WordPress dependencies
 */


const sidesBottom = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;m7.5 6h9v-1.5h-9zm0 13.5h9v-1.5h-9zm-3-3h1.5v-9h-1.5zm13.5-9v9h1.5v-9z&quot;,
    style: {
      opacity: 0.25
    }
  }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;m16.5 19.5h-9v-1.5h9z&quot;
  })]
});
/* harmony default export */ const sides_bottom = (sidesBottom);

;// ./node_modules/@wordpress/icons/build-module/library/sides-left.js
/**
 * WordPress dependencies
 */


const sidesLeft = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;m7.5 6h9v-1.5h-9zm0 13.5h9v-1.5h-9zm-3-3h1.5v-9h-1.5zm13.5-9v9h1.5v-9z&quot;,
    style: {
      opacity: 0.25
    }
  }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;m4.5 16.5v-9h1.5v9z&quot;
  })]
});
/* harmony default export */ const sides_left = (sidesLeft);

;// ./node_modules/@wordpress/block-editor/build-module/components/spacing-sizes-control/utils.js
/**
 * WordPress dependencies
 */


const RANGE_CONTROL_MAX_SIZE = 8;
const ALL_SIDES = [&#039;top&#039;, &#039;right&#039;, &#039;bottom&#039;, &#039;left&#039;];
const DEFAULT_VALUES = {
  top: undefined,
  right: undefined,
  bottom: undefined,
  left: undefined
};
const ICONS = {
  custom: sides_all,
  axial: sides_all,
  horizontal: sides_horizontal,
  vertical: sides_vertical,
  top: sides_top,
  right: sides_right,
  bottom: sides_bottom,
  left: sides_left
};
const LABELS = {
  default: (0,external_wp_i18n_namespaceObject.__)(&#039;Spacing control&#039;),
  top: (0,external_wp_i18n_namespaceObject.__)(&#039;Top&#039;),
  bottom: (0,external_wp_i18n_namespaceObject.__)(&#039;Bottom&#039;),
  left: (0,external_wp_i18n_namespaceObject.__)(&#039;Left&#039;),
  right: (0,external_wp_i18n_namespaceObject.__)(&#039;Right&#039;),
  mixed: (0,external_wp_i18n_namespaceObject.__)(&#039;Mixed&#039;),
  vertical: (0,external_wp_i18n_namespaceObject.__)(&#039;Vertical&#039;),
  horizontal: (0,external_wp_i18n_namespaceObject.__)(&#039;Horizontal&#039;),
  axial: (0,external_wp_i18n_namespaceObject.__)(&#039;Horizontal &amp; vertical&#039;),
  custom: (0,external_wp_i18n_namespaceObject.__)(&#039;Custom&#039;)
};
const VIEWS = {
  axial: &#039;axial&#039;,
  top: &#039;top&#039;,
  right: &#039;right&#039;,
  bottom: &#039;bottom&#039;,
  left: &#039;left&#039;,
  custom: &#039;custom&#039;
};

/**
 * Checks is given value is a spacing preset.
 *
 * @param {string} value Value to check
 *
 * @return {boolean} Return true if value is string in format var:preset|spacing|.
 */
function isValueSpacingPreset(value) {
  if (!value?.includes) {
    return false;
  }
  return value === &#039;0&#039; || value.includes(&#039;var:preset|spacing|&#039;);
}

/**
 * Converts a spacing preset into a custom value.
 *
 * @param {string} value        Value to convert
 * @param {Array}  spacingSizes Array of the current spacing preset objects
 *
 * @return {string} Mapping of the spacing preset to its equivalent custom value.
 */
function getCustomValueFromPreset(value, spacingSizes) {
  if (!isValueSpacingPreset(value)) {
    return value;
  }
  const slug = getSpacingPresetSlug(value);
  const spacingSize = spacingSizes.find(size =&gt; String(size.slug) === slug);
  return spacingSize?.size;
}

/**
 * Converts a custom value to preset value if one can be found.
 *
 * Returns value as-is if no match is found.
 *
 * @param {string} value        Value to convert
 * @param {Array}  spacingSizes Array of the current spacing preset objects
 *
 * @return {string} The preset value if it can be found.
 */
function getPresetValueFromCustomValue(value, spacingSizes) {
  // Return value as-is if it is undefined or is already a preset, or &#039;0&#039;;
  if (!value || isValueSpacingPreset(value) || value === &#039;0&#039;) {
    return value;
  }
  const spacingMatch = spacingSizes.find(size =&gt; String(size.size) === String(value));
  if (spacingMatch?.slug) {
    return `var:preset|spacing|${spacingMatch.slug}`;
  }
  return value;
}

/**
 * Converts a spacing preset into a custom value.
 *
 * @param {string} value Value to convert.
 *
 * @return {string | undefined} CSS var string for given spacing preset value.
 */
function getSpacingPresetCssVar(value) {
  if (!value) {
    return;
  }
  const slug = value.match(/var:preset\|spacing\|(.+)/);
  if (!slug) {
    return value;
  }
  return `var(--wp--preset--spacing--${slug[1]})`;
}

/**
 * Returns the slug section of the given spacing preset string.
 *
 * @param {string} value Value to extract slug from.
 *
 * @return {string|undefined} The int value of the slug from given spacing preset.
 */
function getSpacingPresetSlug(value) {
  if (!value) {
    return;
  }
  if (value === &#039;0&#039; || value === &#039;default&#039;) {
    return value;
  }
  const slug = value.match(/var:preset\|spacing\|(.+)/);
  return slug ? slug[1] : undefined;
}

/**
 * Converts spacing preset value into a Range component value .
 *
 * @param {string} presetValue  Value to convert to Range value.
 * @param {Array}  spacingSizes Array of current spacing preset value objects.
 *
 * @return {number} The int value for use in Range control.
 */
function getSliderValueFromPreset(presetValue, spacingSizes) {
  if (presetValue === undefined) {
    return 0;
  }
  const slug = parseFloat(presetValue, 10) === 0 ? &#039;0&#039; : getSpacingPresetSlug(presetValue);
  const sliderValue = spacingSizes.findIndex(spacingSize =&gt; {
    return String(spacingSize.slug) === slug;
  });

  // Returning NaN rather than undefined as undefined makes range control thumb sit in center
  return sliderValue !== -1 ? sliderValue : NaN;
}

/**
 * Determines whether a particular axis has support. If no axis is
 * specified, this function checks if either axis is supported.
 *
 * @param {Array}  sides Supported sides.
 * @param {string} axis  Which axis to check.
 *
 * @return {boolean} Whether there is support for the specified axis or both axes.
 */
function hasAxisSupport(sides, axis) {
  if (!sides || !sides.length) {
    return false;
  }
  const hasHorizontalSupport = sides.includes(&#039;horizontal&#039;) || sides.includes(&#039;left&#039;) &amp;&amp; sides.includes(&#039;right&#039;);
  const hasVerticalSupport = sides.includes(&#039;vertical&#039;) || sides.includes(&#039;top&#039;) &amp;&amp; sides.includes(&#039;bottom&#039;);
  if (axis === &#039;horizontal&#039;) {
    return hasHorizontalSupport;
  }
  if (axis === &#039;vertical&#039;) {
    return hasVerticalSupport;
  }
  return hasHorizontalSupport || hasVerticalSupport;
}

/**
 * Checks if the supported sides are balanced for each axis.
 * - Horizontal - both left and right sides are supported.
 * - Vertical - both top and bottom are supported.
 *
 * @param {Array} sides The supported sides which may be axes as well.
 *
 * @return {boolean} Whether or not the supported sides are balanced.
 */
function hasBalancedSidesSupport(sides = []) {
  const counts = {
    top: 0,
    right: 0,
    bottom: 0,
    left: 0
  };
  sides.forEach(side =&gt; counts[side] += 1);
  return (counts.top + counts.bottom) % 2 === 0 &amp;&amp; (counts.left + counts.right) % 2 === 0;
}

/**
 * Determines which view the SpacingSizesControl should default to on its
 * first render; Axial, Custom, or Single side.
 *
 * @param {Object} values Current side values.
 * @param {Array}  sides  Supported sides.
 *
 * @return {string} View to display.
 */
function getInitialView(values = {}, sides) {
  const {
    top,
    right,
    bottom,
    left
  } = values;
  const sideValues = [top, right, bottom, left].filter(Boolean);

  // Axial ( Horizontal &amp; vertical ).
  // - Has axial side support
  // - Has axial side values which match
  // - Has no values and the supported sides are balanced
  const hasMatchingAxialValues = top === bottom &amp;&amp; left === right &amp;&amp; (!!top || !!left);
  const hasNoValuesAndBalancedSides = !sideValues.length &amp;&amp; hasBalancedSidesSupport(sides);
  const hasOnlyAxialSides = sides?.includes(&#039;horizontal&#039;) &amp;&amp; sides?.includes(&#039;vertical&#039;) &amp;&amp; sides?.length === 2;
  if (hasAxisSupport(sides) &amp;&amp; (hasMatchingAxialValues || hasNoValuesAndBalancedSides)) {
    return VIEWS.axial;
  }

  // Only axial sides are supported and single value defined.
  // - Ensure the side returned is the first side that has a value.
  if (hasOnlyAxialSides &amp;&amp; sideValues.length === 1) {
    let side;
    Object.entries(values).some(([key, value]) =&gt; {
      side = key;
      return value !== undefined;
    });
    return side;
  }

  // Only single side supported and no value defined.
  if (sides?.length === 1 &amp;&amp; !sideValues.length) {
    return sides[0];
  }

  // Default to the Custom (separated sides) view.
  return VIEWS.custom;
}

;// ./node_modules/@wordpress/block-editor/build-module/hooks/gap.js
/**
 * Internal dependencies
 */


/**
 * Returns a BoxControl object value from a given blockGap style value.
 * The string check is for backwards compatibility before Gutenberg supported
 * split gap values (row and column) and the value was a string n + unit.
 *
 * @param {?string | ?Object} blockGapValue A block gap string or axial object value, e.g., &#039;10px&#039; or { top: &#039;10px&#039;, left: &#039;10px&#039;}.
 * @return {Object|null}                    A value to pass to the BoxControl component.
 */
function getGapBoxControlValueFromStyle(blockGapValue) {
  if (!blockGapValue) {
    return null;
  }
  const isValueString = typeof blockGapValue === &#039;string&#039;;
  return {
    top: isValueString ? blockGapValue : blockGapValue?.top,
    left: isValueString ? blockGapValue : blockGapValue?.left
  };
}

/**
 * Returns a CSS value for the `gap` property from a given blockGap style.
 *
 * @param {?string | ?Object} blockGapValue A block gap string or axial object value, e.g., &#039;10px&#039; or { top: &#039;10px&#039;, left: &#039;10px&#039;}.
 * @param {?string}           defaultValue  A default gap value.
 * @return {string|null}                    The concatenated gap value (row and column).
 */
function getGapCSSValue(blockGapValue, defaultValue = &#039;0&#039;) {
  const blockGapBoxControlValue = getGapBoxControlValueFromStyle(blockGapValue);
  if (!blockGapBoxControlValue) {
    return null;
  }
  const row = getSpacingPresetCssVar(blockGapBoxControlValue?.top) || defaultValue;
  const column = getSpacingPresetCssVar(blockGapBoxControlValue?.left) || defaultValue;
  return row === column ? row : `${row} ${column}`;
}

;// ./node_modules/@wordpress/icons/build-module/library/justify-top.js
/**
 * WordPress dependencies
 */


const justifyTop = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;M9 20h6V9H9v11zM4 4v1.5h16V4H4z&quot;
  })
});
/* harmony default export */ const justify_top = (justifyTop);

;// ./node_modules/@wordpress/icons/build-module/library/justify-center-vertical.js
/**
 * WordPress dependencies
 */


const justifyCenterVertical = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;M20 11h-5V4H9v7H4v1.5h5V20h6v-7.5h5z&quot;
  })
});
/* harmony default export */ const justify_center_vertical = (justifyCenterVertical);

;// ./node_modules/@wordpress/icons/build-module/library/justify-bottom.js
/**
 * WordPress dependencies
 */


const justifyBottom = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;M15 4H9v11h6V4zM4 18.5V20h16v-1.5H4z&quot;
  })
});
/* harmony default export */ const justify_bottom = (justifyBottom);

;// ./node_modules/@wordpress/icons/build-module/library/justify-stretch-vertical.js
/**
 * WordPress dependencies
 */


const justifyStretchVertical = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;M4 4L20 4L20 5.5L4 5.5L4 4ZM10 7L14 7L14 17L10 17L10 7ZM20 18.5L4 18.5L4 20L20 20L20 18.5Z&quot;
  })
});
/* harmony default export */ const justify_stretch_vertical = (justifyStretchVertical);

;// ./node_modules/@wordpress/icons/build-module/library/justify-space-between-vertical.js
/**
 * WordPress dependencies
 */


const justifySpaceBetweenVertical = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;M7 4H17V8L7 8V4ZM7 16L17 16V20L7 20V16ZM20 11.25H4V12.75H20V11.25Z&quot;
  })
});
/* harmony default export */ const justify_space_between_vertical = (justifySpaceBetweenVertical);

;// ./node_modules/@wordpress/block-editor/build-module/components/block-vertical-alignment-control/ui.js
/**
 * WordPress dependencies
 */




const BLOCK_ALIGNMENTS_CONTROLS = {
  top: {
    icon: justify_top,
    title: (0,external_wp_i18n_namespaceObject._x)(&#039;Align top&#039;, &#039;Block vertical alignment setting&#039;)
  },
  center: {
    icon: justify_center_vertical,
    title: (0,external_wp_i18n_namespaceObject._x)(&#039;Align middle&#039;, &#039;Block vertical alignment setting&#039;)
  },
  bottom: {
    icon: justify_bottom,
    title: (0,external_wp_i18n_namespaceObject._x)(&#039;Align bottom&#039;, &#039;Block vertical alignment setting&#039;)
  },
  stretch: {
    icon: justify_stretch_vertical,
    title: (0,external_wp_i18n_namespaceObject._x)(&#039;Stretch to fill&#039;, &#039;Block vertical alignment setting&#039;)
  },
  &#039;space-between&#039;: {
    icon: justify_space_between_vertical,
    title: (0,external_wp_i18n_namespaceObject._x)(&#039;Space between&#039;, &#039;Block vertical alignment setting&#039;)
  }
};
const DEFAULT_CONTROLS = [&#039;top&#039;, &#039;center&#039;, &#039;bottom&#039;];
const DEFAULT_CONTROL = &#039;top&#039;;
function BlockVerticalAlignmentUI({
  value,
  onChange,
  controls = DEFAULT_CONTROLS,
  isCollapsed = true,
  isToolbar
}) {
  function applyOrUnset(align) {
    return () =&gt; onChange(value === align ? undefined : align);
  }
  const activeAlignment = BLOCK_ALIGNMENTS_CONTROLS[value];
  const defaultAlignmentControl = BLOCK_ALIGNMENTS_CONTROLS[DEFAULT_CONTROL];
  const UIComponent = isToolbar ? external_wp_components_namespaceObject.ToolbarGroup : external_wp_components_namespaceObject.ToolbarDropdownMenu;
  const extraProps = isToolbar ? {
    isCollapsed
  } : {};
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(UIComponent, {
    icon: activeAlignment ? activeAlignment.icon : defaultAlignmentControl.icon,
    label: (0,external_wp_i18n_namespaceObject._x)(&#039;Change vertical alignment&#039;, &#039;Block vertical alignment setting label&#039;),
    controls: controls.map(control =&gt; {
      return {
        ...BLOCK_ALIGNMENTS_CONTROLS[control],
        isActive: value === control,
        role: isCollapsed ? &#039;menuitemradio&#039; : undefined,
        onClick: applyOrUnset(control)
      };
    }),
    ...extraProps
  });
}

/**
 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/block-vertical-alignment-toolbar/README.md
 */
/* harmony default export */ const ui = (BlockVerticalAlignmentUI);

;// ./node_modules/@wordpress/block-editor/build-module/components/block-vertical-alignment-control/index.js
/**
 * Internal dependencies
 */


const BlockVerticalAlignmentControl = props =&gt; {
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ui, {
    ...props,
    isToolbar: false
  });
};
const BlockVerticalAlignmentToolbar = props =&gt; {
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ui, {
    ...props,
    isToolbar: true
  });
};

/**
 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/block-vertical-alignment-control/README.md
 */


;// ./node_modules/@wordpress/block-editor/build-module/components/justify-content-control/ui.js
/**
 * WordPress dependencies
 */




const icons = {
  left: justify_left,
  center: justify_center,
  right: justify_right,
  &#039;space-between&#039;: justify_space_between,
  stretch: justify_stretch
};
function JustifyContentUI({
  allowedControls = [&#039;left&#039;, &#039;center&#039;, &#039;right&#039;, &#039;space-between&#039;],
  isCollapsed = true,
  onChange,
  value,
  popoverProps,
  isToolbar
}) {
  // If the control is already selected we want a click
  // again on the control to deselect the item, so we
  // call onChange( undefined )
  const handleClick = next =&gt; {
    if (next === value) {
      onChange(undefined);
    } else {
      onChange(next);
    }
  };
  const icon = value ? icons[value] : icons.left;
  const allControls = [{
    name: &#039;left&#039;,
    icon: justify_left,
    title: (0,external_wp_i18n_namespaceObject.__)(&#039;Justify items left&#039;),
    isActive: &#039;left&#039; === value,
    onClick: () =&gt; handleClick(&#039;left&#039;)
  }, {
    name: &#039;center&#039;,
    icon: justify_center,
    title: (0,external_wp_i18n_namespaceObject.__)(&#039;Justify items center&#039;),
    isActive: &#039;center&#039; === value,
    onClick: () =&gt; handleClick(&#039;center&#039;)
  }, {
    name: &#039;right&#039;,
    icon: justify_right,
    title: (0,external_wp_i18n_namespaceObject.__)(&#039;Justify items right&#039;),
    isActive: &#039;right&#039; === value,
    onClick: () =&gt; handleClick(&#039;right&#039;)
  }, {
    name: &#039;space-between&#039;,
    icon: justify_space_between,
    title: (0,external_wp_i18n_namespaceObject.__)(&#039;Space between items&#039;),
    isActive: &#039;space-between&#039; === value,
    onClick: () =&gt; handleClick(&#039;space-between&#039;)
  }, {
    name: &#039;stretch&#039;,
    icon: justify_stretch,
    title: (0,external_wp_i18n_namespaceObject.__)(&#039;Stretch items&#039;),
    isActive: &#039;stretch&#039; === value,
    onClick: () =&gt; handleClick(&#039;stretch&#039;)
  }];
  const UIComponent = isToolbar ? external_wp_components_namespaceObject.ToolbarGroup : external_wp_components_namespaceObject.ToolbarDropdownMenu;
  const extraProps = isToolbar ? {
    isCollapsed
  } : {};
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(UIComponent, {
    icon: icon,
    popoverProps: popoverProps,
    label: (0,external_wp_i18n_namespaceObject.__)(&#039;Change items justification&#039;),
    controls: allControls.filter(elem =&gt; allowedControls.includes(elem.name)),
    ...extraProps
  });
}
/* harmony default export */ const justify_content_control_ui = (JustifyContentUI);

;// ./node_modules/@wordpress/block-editor/build-module/components/justify-content-control/index.js
/**
 * Internal dependencies
 */


const JustifyContentControl = props =&gt; {
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(justify_content_control_ui, {
    ...props,
    isToolbar: false
  });
};
const JustifyToolbar = props =&gt; {
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(justify_content_control_ui, {
    ...props,
    isToolbar: true
  });
};

/**
 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/justify-content-control/README.md
 */


;// ./node_modules/@wordpress/block-editor/build-module/layouts/flex.js
/**
 * WordPress dependencies
 */




/**
 * Internal dependencies
 */






// Used with the default, horizontal flex orientation.

const justifyContentMap = {
  left: &#039;flex-start&#039;,
  right: &#039;flex-end&#039;,
  center: &#039;center&#039;,
  &#039;space-between&#039;: &#039;space-between&#039;
};

// Used with the vertical (column) flex orientation.
const alignItemsMap = {
  left: &#039;flex-start&#039;,
  right: &#039;flex-end&#039;,
  center: &#039;center&#039;,
  stretch: &#039;stretch&#039;
};
const verticalAlignmentMap = {
  top: &#039;flex-start&#039;,
  center: &#039;center&#039;,
  bottom: &#039;flex-end&#039;,
  stretch: &#039;stretch&#039;,
  &#039;space-between&#039;: &#039;space-between&#039;
};
const flexWrapOptions = [&#039;wrap&#039;, &#039;nowrap&#039;];
/* harmony default export */ const flex = ({
  name: &#039;flex&#039;,
  label: (0,external_wp_i18n_namespaceObject.__)(&#039;Flex&#039;),
  inspectorControls: function FlexLayoutInspectorControls({
    layout = {},
    onChange,
    layoutBlockSupport = {}
  }) {
    const {
      allowOrientation = true,
      allowJustification = true
    } = layoutBlockSupport;
    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.Flex, {
        children: [allowJustification &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FlexItem, {
          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(FlexLayoutJustifyContentControl, {
            layout: layout,
            onChange: onChange
          })
        }), allowOrientation &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FlexItem, {
          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(OrientationControl, {
            layout: layout,
            onChange: onChange
          })
        })]
      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(FlexWrapControl, {
        layout: layout,
        onChange: onChange
      })]
    });
  },
  toolBarControls: function FlexLayoutToolbarControls({
    layout = {},
    onChange,
    layoutBlockSupport
  }) {
    const {
      allowVerticalAlignment = true,
      allowJustification = true
    } = layoutBlockSupport;
    if (!allowJustification &amp;&amp; !allowVerticalAlignment) {
      return null;
    }
    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(block_controls, {
      group: &quot;block&quot;,
      __experimentalShareWithChildBlocks: true,
      children: [allowJustification &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(FlexLayoutJustifyContentControl, {
        layout: layout,
        onChange: onChange,
        isToolbar: true
      }), allowVerticalAlignment &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(FlexLayoutVerticalAlignmentControl, {
        layout: layout,
        onChange: onChange
      })]
    });
  },
  getLayoutStyle: function getLayoutStyle({
    selector,
    layout,
    style,
    blockName,
    hasBlockGapSupport,
    layoutDefinitions = LAYOUT_DEFINITIONS
  }) {
    const {
      orientation = &#039;horizontal&#039;
    } = layout;

    // If a block&#039;s block.json skips serialization for spacing or spacing.blockGap,
    // don&#039;t apply the user-defined value to the styles.
    const blockGapValue = style?.spacing?.blockGap &amp;&amp; !shouldSkipSerialization(blockName, &#039;spacing&#039;, &#039;blockGap&#039;) ? getGapCSSValue(style?.spacing?.blockGap, &#039;0.5em&#039;) : undefined;
    const justifyContent = justifyContentMap[layout.justifyContent];
    const flexWrap = flexWrapOptions.includes(layout.flexWrap) ? layout.flexWrap : &#039;wrap&#039;;
    const verticalAlignment = verticalAlignmentMap[layout.verticalAlignment];
    const alignItems = alignItemsMap[layout.justifyContent] || alignItemsMap.left;
    let output = &#039;&#039;;
    const rules = [];
    if (flexWrap &amp;&amp; flexWrap !== &#039;wrap&#039;) {
      rules.push(`flex-wrap: ${flexWrap}`);
    }
    if (orientation === &#039;horizontal&#039;) {
      if (verticalAlignment) {
        rules.push(`align-items: ${verticalAlignment}`);
      }
      if (justifyContent) {
        rules.push(`justify-content: ${justifyContent}`);
      }
    } else {
      if (verticalAlignment) {
        rules.push(`justify-content: ${verticalAlignment}`);
      }
      rules.push(&#039;flex-direction: column&#039;);
      rules.push(`align-items: ${alignItems}`);
    }
    if (rules.length) {
      output = `${appendSelectors(selector)} {
				${rules.join(&#039;; &#039;)};
			}`;
    }

    // Output blockGap styles based on rules contained in layout definitions in theme.json.
    if (hasBlockGapSupport &amp;&amp; blockGapValue) {
      output += getBlockGapCSS(selector, layoutDefinitions, &#039;flex&#039;, blockGapValue);
    }
    return output;
  },
  getOrientation(layout) {
    const {
      orientation = &#039;horizontal&#039;
    } = layout;
    return orientation;
  },
  getAlignments() {
    return [];
  }
});
function FlexLayoutVerticalAlignmentControl({
  layout,
  onChange
}) {
  const {
    orientation = &#039;horizontal&#039;
  } = layout;
  const defaultVerticalAlignment = orientation === &#039;horizontal&#039; ? verticalAlignmentMap.center : verticalAlignmentMap.top;
  const {
    verticalAlignment = defaultVerticalAlignment
  } = layout;
  const onVerticalAlignmentChange = value =&gt; {
    onChange({
      ...layout,
      verticalAlignment: value
    });
  };
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockVerticalAlignmentControl, {
    onChange: onVerticalAlignmentChange,
    value: verticalAlignment,
    controls: orientation === &#039;horizontal&#039; ? [&#039;top&#039;, &#039;center&#039;, &#039;bottom&#039;, &#039;stretch&#039;] : [&#039;top&#039;, &#039;center&#039;, &#039;bottom&#039;, &#039;space-between&#039;]
  });
}
const POPOVER_PROPS = {
  placement: &#039;bottom-start&#039;
};
function FlexLayoutJustifyContentControl({
  layout,
  onChange,
  isToolbar = false
}) {
  const {
    justifyContent = &#039;left&#039;,
    orientation = &#039;horizontal&#039;
  } = layout;
  const onJustificationChange = value =&gt; {
    onChange({
      ...layout,
      justifyContent: value
    });
  };
  const allowedControls = [&#039;left&#039;, &#039;center&#039;, &#039;right&#039;];
  if (orientation === &#039;horizontal&#039;) {
    allowedControls.push(&#039;space-between&#039;);
  } else {
    allowedControls.push(&#039;stretch&#039;);
  }
  if (isToolbar) {
    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(JustifyContentControl, {
      allowedControls: allowedControls,
      value: justifyContent,
      onChange: onJustificationChange,
      popoverProps: POPOVER_PROPS
    });
  }
  const justificationOptions = [{
    value: &#039;left&#039;,
    icon: justify_left,
    label: (0,external_wp_i18n_namespaceObject.__)(&#039;Justify items left&#039;)
  }, {
    value: &#039;center&#039;,
    icon: justify_center,
    label: (0,external_wp_i18n_namespaceObject.__)(&#039;Justify items center&#039;)
  }, {
    value: &#039;right&#039;,
    icon: justify_right,
    label: (0,external_wp_i18n_namespaceObject.__)(&#039;Justify items right&#039;)
  }];
  if (orientation === &#039;horizontal&#039;) {
    justificationOptions.push({
      value: &#039;space-between&#039;,
      icon: justify_space_between,
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Space between items&#039;)
    });
  } else {
    justificationOptions.push({
      value: &#039;stretch&#039;,
      icon: justify_stretch,
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Stretch items&#039;)
    });
  }
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControl, {
    __next40pxDefaultSize: true,
    __nextHasNoMarginBottom: true,
    label: (0,external_wp_i18n_namespaceObject.__)(&#039;Justification&#039;),
    value: justifyContent,
    onChange: onJustificationChange,
    className: &quot;block-editor-hooks__flex-layout-justification-controls&quot;,
    children: justificationOptions.map(({
      value,
      icon,
      label
    }) =&gt; {
      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControlOptionIcon, {
        value: value,
        icon: icon,
        label: label
      }, value);
    })
  });
}
function FlexWrapControl({
  layout,
  onChange
}) {
  const {
    flexWrap = &#039;wrap&#039;
  } = layout;
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToggleControl, {
    __nextHasNoMarginBottom: true,
    label: (0,external_wp_i18n_namespaceObject.__)(&#039;Allow to wrap to multiple lines&#039;),
    onChange: value =&gt; {
      onChange({
        ...layout,
        flexWrap: value ? &#039;wrap&#039; : &#039;nowrap&#039;
      });
    },
    checked: flexWrap === &#039;wrap&#039;
  });
}
function OrientationControl({
  layout,
  onChange
}) {
  const {
    orientation = &#039;horizontal&#039;,
    verticalAlignment,
    justifyContent
  } = layout;
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalToggleGroupControl, {
    __next40pxDefaultSize: true,
    __nextHasNoMarginBottom: true,
    className: &quot;block-editor-hooks__flex-layout-orientation-controls&quot;,
    label: (0,external_wp_i18n_namespaceObject.__)(&#039;Orientation&#039;),
    value: orientation,
    onChange: value =&gt; {
      // Make sure the vertical alignment and justification are compatible with the new orientation.
      let newVerticalAlignment = verticalAlignment;
      let newJustification = justifyContent;
      if (value === &#039;horizontal&#039;) {
        if (verticalAlignment === &#039;space-between&#039;) {
          newVerticalAlignment = &#039;center&#039;;
        }
        if (justifyContent === &#039;stretch&#039;) {
          newJustification = &#039;left&#039;;
        }
      } else {
        if (verticalAlignment === &#039;stretch&#039;) {
          newVerticalAlignment = &#039;top&#039;;
        }
        if (justifyContent === &#039;space-between&#039;) {
          newJustification = &#039;left&#039;;
        }
      }
      return onChange({
        ...layout,
        orientation: value,
        verticalAlignment: newVerticalAlignment,
        justifyContent: newJustification
      });
    },
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControlOptionIcon, {
      icon: arrow_right,
      value: &quot;horizontal&quot;,
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Horizontal&#039;)
    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControlOptionIcon, {
      icon: arrow_down,
      value: &quot;vertical&quot;,
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Vertical&#039;)
    })]
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/layouts/flow.js
/**
 * WordPress dependencies
 */


/**
 * Internal dependencies
 */




/* harmony default export */ const flow = ({
  name: &#039;default&#039;,
  label: (0,external_wp_i18n_namespaceObject.__)(&#039;Flow&#039;),
  inspectorControls: function DefaultLayoutInspectorControls() {
    return null;
  },
  toolBarControls: function DefaultLayoutToolbarControls() {
    return null;
  },
  getLayoutStyle: function getLayoutStyle({
    selector,
    style,
    blockName,
    hasBlockGapSupport,
    layoutDefinitions = LAYOUT_DEFINITIONS
  }) {
    const blockGapStyleValue = getGapCSSValue(style?.spacing?.blockGap);

    // If a block&#039;s block.json skips serialization for spacing or
    // spacing.blockGap, don&#039;t apply the user-defined value to the styles.
    let blockGapValue = &#039;&#039;;
    if (!shouldSkipSerialization(blockName, &#039;spacing&#039;, &#039;blockGap&#039;)) {
      // If an object is provided only use the &#039;top&#039; value for this kind of gap.
      if (blockGapStyleValue?.top) {
        blockGapValue = getGapCSSValue(blockGapStyleValue?.top);
      } else if (typeof blockGapStyleValue === &#039;string&#039;) {
        blockGapValue = getGapCSSValue(blockGapStyleValue);
      }
    }
    let output = &#039;&#039;;

    // Output blockGap styles based on rules contained in layout definitions in theme.json.
    if (hasBlockGapSupport &amp;&amp; blockGapValue) {
      output += getBlockGapCSS(selector, layoutDefinitions, &#039;default&#039;, blockGapValue);
    }
    return output;
  },
  getOrientation() {
    return &#039;vertical&#039;;
  },
  getAlignments(layout, isBlockBasedTheme) {
    const alignmentInfo = getAlignmentsInfo(layout);
    if (layout.alignments !== undefined) {
      if (!layout.alignments.includes(&#039;none&#039;)) {
        layout.alignments.unshift(&#039;none&#039;);
      }
      return layout.alignments.map(alignment =&gt; ({
        name: alignment,
        info: alignmentInfo[alignment]
      }));
    }
    const alignments = [{
      name: &#039;left&#039;
    }, {
      name: &#039;center&#039;
    }, {
      name: &#039;right&#039;
    }];

    // This is for backwards compatibility with hybrid themes.
    if (!isBlockBasedTheme) {
      const {
        contentSize,
        wideSize
      } = layout;
      if (contentSize) {
        alignments.unshift({
          name: &#039;full&#039;
        });
      }
      if (wideSize) {
        alignments.unshift({
          name: &#039;wide&#039;,
          info: alignmentInfo.wide
        });
      }
    }
    alignments.unshift({
      name: &#039;none&#039;,
      info: alignmentInfo.none
    });
    return alignments;
  }
});

;// ./node_modules/@wordpress/icons/build-module/icon/index.js
/**
 * WordPress dependencies
 */


/** @typedef {{icon: JSX.Element, size?: number} &amp; import(&#039;@wordpress/primitives&#039;).SVGProps} IconProps */

/**
 * Return an SVG icon.
 *
 * @param {IconProps}                                 props icon is the SVG component to render
 *                                                          size is a number specifying the icon size in pixels
 *                                                          Other props will be passed to wrapped SVG component
 * @param {import(&#039;react&#039;).ForwardedRef&lt;HTMLElement&gt;} ref   The forwarded ref to the SVG element.
 *
 * @return {JSX.Element}  Icon component
 */
function Icon({
  icon,
  size = 24,
  ...props
}, ref) {
  return (0,external_wp_element_namespaceObject.cloneElement)(icon, {
    width: size,
    height: size,
    ...props,
    ref
  });
}
/* harmony default export */ const build_module_icon = ((0,external_wp_element_namespaceObject.forwardRef)(Icon));

;// ./node_modules/@wordpress/icons/build-module/library/align-none.js
/**
 * WordPress dependencies
 */


const alignNone = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;M19 5.5H5V4h14v1.5ZM19 20H5v-1.5h14V20ZM5 9h14v6H5V9Z&quot;
  })
});
/* harmony default export */ const align_none = (alignNone);

;// ./node_modules/@wordpress/icons/build-module/library/stretch-wide.js
/**
 * WordPress dependencies
 */


const stretchWide = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;M16 5.5H8V4h8v1.5ZM16 20H8v-1.5h8V20ZM5 9h14v6H5V9Z&quot;
  })
});
/* harmony default export */ const stretch_wide = (stretchWide);

;// ./node_modules/@wordpress/block-editor/build-module/layouts/constrained.js
/**
 * WordPress dependencies
 */





/**
 * Internal dependencies
 */







/* harmony default export */ const constrained = ({
  name: &#039;constrained&#039;,
  label: (0,external_wp_i18n_namespaceObject.__)(&#039;Constrained&#039;),
  inspectorControls: function DefaultLayoutInspectorControls({
    layout,
    onChange,
    layoutBlockSupport = {}
  }) {
    const {
      wideSize,
      contentSize,
      justifyContent = &#039;center&#039;
    } = layout;
    const {
      allowJustification = true,
      allowCustomContentAndWideSize = true
    } = layoutBlockSupport;
    const onJustificationChange = value =&gt; {
      onChange({
        ...layout,
        justifyContent: value
      });
    };
    const justificationOptions = [{
      value: &#039;left&#039;,
      icon: justify_left,
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Justify items left&#039;)
    }, {
      value: &#039;center&#039;,
      icon: justify_center,
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Justify items center&#039;)
    }, {
      value: &#039;right&#039;,
      icon: justify_right,
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Justify items right&#039;)
    }];
    const [availableUnits] = use_settings_useSettings(&#039;spacing.units&#039;);
    const units = (0,external_wp_components_namespaceObject.__experimentalUseCustomUnits)({
      availableUnits: availableUnits || [&#039;%&#039;, &#039;px&#039;, &#039;em&#039;, &#039;rem&#039;, &#039;vw&#039;]
    });
    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalVStack, {
      spacing: 4,
      className: &quot;block-editor-hooks__layout-constrained&quot;,
      children: [allowCustomContentAndWideSize &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalUnitControl, {
          __next40pxDefaultSize: true,
          label: (0,external_wp_i18n_namespaceObject.__)(&#039;Content width&#039;),
          labelPosition: &quot;top&quot;,
          value: contentSize || wideSize || &#039;&#039;,
          onChange: nextWidth =&gt; {
            nextWidth = 0 &gt; parseFloat(nextWidth) ? &#039;0&#039; : nextWidth;
            onChange({
              ...layout,
              contentSize: nextWidth
            });
          },
          units: units,
          prefix: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalInputControlPrefixWrapper, {
            variant: &quot;icon&quot;,
            children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(build_module_icon, {
              icon: align_none
            })
          })
        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalUnitControl, {
          __next40pxDefaultSize: true,
          label: (0,external_wp_i18n_namespaceObject.__)(&#039;Wide width&#039;),
          labelPosition: &quot;top&quot;,
          value: wideSize || contentSize || &#039;&#039;,
          onChange: nextWidth =&gt; {
            nextWidth = 0 &gt; parseFloat(nextWidth) ? &#039;0&#039; : nextWidth;
            onChange({
              ...layout,
              wideSize: nextWidth
            });
          },
          units: units,
          prefix: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalInputControlPrefixWrapper, {
            variant: &quot;icon&quot;,
            children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(build_module_icon, {
              icon: stretch_wide
            })
          })
        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;p&quot;, {
          className: &quot;block-editor-hooks__layout-constrained-helptext&quot;,
          children: (0,external_wp_i18n_namespaceObject.__)(&#039;Customize the width for all elements that are assigned to the center or wide columns.&#039;)
        })]
      }), allowJustification &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControl, {
        __next40pxDefaultSize: true,
        __nextHasNoMarginBottom: true,
        label: (0,external_wp_i18n_namespaceObject.__)(&#039;Justification&#039;),
        value: justifyContent,
        onChange: onJustificationChange,
        children: justificationOptions.map(({
          value,
          icon,
          label
        }) =&gt; {
          return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControlOptionIcon, {
            value: value,
            icon: icon,
            label: label
          }, value);
        })
      })]
    });
  },
  toolBarControls: function DefaultLayoutToolbarControls({
    layout = {},
    onChange,
    layoutBlockSupport
  }) {
    const {
      allowJustification = true
    } = layoutBlockSupport;
    if (!allowJustification) {
      return null;
    }
    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_controls, {
      group: &quot;block&quot;,
      __experimentalShareWithChildBlocks: true,
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(DefaultLayoutJustifyContentControl, {
        layout: layout,
        onChange: onChange
      })
    });
  },
  getLayoutStyle: function getLayoutStyle({
    selector,
    layout = {},
    style,
    blockName,
    hasBlockGapSupport,
    layoutDefinitions = LAYOUT_DEFINITIONS
  }) {
    const {
      contentSize,
      wideSize,
      justifyContent
    } = layout;
    const blockGapStyleValue = getGapCSSValue(style?.spacing?.blockGap);

    // If a block&#039;s block.json skips serialization for spacing or
    // spacing.blockGap, don&#039;t apply the user-defined value to the styles.
    let blockGapValue = &#039;&#039;;
    if (!shouldSkipSerialization(blockName, &#039;spacing&#039;, &#039;blockGap&#039;)) {
      // If an object is provided only use the &#039;top&#039; value for this kind of gap.
      if (blockGapStyleValue?.top) {
        blockGapValue = getGapCSSValue(blockGapStyleValue?.top);
      } else if (typeof blockGapStyleValue === &#039;string&#039;) {
        blockGapValue = getGapCSSValue(blockGapStyleValue);
      }
    }
    const marginLeft = justifyContent === &#039;left&#039; ? &#039;0 !important&#039; : &#039;auto !important&#039;;
    const marginRight = justifyContent === &#039;right&#039; ? &#039;0 !important&#039; : &#039;auto !important&#039;;
    let output = !!contentSize || !!wideSize ? `
					${appendSelectors(selector, &#039;&gt; :where(:not(.alignleft):not(.alignright):not(.alignfull))&#039;)} {
						max-width: ${contentSize !== null &amp;&amp; contentSize !== void 0 ? contentSize : wideSize};
						margin-left: ${marginLeft};
						margin-right: ${marginRight};
					}
					${appendSelectors(selector, &#039;&gt; .alignwide&#039;)}  {
						max-width: ${wideSize !== null &amp;&amp; wideSize !== void 0 ? wideSize : contentSize};
					}
					${appendSelectors(selector, &#039;&gt; .alignfull&#039;)} {
						max-width: none;
					}
				` : &#039;&#039;;
    if (justifyContent === &#039;left&#039;) {
      output += `${appendSelectors(selector, &#039;&gt; :where(:not(.alignleft):not(.alignright):not(.alignfull))&#039;)}
			{ margin-left: ${marginLeft}; }`;
    } else if (justifyContent === &#039;right&#039;) {
      output += `${appendSelectors(selector, &#039;&gt; :where(:not(.alignleft):not(.alignright):not(.alignfull))&#039;)}
			{ margin-right: ${marginRight}; }`;
    }

    // If there is custom padding, add negative margins for alignfull blocks.
    if (style?.spacing?.padding) {
      // The style object might be storing a preset so we need to make sure we get a usable value.
      const paddingValues = (0,external_wp_styleEngine_namespaceObject.getCSSRules)(style);
      paddingValues.forEach(rule =&gt; {
        if (rule.key === &#039;paddingRight&#039;) {
          // Add unit if 0, to avoid calc(0 * -1) which is invalid.
          const paddingRightValue = rule.value === &#039;0&#039; ? &#039;0px&#039; : rule.value;
          output += `
					${appendSelectors(selector, &#039;&gt; .alignfull&#039;)} {
						margin-right: calc(${paddingRightValue} * -1);
					}
					`;
        } else if (rule.key === &#039;paddingLeft&#039;) {
          // Add unit if 0, to avoid calc(0 * -1) which is invalid.
          const paddingLeftValue = rule.value === &#039;0&#039; ? &#039;0px&#039; : rule.value;
          output += `
					${appendSelectors(selector, &#039;&gt; .alignfull&#039;)} {
						margin-left: calc(${paddingLeftValue} * -1);
					}
					`;
        }
      });
    }

    // Output blockGap styles based on rules contained in layout definitions in theme.json.
    if (hasBlockGapSupport &amp;&amp; blockGapValue) {
      output += getBlockGapCSS(selector, layoutDefinitions, &#039;constrained&#039;, blockGapValue);
    }
    return output;
  },
  getOrientation() {
    return &#039;vertical&#039;;
  },
  getAlignments(layout) {
    const alignmentInfo = getAlignmentsInfo(layout);
    if (layout.alignments !== undefined) {
      if (!layout.alignments.includes(&#039;none&#039;)) {
        layout.alignments.unshift(&#039;none&#039;);
      }
      return layout.alignments.map(alignment =&gt; ({
        name: alignment,
        info: alignmentInfo[alignment]
      }));
    }
    const {
      contentSize,
      wideSize
    } = layout;
    const alignments = [{
      name: &#039;left&#039;
    }, {
      name: &#039;center&#039;
    }, {
      name: &#039;right&#039;
    }];
    if (contentSize) {
      alignments.unshift({
        name: &#039;full&#039;
      });
    }
    if (wideSize) {
      alignments.unshift({
        name: &#039;wide&#039;,
        info: alignmentInfo.wide
      });
    }
    alignments.unshift({
      name: &#039;none&#039;,
      info: alignmentInfo.none
    });
    return alignments;
  }
});
const constrained_POPOVER_PROPS = {
  placement: &#039;bottom-start&#039;
};
function DefaultLayoutJustifyContentControl({
  layout,
  onChange
}) {
  const {
    justifyContent = &#039;center&#039;
  } = layout;
  const onJustificationChange = value =&gt; {
    onChange({
      ...layout,
      justifyContent: value
    });
  };
  const allowedControls = [&#039;left&#039;, &#039;center&#039;, &#039;right&#039;];
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(JustifyContentControl, {
    allowedControls: allowedControls,
    value: justifyContent,
    onChange: onJustificationChange,
    popoverProps: constrained_POPOVER_PROPS
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/layouts/grid.js
/**
 * WordPress dependencies
 */




/**
 * Internal dependencies
 */





const RANGE_CONTROL_MAX_VALUES = {
  px: 600,
  &#039;%&#039;: 100,
  vw: 100,
  vh: 100,
  em: 38,
  rem: 38,
  svw: 100,
  lvw: 100,
  dvw: 100,
  svh: 100,
  lvh: 100,
  dvh: 100,
  vi: 100,
  svi: 100,
  lvi: 100,
  dvi: 100,
  vb: 100,
  svb: 100,
  lvb: 100,
  dvb: 100,
  vmin: 100,
  svmin: 100,
  lvmin: 100,
  dvmin: 100,
  vmax: 100,
  svmax: 100,
  lvmax: 100,
  dvmax: 100
};
const units = [{
  value: &#039;px&#039;,
  label: &#039;px&#039;,
  default: 0
}, {
  value: &#039;rem&#039;,
  label: &#039;rem&#039;,
  default: 0
}, {
  value: &#039;em&#039;,
  label: &#039;em&#039;,
  default: 0
}];
/* harmony default export */ const grid = ({
  name: &#039;grid&#039;,
  label: (0,external_wp_i18n_namespaceObject.__)(&#039;Grid&#039;),
  inspectorControls: function GridLayoutInspectorControls({
    layout = {},
    onChange,
    layoutBlockSupport = {}
  }) {
    const {
      allowSizingOnChildren = false
    } = layoutBlockSupport;

    // In the experiment we want to also show column control in Auto mode, and
    // the minimum width control in Manual mode.
    const showColumnsControl = window.__experimentalEnableGridInteractivity || !!layout?.columnCount;
    const showMinWidthControl = window.__experimentalEnableGridInteractivity || !layout?.columnCount;
    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(GridLayoutTypeControl, {
        layout: layout,
        onChange: onChange
      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalVStack, {
        spacing: 4,
        children: [showColumnsControl &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(GridLayoutColumnsAndRowsControl, {
          layout: layout,
          onChange: onChange,
          allowSizingOnChildren: allowSizingOnChildren
        }), showMinWidthControl &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(GridLayoutMinimumWidthControl, {
          layout: layout,
          onChange: onChange
        })]
      })]
    });
  },
  toolBarControls: function GridLayoutToolbarControls() {
    return null;
  },
  getLayoutStyle: function getLayoutStyle({
    selector,
    layout,
    style,
    blockName,
    hasBlockGapSupport,
    layoutDefinitions = LAYOUT_DEFINITIONS
  }) {
    const {
      minimumColumnWidth = null,
      columnCount = null,
      rowCount = null
    } = layout;

    // Check that the grid layout attributes are of the correct type, so that we don&#039;t accidentally
    // write code that stores a string attribute instead of a number.
    if (false) {}

    // If a block&#039;s block.json skips serialization for spacing or spacing.blockGap,
    // don&#039;t apply the user-defined value to the styles.
    const blockGapValue = style?.spacing?.blockGap &amp;&amp; !shouldSkipSerialization(blockName, &#039;spacing&#039;, &#039;blockGap&#039;) ? getGapCSSValue(style?.spacing?.blockGap, &#039;0.5em&#039;) : undefined;
    let output = &#039;&#039;;
    const rules = [];
    if (minimumColumnWidth &amp;&amp; columnCount &gt; 0) {
      const maxValue = `max(${minimumColumnWidth}, ( 100% - (${blockGapValue || &#039;1.2rem&#039;}*${columnCount - 1}) ) / ${columnCount})`;
      rules.push(`grid-template-columns: repeat(auto-fill, minmax(${maxValue}, 1fr))`, `container-type: inline-size`);
      if (rowCount) {
        rules.push(`grid-template-rows: repeat(${rowCount}, minmax(1rem, auto))`);
      }
    } else if (columnCount) {
      rules.push(`grid-template-columns: repeat(${columnCount}, minmax(0, 1fr))`);
      if (rowCount) {
        rules.push(`grid-template-rows: repeat(${rowCount}, minmax(1rem, auto))`);
      }
    } else {
      rules.push(`grid-template-columns: repeat(auto-fill, minmax(min(${minimumColumnWidth || &#039;12rem&#039;}, 100%), 1fr))`, &#039;container-type: inline-size&#039;);
    }
    if (rules.length) {
      // Reason to disable: the extra line breaks added by prettier mess with the unit tests.
      // eslint-disable-next-line prettier/prettier
      output = `${appendSelectors(selector)} { ${rules.join(&#039;; &#039;)}; }`;
    }

    // Output blockGap styles based on rules contained in layout definitions in theme.json.
    if (hasBlockGapSupport &amp;&amp; blockGapValue) {
      output += getBlockGapCSS(selector, layoutDefinitions, &#039;grid&#039;, blockGapValue);
    }
    return output;
  },
  getOrientation() {
    return &#039;horizontal&#039;;
  },
  getAlignments() {
    return [];
  }
});

// Enables setting minimum width of grid items.
function GridLayoutMinimumWidthControl({
  layout,
  onChange
}) {
  const {
    minimumColumnWidth,
    columnCount,
    isManualPlacement
  } = layout;
  const defaultValue = isManualPlacement || columnCount ? null : &#039;12rem&#039;;
  const value = minimumColumnWidth || defaultValue;
  const [quantity, unit = &#039;rem&#039;] = (0,external_wp_components_namespaceObject.__experimentalParseQuantityAndUnitFromRawValue)(value);
  const handleSliderChange = next =&gt; {
    onChange({
      ...layout,
      minimumColumnWidth: [next, unit].join(&#039;&#039;)
    });
  };

  // Mostly copied from HeightControl.
  const handleUnitChange = newUnit =&gt; {
    // Attempt to smooth over differences between currentUnit and newUnit.
    // This should slightly improve the experience of switching between unit types.
    let newValue;
    if ([&#039;em&#039;, &#039;rem&#039;].includes(newUnit) &amp;&amp; unit === &#039;px&#039;) {
      // Convert pixel value to an approximate of the new unit, assuming a root size of 16px.
      newValue = (quantity / 16).toFixed(2) + newUnit;
    } else if ([&#039;em&#039;, &#039;rem&#039;].includes(unit) &amp;&amp; newUnit === &#039;px&#039;) {
      // Convert to pixel value assuming a root size of 16px.
      newValue = Math.round(quantity * 16) + newUnit;
    }
    onChange({
      ...layout,
      minimumColumnWidth: newValue
    });
  };
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;fieldset&quot;, {
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.BaseControl.VisualLabel, {
      as: &quot;legend&quot;,
      children: (0,external_wp_i18n_namespaceObject.__)(&#039;Minimum column width&#039;)
    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.Flex, {
      gap: 4,
      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FlexItem, {
        isBlock: true,
        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalUnitControl, {
          size: &quot;__unstable-large&quot;,
          onChange: newValue =&gt; {
            onChange({
              ...layout,
              minimumColumnWidth: newValue === &#039;&#039; ? undefined : newValue
            });
          },
          onUnitChange: handleUnitChange,
          value: value,
          units: units,
          min: 0,
          label: (0,external_wp_i18n_namespaceObject.__)(&#039;Minimum column width&#039;),
          hideLabelFromVision: true
        })
      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FlexItem, {
        isBlock: true,
        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.RangeControl, {
          __next40pxDefaultSize: true,
          __nextHasNoMarginBottom: true,
          onChange: handleSliderChange,
          value: quantity || 0,
          min: 0,
          max: RANGE_CONTROL_MAX_VALUES[unit] || 600,
          withInputField: false,
          label: (0,external_wp_i18n_namespaceObject.__)(&#039;Minimum column width&#039;),
          hideLabelFromVision: true
        })
      })]
    })]
  });
}

// Enables setting number of grid columns
function GridLayoutColumnsAndRowsControl({
  layout,
  onChange,
  allowSizingOnChildren
}) {
  // If the grid interactivity experiment is enabled, allow unsetting the column count.
  const defaultColumnCount = window.__experimentalEnableGridInteractivity ? undefined : 3;
  const {
    columnCount = defaultColumnCount,
    rowCount,
    isManualPlacement
  } = layout;
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_ReactJSXRuntime_namespaceObject.Fragment, {
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;fieldset&quot;, {
      children: [(!window.__experimentalEnableGridInteractivity || !isManualPlacement) &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.BaseControl.VisualLabel, {
        as: &quot;legend&quot;,
        children: (0,external_wp_i18n_namespaceObject.__)(&#039;Columns&#039;)
      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.Flex, {
        gap: 4,
        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FlexItem, {
          isBlock: true,
          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalNumberControl, {
            size: &quot;__unstable-large&quot;,
            onChange: value =&gt; {
              if (window.__experimentalEnableGridInteractivity) {
                // Allow unsetting the column count when in auto mode.
                const defaultNewColumnCount = isManualPlacement ? 1 : undefined;
                const newColumnCount = value === &#039;&#039; || value === &#039;0&#039; ? defaultNewColumnCount : parseInt(value, 10);
                onChange({
                  ...layout,
                  columnCount: newColumnCount
                });
              } else {
                // Don&#039;t allow unsetting the column count.
                const newColumnCount = value === &#039;&#039; || value === &#039;0&#039; ? 1 : parseInt(value, 10);
                onChange({
                  ...layout,
                  columnCount: newColumnCount
                });
              }
            },
            value: columnCount,
            min: 1,
            label: (0,external_wp_i18n_namespaceObject.__)(&#039;Columns&#039;),
            hideLabelFromVision: !window.__experimentalEnableGridInteractivity || !isManualPlacement
          })
        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FlexItem, {
          isBlock: true,
          children: window.__experimentalEnableGridInteractivity &amp;&amp; allowSizingOnChildren &amp;&amp; isManualPlacement ? /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalNumberControl, {
            size: &quot;__unstable-large&quot;,
            onChange: value =&gt; {
              // Don&#039;t allow unsetting the row count.
              const newRowCount = value === &#039;&#039; || value === &#039;0&#039; ? 1 : parseInt(value, 10);
              onChange({
                ...layout,
                rowCount: newRowCount
              });
            },
            value: rowCount,
            min: 1,
            label: (0,external_wp_i18n_namespaceObject.__)(&#039;Rows&#039;)
          }) : /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.RangeControl, {
            __next40pxDefaultSize: true,
            __nextHasNoMarginBottom: true,
            value: columnCount !== null &amp;&amp; columnCount !== void 0 ? columnCount : 1,
            onChange: value =&gt; onChange({
              ...layout,
              columnCount: value === &#039;&#039; || value === &#039;0&#039; ? 1 : value
            }),
            min: 1,
            max: 16,
            withInputField: false,
            label: (0,external_wp_i18n_namespaceObject.__)(&#039;Columns&#039;),
            hideLabelFromVision: true
          })
        })]
      })]
    })
  });
}

// Enables switching between grid types
function GridLayoutTypeControl({
  layout,
  onChange
}) {
  const {
    columnCount,
    rowCount,
    minimumColumnWidth,
    isManualPlacement
  } = layout;

  /**
   * When switching, temporarily save any custom values set on the
   * previous type so we can switch back without loss.
   */
  const [tempColumnCount, setTempColumnCount] = (0,external_wp_element_namespaceObject.useState)(columnCount || 3);
  const [tempRowCount, setTempRowCount] = (0,external_wp_element_namespaceObject.useState)(rowCount);
  const [tempMinimumColumnWidth, setTempMinimumColumnWidth] = (0,external_wp_element_namespaceObject.useState)(minimumColumnWidth || &#039;12rem&#039;);
  const gridPlacement = isManualPlacement || !!columnCount &amp;&amp; !window.__experimentalEnableGridInteractivity ? &#039;manual&#039; : &#039;auto&#039;;
  const onChangeType = value =&gt; {
    if (value === &#039;manual&#039;) {
      setTempMinimumColumnWidth(minimumColumnWidth || &#039;12rem&#039;);
    } else {
      setTempColumnCount(columnCount || 3);
      setTempRowCount(rowCount);
    }
    onChange({
      ...layout,
      columnCount: value === &#039;manual&#039; ? tempColumnCount : null,
      rowCount: value === &#039;manual&#039; &amp;&amp; window.__experimentalEnableGridInteractivity ? tempRowCount : undefined,
      isManualPlacement: value === &#039;manual&#039; &amp;&amp; window.__experimentalEnableGridInteractivity ? true : undefined,
      minimumColumnWidth: value === &#039;auto&#039; ? tempMinimumColumnWidth : null
    });
  };
  const helpText = gridPlacement === &#039;manual&#039; ? (0,external_wp_i18n_namespaceObject.__)(&#039;Grid items can be manually placed in any position on the grid.&#039;) : (0,external_wp_i18n_namespaceObject.__)(&#039;Grid items are placed automatically depending on their order.&#039;);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalToggleGroupControl, {
    __next40pxDefaultSize: true,
    __nextHasNoMarginBottom: true,
    label: (0,external_wp_i18n_namespaceObject.__)(&#039;Grid item position&#039;),
    value: gridPlacement,
    onChange: onChangeType,
    isBlock: true,
    help: window.__experimentalEnableGridInteractivity ? helpText : undefined,
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControlOption, {
      value: &quot;auto&quot;,
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Auto&#039;)
    }, &quot;auto&quot;), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControlOption, {
      value: &quot;manual&quot;,
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Manual&#039;)
    }, &quot;manual&quot;)]
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/layouts/index.js
/**
 * Internal dependencies
 */




const layoutTypes = [flow, flex, constrained, grid];

/**
 * Retrieves a layout type by name.
 *
 * @param {string} name - The name of the layout type.
 * @return {Object} Layout type.
 */
function getLayoutType(name = &#039;default&#039;) {
  return layoutTypes.find(layoutType =&gt; layoutType.name === name);
}

/**
 * Retrieves the available layout types.
 *
 * @return {Array} Layout types.
 */
function getLayoutTypes() {
  return layoutTypes;
}

;// ./node_modules/@wordpress/block-editor/build-module/components/block-list/layout.js
/**
 * WordPress dependencies
 */


/**
 * Internal dependencies
 */



const defaultLayout = {
  type: &#039;default&#039;
};
const Layout = (0,external_wp_element_namespaceObject.createContext)(defaultLayout);

/**
 * Allows to define the layout.
 */
const LayoutProvider = Layout.Provider;

/**
 * React hook used to retrieve the layout config.
 */
function useLayout() {
  return (0,external_wp_element_namespaceObject.useContext)(Layout);
}
function LayoutStyle({
  layout = {},
  css,
  ...props
}) {
  const layoutType = getLayoutType(layout.type);
  const [blockGapSupport] = use_settings_useSettings(&#039;spacing.blockGap&#039;);
  const hasBlockGapSupport = blockGapSupport !== null;
  if (layoutType) {
    if (css) {
      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;style&quot;, {
        children: css
      });
    }
    const layoutStyle = layoutType.getLayoutStyle?.({
      hasBlockGapSupport,
      layout,
      ...props
    });
    if (layoutStyle) {
      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;style&quot;, {
        children: layoutStyle
      });
    }
  }
  return null;
}

;// ./node_modules/@wordpress/block-editor/build-module/components/block-alignment-control/use-available-alignments.js
/**
 * WordPress dependencies
 */


/**
 * Internal dependencies
 */



const use_available_alignments_EMPTY_ARRAY = [];
const use_available_alignments_DEFAULT_CONTROLS = [&#039;none&#039;, &#039;left&#039;, &#039;center&#039;, &#039;right&#039;, &#039;wide&#039;, &#039;full&#039;];
const WIDE_CONTROLS = [&#039;wide&#039;, &#039;full&#039;];
function useAvailableAlignments(controls = use_available_alignments_DEFAULT_CONTROLS) {
  // Always add the `none` option if not exists.
  if (!controls.includes(&#039;none&#039;)) {
    controls = [&#039;none&#039;, ...controls];
  }
  const isNoneOnly = controls.length === 1 &amp;&amp; controls[0] === &#039;none&#039;;
  const [wideControlsEnabled, themeSupportsLayout, isBlockBasedTheme] = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    var _settings$alignWide;
    // If `isNoneOnly` is true, we&#039;ll be returning early because there is
    // nothing to filter on an empty array. We won&#039;t need the info from
    // the `useSelect` but we must call it anyway because Rules of Hooks.
    // So the callback returns early to avoid block editor subscription.
    if (isNoneOnly) {
      return [false, false, false];
    }
    const settings = select(store).getSettings();
    return [(_settings$alignWide = settings.alignWide) !== null &amp;&amp; _settings$alignWide !== void 0 ? _settings$alignWide : false, settings.supportsLayout, settings.__unstableIsBlockBasedTheme];
  }, [isNoneOnly]);
  const layout = useLayout();
  if (isNoneOnly) {
    return use_available_alignments_EMPTY_ARRAY;
  }
  const layoutType = getLayoutType(layout?.type);
  if (themeSupportsLayout) {
    const layoutAlignments = layoutType.getAlignments(layout, isBlockBasedTheme);
    const alignments = layoutAlignments.filter(alignment =&gt; controls.includes(alignment.name));
    // While we treat `none` as an alignment, we shouldn&#039;t return it if no
    // other alignments exist.
    if (alignments.length === 1 &amp;&amp; alignments[0].name === &#039;none&#039;) {
      return use_available_alignments_EMPTY_ARRAY;
    }
    return alignments;
  }

  // Starting here, it&#039;s the fallback for themes not supporting the layout config.
  if (layoutType.name !== &#039;default&#039; &amp;&amp; layoutType.name !== &#039;constrained&#039;) {
    return use_available_alignments_EMPTY_ARRAY;
  }
  const alignments = controls.filter(control =&gt; {
    if (layout.alignments) {
      return layout.alignments.includes(control);
    }
    if (!wideControlsEnabled &amp;&amp; WIDE_CONTROLS.includes(control)) {
      return false;
    }
    return use_available_alignments_DEFAULT_CONTROLS.includes(control);
  }).map(name =&gt; ({
    name
  }));

  // While we treat `none` as an alignment, we shouldn&#039;t return it if no
  // other alignments exist.
  if (alignments.length === 1 &amp;&amp; alignments[0].name === &#039;none&#039;) {
    return use_available_alignments_EMPTY_ARRAY;
  }
  return alignments;
}

;// ./node_modules/@wordpress/icons/build-module/library/position-left.js
/**
 * WordPress dependencies
 */


const positionLeft = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;M5 5.5h8V4H5v1.5ZM5 20h8v-1.5H5V20ZM19 9H5v6h14V9Z&quot;
  })
});
/* harmony default export */ const position_left = (positionLeft);

;// ./node_modules/@wordpress/icons/build-module/library/position-center.js
/**
 * WordPress dependencies
 */


const positionCenter = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;M19 5.5H5V4h14v1.5ZM19 20H5v-1.5h14V20ZM7 9h10v6H7V9Z&quot;
  })
});
/* harmony default export */ const position_center = (positionCenter);

;// ./node_modules/@wordpress/icons/build-module/library/position-right.js
/**
 * WordPress dependencies
 */


const positionRight = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;M19 5.5h-8V4h8v1.5ZM19 20h-8v-1.5h8V20ZM5 9h14v6H5V9Z&quot;
  })
});
/* harmony default export */ const position_right = (positionRight);

;// ./node_modules/@wordpress/icons/build-module/library/stretch-full-width.js
/**
 * WordPress dependencies
 */


const stretchFullWidth = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;M5 4h14v11H5V4Zm11 16H8v-1.5h8V20Z&quot;
  })
});
/* harmony default export */ const stretch_full_width = (stretchFullWidth);

;// ./node_modules/@wordpress/block-editor/build-module/components/block-alignment-control/constants.js
/**
 * WordPress dependencies
 */


const constants_BLOCK_ALIGNMENTS_CONTROLS = {
  none: {
    icon: align_none,
    title: (0,external_wp_i18n_namespaceObject._x)(&#039;None&#039;, &#039;Alignment option&#039;)
  },
  left: {
    icon: position_left,
    title: (0,external_wp_i18n_namespaceObject.__)(&#039;Align left&#039;)
  },
  center: {
    icon: position_center,
    title: (0,external_wp_i18n_namespaceObject.__)(&#039;Align center&#039;)
  },
  right: {
    icon: position_right,
    title: (0,external_wp_i18n_namespaceObject.__)(&#039;Align right&#039;)
  },
  wide: {
    icon: stretch_wide,
    title: (0,external_wp_i18n_namespaceObject.__)(&#039;Wide width&#039;)
  },
  full: {
    icon: stretch_full_width,
    title: (0,external_wp_i18n_namespaceObject.__)(&#039;Full width&#039;)
  }
};
const constants_DEFAULT_CONTROL = &#039;none&#039;;

;// ./node_modules/@wordpress/block-editor/build-module/components/block-alignment-control/ui.js
/**
 * External dependencies
 */


/**
 * WordPress dependencies
 */



/**
 * Internal dependencies
 */



function BlockAlignmentUI({
  value,
  onChange,
  controls,
  isToolbar,
  isCollapsed = true
}) {
  const enabledControls = useAvailableAlignments(controls);
  const hasEnabledControls = !!enabledControls.length;
  if (!hasEnabledControls) {
    return null;
  }
  function onChangeAlignment(align) {
    onChange([value, &#039;none&#039;].includes(align) ? undefined : align);
  }
  const activeAlignmentControl = constants_BLOCK_ALIGNMENTS_CONTROLS[value];
  const defaultAlignmentControl = constants_BLOCK_ALIGNMENTS_CONTROLS[constants_DEFAULT_CONTROL];
  const UIComponent = isToolbar ? external_wp_components_namespaceObject.ToolbarGroup : external_wp_components_namespaceObject.ToolbarDropdownMenu;
  const commonProps = {
    icon: activeAlignmentControl ? activeAlignmentControl.icon : defaultAlignmentControl.icon,
    label: (0,external_wp_i18n_namespaceObject.__)(&#039;Align&#039;)
  };
  const extraProps = isToolbar ? {
    isCollapsed,
    controls: enabledControls.map(({
      name: controlName
    }) =&gt; {
      return {
        ...constants_BLOCK_ALIGNMENTS_CONTROLS[controlName],
        isActive: value === controlName || !value &amp;&amp; controlName === &#039;none&#039;,
        role: isCollapsed ? &#039;menuitemradio&#039; : undefined,
        onClick: () =&gt; onChangeAlignment(controlName)
      };
    })
  } : {
    toggleProps: {
      description: (0,external_wp_i18n_namespaceObject.__)(&#039;Change alignment&#039;)
    },
    children: ({
      onClose
    }) =&gt; {
      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_ReactJSXRuntime_namespaceObject.Fragment, {
        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuGroup, {
          className: &quot;block-editor-block-alignment-control__menu-group&quot;,
          children: enabledControls.map(({
            name: controlName,
            info
          }) =&gt; {
            const {
              icon,
              title
            } = constants_BLOCK_ALIGNMENTS_CONTROLS[controlName];
            // If no value is provided, mark as selected the `none` option.
            const isSelected = controlName === value || !value &amp;&amp; controlName === &#039;none&#039;;
            return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, {
              icon: icon,
              iconPosition: &quot;left&quot;,
              className: dist_clsx(&#039;components-dropdown-menu__menu-item&#039;, {
                &#039;is-active&#039;: isSelected
              }),
              isSelected: isSelected,
              onClick: () =&gt; {
                onChangeAlignment(controlName);
                onClose();
              },
              role: &quot;menuitemradio&quot;,
              info: info,
              children: title
            }, controlName);
          })
        })
      });
    }
  };
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(UIComponent, {
    ...commonProps,
    ...extraProps
  });
}
/* harmony default export */ const block_alignment_control_ui = (BlockAlignmentUI);

;// ./node_modules/@wordpress/block-editor/build-module/components/block-alignment-control/index.js
/**
 * Internal dependencies
 */


const BlockAlignmentControl = props =&gt; {
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_alignment_control_ui, {
    ...props,
    isToolbar: false
  });
};
const BlockAlignmentToolbar = props =&gt; {
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_alignment_control_ui, {
    ...props,
    isToolbar: true
  });
};

/**
 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/block-alignment-control/README.md
 */


;// ./node_modules/@wordpress/block-editor/build-module/components/block-editing-mode/index.js
/**
 * WordPress dependencies
 */



/**
 * Internal dependencies
 */



/**
 * @typedef {&#039;disabled&#039;|&#039;contentOnly&#039;|&#039;default&#039;} BlockEditingMode
 */

/**
 * Allows a block to restrict the user interface that is displayed for editing
 * that block and its inner blocks.
 *
 * @example
 * ```js
 * function MyBlock( { attributes, setAttributes } ) {
 *     useBlockEditingMode( &#039;disabled&#039; );
 *     return &lt;div { ...useBlockProps() }&gt;&lt;/div&gt;;
 * }
 * ```
 *
 * `mode` can be one of three options:
 *
 * - `&#039;disabled&#039;`: Prevents editing the block entirely, i.e. it cannot be
 *   selected.
 * - `&#039;contentOnly&#039;`: Hides all non-content UI, e.g. auxiliary controls in the
 *   toolbar, the block movers, block settings.
 * - `&#039;default&#039;`: Allows editing the block as normal.
 *
 * The mode is inherited by all of the block&#039;s inner blocks, unless they have
 * their own mode.
 *
 * If called outside of a block context, the mode is applied to all blocks.
 *
 * @param {?BlockEditingMode} mode The editing mode to apply. If undefined, the
 *                                 current editing mode is not changed.
 *
 * @return {BlockEditingMode} The current editing mode.
 */
function useBlockEditingMode(mode) {
  const context = useBlockEditContext();
  const {
    clientId = &#039;&#039;
  } = context;
  const {
    setBlockEditingMode,
    unsetBlockEditingMode
  } = (0,external_wp_data_namespaceObject.useDispatch)(store);
  const globalBlockEditingMode = (0,external_wp_data_namespaceObject.useSelect)(select =&gt;
  // Avoid adding the subscription if not needed!
  clientId ? null : select(store).getBlockEditingMode(), [clientId]);
  (0,external_wp_element_namespaceObject.useEffect)(() =&gt; {
    if (mode) {
      setBlockEditingMode(clientId, mode);
    }
    return () =&gt; {
      if (mode) {
        unsetBlockEditingMode(clientId);
      }
    };
  }, [clientId, mode, setBlockEditingMode, unsetBlockEditingMode]);
  return clientId ? context[blockEditingModeKey] : globalBlockEditingMode;
}

;// ./node_modules/@wordpress/block-editor/build-module/hooks/align.js
/**
 * External dependencies
 */


/**
 * WordPress dependencies
 */



/**
 * Internal dependencies
 */




/**
 * An array which includes all possible valid alignments,
 * used to validate if an alignment is valid or not.
 *
 * @constant
 * @type {string[]}
 */

const ALL_ALIGNMENTS = [&#039;left&#039;, &#039;center&#039;, &#039;right&#039;, &#039;wide&#039;, &#039;full&#039;];

/**
 * An array which includes all wide alignments.
 * In order for this alignments to be valid they need to be supported by the block,
 * and by the theme.
 *
 * @constant
 * @type {string[]}
 */
const WIDE_ALIGNMENTS = [&#039;wide&#039;, &#039;full&#039;];

/**
 * Returns the valid alignments.
 * 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.
 * Exported just for testing purposes, not exported outside the module.
 *
 * @param {?boolean|string[]} blockAlign          Aligns supported by the block.
 * @param {?boolean}          hasWideBlockSupport True if block supports wide alignments. And False otherwise.
 * @param {?boolean}          hasWideEnabled      True if theme supports wide alignments. And False otherwise.
 *
 * @return {string[]} Valid alignments.
 */
function getValidAlignments(blockAlign, hasWideBlockSupport = true, hasWideEnabled = true) {
  let validAlignments;
  if (Array.isArray(blockAlign)) {
    validAlignments = ALL_ALIGNMENTS.filter(value =&gt; blockAlign.includes(value));
  } else if (blockAlign === true) {
    // `true` includes all alignments...
    validAlignments = [...ALL_ALIGNMENTS];
  } else {
    validAlignments = [];
  }
  if (!hasWideEnabled || blockAlign === true &amp;&amp; !hasWideBlockSupport) {
    return validAlignments.filter(alignment =&gt; !WIDE_ALIGNMENTS.includes(alignment));
  }
  return validAlignments;
}

/**
 * Filters registered block settings, extending attributes to include `align`.
 *
 * @param {Object} settings Original block settings.
 *
 * @return {Object} Filtered block settings.
 */
function addAttribute(settings) {
  var _settings$attributes$;
  // Allow blocks to specify their own attribute definition with default values if needed.
  if (&#039;type&#039; in ((_settings$attributes$ = settings.attributes?.align) !== null &amp;&amp; _settings$attributes$ !== void 0 ? _settings$attributes$ : {})) {
    return settings;
  }
  if ((0,external_wp_blocks_namespaceObject.hasBlockSupport)(settings, &#039;align&#039;)) {
    // Gracefully handle if settings.attributes is undefined.
    settings.attributes = {
      ...settings.attributes,
      align: {
        type: &#039;string&#039;,
        // Allow for &#039;&#039; since it is used by the `updateAlignment` function
        // in toolbar controls for special cases with defined default values.
        enum: [...ALL_ALIGNMENTS, &#039;&#039;]
      }
    };
  }
  return settings;
}
function BlockEditAlignmentToolbarControlsPure({
  name: blockName,
  align,
  setAttributes
}) {
  // Compute the block valid alignments by taking into account,
  // if the theme supports wide alignments or not and the layout&#039;s
  // available alignments. We do that for conditionally rendering
  // Slot.
  const blockAllowedAlignments = getValidAlignments((0,external_wp_blocks_namespaceObject.getBlockSupport)(blockName, &#039;align&#039;), (0,external_wp_blocks_namespaceObject.hasBlockSupport)(blockName, &#039;alignWide&#039;, true));
  const validAlignments = useAvailableAlignments(blockAllowedAlignments).map(({
    name
  }) =&gt; name);
  const blockEditingMode = useBlockEditingMode();
  if (!validAlignments.length || blockEditingMode !== &#039;default&#039;) {
    return null;
  }
  const updateAlignment = nextAlign =&gt; {
    if (!nextAlign) {
      const blockType = (0,external_wp_blocks_namespaceObject.getBlockType)(blockName);
      const blockDefaultAlign = blockType?.attributes?.align?.default;
      if (blockDefaultAlign) {
        nextAlign = &#039;&#039;;
      }
    }
    setAttributes({
      align: nextAlign
    });
  };
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_controls, {
    group: &quot;block&quot;,
    __experimentalShareWithChildBlocks: true,
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockAlignmentControl, {
      value: align,
      onChange: updateAlignment,
      controls: validAlignments
    })
  });
}
/* harmony default export */ const align = ({
  shareWithChildBlocks: true,
  edit: BlockEditAlignmentToolbarControlsPure,
  useBlockProps,
  addSaveProps: addAssignedAlign,
  attributeKeys: [&#039;align&#039;],
  hasSupport(name) {
    return (0,external_wp_blocks_namespaceObject.hasBlockSupport)(name, &#039;align&#039;, false);
  }
});
function useBlockProps({
  name,
  align
}) {
  const blockAllowedAlignments = getValidAlignments((0,external_wp_blocks_namespaceObject.getBlockSupport)(name, &#039;align&#039;), (0,external_wp_blocks_namespaceObject.hasBlockSupport)(name, &#039;alignWide&#039;, true));
  const validAlignments = useAvailableAlignments(blockAllowedAlignments);
  if (validAlignments.some(alignment =&gt; alignment.name === align)) {
    return {
      &#039;data-align&#039;: align
    };
  }
  return {};
}

/**
 * Override props assigned to save component to inject alignment class name if
 * block supports it.
 *
 * @param {Object} props      Additional props applied to save element.
 * @param {Object} blockType  Block type.
 * @param {Object} attributes Block attributes.
 *
 * @return {Object} Filtered props applied to save element.
 */
function addAssignedAlign(props, blockType, attributes) {
  const {
    align
  } = attributes;
  const blockAlign = (0,external_wp_blocks_namespaceObject.getBlockSupport)(blockType, &#039;align&#039;);
  const hasWideBlockSupport = (0,external_wp_blocks_namespaceObject.hasBlockSupport)(blockType, &#039;alignWide&#039;, true);

  // Compute valid alignments without taking into account if
  // the theme supports wide alignments or not.
  // This way changing themes does not impact the block save.
  const isAlignValid = getValidAlignments(blockAlign, hasWideBlockSupport).includes(align);
  if (isAlignValid) {
    props.className = dist_clsx(`align${align}`, props.className);
  }
  return props;
}
(0,external_wp_hooks_namespaceObject.addFilter)(&#039;blocks.registerBlockType&#039;, &#039;core/editor/align/addAttribute&#039;, addAttribute);

;// ./node_modules/@wordpress/block-editor/build-module/components/inspector-controls/groups.js
/**
 * WordPress dependencies
 */

const InspectorControlsDefault = (0,external_wp_components_namespaceObject.createSlotFill)(&#039;InspectorControls&#039;);
const InspectorControlsAdvanced = (0,external_wp_components_namespaceObject.createSlotFill)(&#039;InspectorAdvancedControls&#039;);
const InspectorControlsBindings = (0,external_wp_components_namespaceObject.createSlotFill)(&#039;InspectorControlsBindings&#039;);
const InspectorControlsBackground = (0,external_wp_components_namespaceObject.createSlotFill)(&#039;InspectorControlsBackground&#039;);
const InspectorControlsBorder = (0,external_wp_components_namespaceObject.createSlotFill)(&#039;InspectorControlsBorder&#039;);
const InspectorControlsColor = (0,external_wp_components_namespaceObject.createSlotFill)(&#039;InspectorControlsColor&#039;);
const InspectorControlsFilter = (0,external_wp_components_namespaceObject.createSlotFill)(&#039;InspectorControlsFilter&#039;);
const InspectorControlsDimensions = (0,external_wp_components_namespaceObject.createSlotFill)(&#039;InspectorControlsDimensions&#039;);
const InspectorControlsPosition = (0,external_wp_components_namespaceObject.createSlotFill)(&#039;InspectorControlsPosition&#039;);
const InspectorControlsTypography = (0,external_wp_components_namespaceObject.createSlotFill)(&#039;InspectorControlsTypography&#039;);
const InspectorControlsListView = (0,external_wp_components_namespaceObject.createSlotFill)(&#039;InspectorControlsListView&#039;);
const InspectorControlsStyles = (0,external_wp_components_namespaceObject.createSlotFill)(&#039;InspectorControlsStyles&#039;);
const InspectorControlsEffects = (0,external_wp_components_namespaceObject.createSlotFill)(&#039;InspectorControlsEffects&#039;);
const groups_groups = {
  default: InspectorControlsDefault,
  advanced: InspectorControlsAdvanced,
  background: InspectorControlsBackground,
  bindings: InspectorControlsBindings,
  border: InspectorControlsBorder,
  color: InspectorControlsColor,
  dimensions: InspectorControlsDimensions,
  effects: InspectorControlsEffects,
  filter: InspectorControlsFilter,
  list: InspectorControlsListView,
  position: InspectorControlsPosition,
  settings: InspectorControlsDefault,
  // Alias for default.
  styles: InspectorControlsStyles,
  typography: InspectorControlsTypography
};
/* harmony default export */ const inspector_controls_groups = (groups_groups);

;// ./node_modules/@wordpress/block-editor/build-module/components/inspector-controls/fill.js
/**
 * WordPress dependencies
 */





/**
 * Internal dependencies
 */



function InspectorControlsFill({
  children,
  group = &#039;default&#039;,
  __experimentalGroup,
  resetAllFilter
}) {
  if (__experimentalGroup) {
    external_wp_deprecated_default()(&#039;`__experimentalGroup` property in `InspectorControlsFill`&#039;, {
      since: &#039;6.2&#039;,
      version: &#039;6.4&#039;,
      alternative: &#039;`group`&#039;
    });
    group = __experimentalGroup;
  }
  const context = useBlockEditContext();
  const Fill = inspector_controls_groups[group]?.Fill;
  if (!Fill) {
     true ? external_wp_warning_default()(`Unknown InspectorControls group &quot;${group}&quot; provided.`) : 0;
    return null;
  }
  if (!context[mayDisplayControlsKey]) {
    return null;
  }
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalStyleProvider, {
    document: document,
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Fill, {
      children: fillProps =&gt; {
        return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ToolsPanelInspectorControl, {
          fillProps: fillProps,
          children: children,
          resetAllFilter: resetAllFilter
        });
      }
    })
  });
}
function RegisterResetAll({
  resetAllFilter,
  children
}) {
  const {
    registerResetAllFilter,
    deregisterResetAllFilter
  } = (0,external_wp_element_namespaceObject.useContext)(external_wp_components_namespaceObject.__experimentalToolsPanelContext);
  (0,external_wp_element_namespaceObject.useEffect)(() =&gt; {
    if (resetAllFilter &amp;&amp; registerResetAllFilter &amp;&amp; deregisterResetAllFilter) {
      registerResetAllFilter(resetAllFilter);
      return () =&gt; {
        deregisterResetAllFilter(resetAllFilter);
      };
    }
  }, [resetAllFilter, registerResetAllFilter, deregisterResetAllFilter]);
  return children;
}
function ToolsPanelInspectorControl({
  children,
  resetAllFilter,
  fillProps
}) {
  // `fillProps.forwardedContext` is an array of context provider entries, provided by slot,
  // that should wrap the fill markup.
  const {
    forwardedContext = []
  } = fillProps;

  // Children passed to InspectorControlsFill will not have
  // access to any React Context whose Provider is part of
  // the InspectorControlsSlot tree. So we re-create the
  // Provider in this subtree.
  const innerMarkup = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(RegisterResetAll, {
    resetAllFilter: resetAllFilter,
    children: children
  });
  return forwardedContext.reduce((inner, [Provider, props]) =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Provider, {
    ...props,
    children: inner
  }), innerMarkup);
}

;// ./node_modules/@wordpress/block-editor/build-module/components/inspector-controls/block-support-tools-panel.js
/**
 * WordPress dependencies
 */




/**
 * Internal dependencies
 */




function BlockSupportToolsPanel({
  children,
  group,
  label
}) {
  const {
    updateBlockAttributes
  } = (0,external_wp_data_namespaceObject.useDispatch)(store);
  const {
    getBlockAttributes,
    getMultiSelectedBlockClientIds,
    getSelectedBlockClientId,
    hasMultiSelection
  } = (0,external_wp_data_namespaceObject.useSelect)(store);
  const dropdownMenuProps = useToolsPanelDropdownMenuProps();
  const panelId = getSelectedBlockClientId();
  const resetAll = (0,external_wp_element_namespaceObject.useCallback)((resetFilters = []) =&gt; {
    const newAttributes = {};
    const clientIds = hasMultiSelection() ? getMultiSelectedBlockClientIds() : [panelId];
    clientIds.forEach(clientId =&gt; {
      const {
        style
      } = getBlockAttributes(clientId);
      let newBlockAttributes = {
        style
      };
      resetFilters.forEach(resetFilter =&gt; {
        newBlockAttributes = {
          ...newBlockAttributes,
          ...resetFilter(newBlockAttributes)
        };
      });

      // Enforce a cleaned style object.
      newBlockAttributes = {
        ...newBlockAttributes,
        style: utils_cleanEmptyObject(newBlockAttributes.style)
      };
      newAttributes[clientId] = newBlockAttributes;
    });
    updateBlockAttributes(clientIds, newAttributes, true);
  }, [getBlockAttributes, getMultiSelectedBlockClientIds, hasMultiSelection, panelId, updateBlockAttributes]);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanel, {
    className: `${group}-block-support-panel`,
    label: label,
    resetAll: resetAll,
    panelId: panelId,
    hasInnerWrapper: true,
    shouldRenderPlaceholderItems: true // Required to maintain fills ordering.
    ,
    __experimentalFirstVisibleItemClass: &quot;first&quot;,
    __experimentalLastVisibleItemClass: &quot;last&quot;,
    dropdownMenuProps: dropdownMenuProps,
    children: children
  }, panelId);
}

;// ./node_modules/@wordpress/block-editor/build-module/components/inspector-controls/block-support-slot-container.js
/**
 * WordPress dependencies
 */



function BlockSupportSlotContainer({
  Slot,
  fillProps,
  ...props
}) {
  // Add the toolspanel context provider and value to existing fill props
  const toolsPanelContext = (0,external_wp_element_namespaceObject.useContext)(external_wp_components_namespaceObject.__experimentalToolsPanelContext);
  const computedFillProps = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; {
    var _fillProps$forwardedC;
    return {
      ...(fillProps !== null &amp;&amp; fillProps !== void 0 ? fillProps : {}),
      forwardedContext: [...((_fillProps$forwardedC = fillProps?.forwardedContext) !== null &amp;&amp; _fillProps$forwardedC !== void 0 ? _fillProps$forwardedC : []), [external_wp_components_namespaceObject.__experimentalToolsPanelContext.Provider, {
        value: toolsPanelContext
      }]]
    };
  }, [toolsPanelContext, fillProps]);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Slot, {
    ...props,
    fillProps: computedFillProps,
    bubblesVirtually: true
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/inspector-controls/slot.js
/**
 * WordPress dependencies
 */




/**
 * Internal dependencies
 */




function InspectorControlsSlot({
  __experimentalGroup,
  group = &#039;default&#039;,
  label,
  fillProps,
  ...props
}) {
  if (__experimentalGroup) {
    external_wp_deprecated_default()(&#039;`__experimentalGroup` property in `InspectorControlsSlot`&#039;, {
      since: &#039;6.2&#039;,
      version: &#039;6.4&#039;,
      alternative: &#039;`group`&#039;
    });
    group = __experimentalGroup;
  }
  const slotFill = inspector_controls_groups[group];
  const fills = (0,external_wp_components_namespaceObject.__experimentalUseSlotFills)(slotFill?.name);
  if (!slotFill) {
     true ? external_wp_warning_default()(`Unknown InspectorControls group &quot;${group}&quot; provided.`) : 0;
    return null;
  }
  if (!fills?.length) {
    return null;
  }
  const {
    Slot
  } = slotFill;
  if (label) {
    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockSupportToolsPanel, {
      group: group,
      label: label,
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockSupportSlotContainer, {
        ...props,
        fillProps: fillProps,
        Slot: Slot
      })
    });
  }
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Slot, {
    ...props,
    fillProps: fillProps,
    bubblesVirtually: true
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/inspector-controls/index.js
/**
 * Internal dependencies
 */



const InspectorControls = InspectorControlsFill;
InspectorControls.Slot = InspectorControlsSlot;

// This is just here for backward compatibility.
const InspectorAdvancedControls = props =&gt; {
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(InspectorControlsFill, {
    ...props,
    group: &quot;advanced&quot;
  });
};
InspectorAdvancedControls.Slot = props =&gt; {
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(InspectorControlsSlot, {
    ...props,
    group: &quot;advanced&quot;
  });
};
InspectorAdvancedControls.slotName = &#039;InspectorAdvancedControls&#039;;

/**
 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/inspector-controls/README.md
 */
/* harmony default export */ const inspector_controls = (InspectorControls);

;// external [&quot;wp&quot;,&quot;url&quot;]
const external_wp_url_namespaceObject = window[&quot;wp&quot;][&quot;url&quot;];
;// external [&quot;wp&quot;,&quot;dom&quot;]
const external_wp_dom_namespaceObject = window[&quot;wp&quot;][&quot;dom&quot;];
;// external [&quot;wp&quot;,&quot;blob&quot;]
const external_wp_blob_namespaceObject = window[&quot;wp&quot;][&quot;blob&quot;];
;// external [&quot;wp&quot;,&quot;keycodes&quot;]
const external_wp_keycodes_namespaceObject = window[&quot;wp&quot;][&quot;keycodes&quot;];
;// ./node_modules/@wordpress/icons/build-module/library/media.js
/**
 * WordPress dependencies
 */


const media = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;m7 6.5 4 2.5-4 2.5z&quot;
  }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    fillRule: &quot;evenodd&quot;,
    clipRule: &quot;evenodd&quot;,
    d: &quot;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&quot;
  })]
});
/* harmony default export */ const library_media = (media);

;// ./node_modules/@wordpress/icons/build-module/library/upload.js
/**
 * WordPress dependencies
 */


const upload = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;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&quot;
  })
});
/* harmony default export */ const library_upload = (upload);

;// ./node_modules/@wordpress/icons/build-module/library/post-featured-image.js
/**
 * WordPress dependencies
 */


const postFeaturedImage = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;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&quot;
  })
});
/* harmony default export */ const post_featured_image = (postFeaturedImage);

;// ./node_modules/@wordpress/block-editor/build-module/components/media-upload/index.js
/**
 * WordPress dependencies
 */


/**
 * This is a placeholder for the media upload component necessary to make it possible to provide
 * an integration with the core blocks that handle media files. By default it renders nothing but
 * it provides a way to have it overridden with the `editor.MediaUpload` filter.
 *
 * @return {Component} The component to be rendered.
 */
const MediaUpload = () =&gt; null;

/**
 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/media-upload/README.md
 */
/* harmony default export */ const media_upload = ((0,external_wp_components_namespaceObject.withFilters)(&#039;editor.MediaUpload&#039;)(MediaUpload));

;// ./node_modules/@wordpress/block-editor/build-module/components/media-upload/check.js
/**
 * WordPress dependencies
 */


/**
 * Internal dependencies
 */

function MediaUploadCheck({
  fallback = null,
  children
}) {
  const hasUploadPermissions = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      getSettings
    } = select(store);
    return !!getSettings().mediaUpload;
  }, []);
  return hasUploadPermissions ? children : fallback;
}

/**
 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/media-upload/README.md
 */
/* harmony default export */ const check = (MediaUploadCheck);

;// external [&quot;wp&quot;,&quot;isShallowEqual&quot;]
const external_wp_isShallowEqual_namespaceObject = window[&quot;wp&quot;][&quot;isShallowEqual&quot;];
var external_wp_isShallowEqual_default = /*#__PURE__*/__webpack_require__.n(external_wp_isShallowEqual_namespaceObject);
;// ./node_modules/@wordpress/icons/build-module/library/keyboard-return.js
/**
 * WordPress dependencies
 */


const keyboardReturn = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;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&quot;
  })
});
/* harmony default export */ const keyboard_return = (keyboardReturn);

;// ./node_modules/@wordpress/icons/build-module/library/chevron-left-small.js
/**
 * WordPress dependencies
 */


const chevronLeftSmall = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;m13.1 16-3.4-4 3.4-4 1.1 1-2.6 3 2.6 3-1.1 1z&quot;
  })
});
/* harmony default export */ const chevron_left_small = (chevronLeftSmall);

;// ./node_modules/@wordpress/icons/build-module/library/chevron-right-small.js
/**
 * WordPress dependencies
 */


const chevronRightSmall = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;M10.8622 8.04053L14.2805 12.0286L10.8622 16.0167L9.72327 15.0405L12.3049 12.0286L9.72327 9.01672L10.8622 8.04053Z&quot;
  })
});
/* harmony default export */ const chevron_right_small = (chevronRightSmall);

;// ./node_modules/@wordpress/block-editor/build-module/components/link-control/settings-drawer.js
/**
 * WordPress dependencies
 */






function LinkSettingsDrawer({
  children,
  settingsOpen,
  setSettingsOpen
}) {
  const prefersReducedMotion = (0,external_wp_compose_namespaceObject.useReducedMotion)();
  const MaybeAnimatePresence = prefersReducedMotion ? external_wp_element_namespaceObject.Fragment : external_wp_components_namespaceObject.__unstableAnimatePresence;
  const MaybeMotionDiv = prefersReducedMotion ? &#039;div&#039; : external_wp_components_namespaceObject.__unstableMotion.div;
  const id = (0,external_wp_compose_namespaceObject.useInstanceId)(LinkSettingsDrawer);
  const settingsDrawerId = `link-control-settings-drawer-${id}`;
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
      __next40pxDefaultSize: true,
      className: &quot;block-editor-link-control__drawer-toggle&quot;,
      &quot;aria-expanded&quot;: settingsOpen,
      onClick: () =&gt; setSettingsOpen(!settingsOpen),
      icon: (0,external_wp_i18n_namespaceObject.isRTL)() ? chevron_left_small : chevron_right_small,
      &quot;aria-controls&quot;: settingsDrawerId,
      children: (0,external_wp_i18n_namespaceObject._x)(&#039;Advanced&#039;, &#039;Additional link settings&#039;)
    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(MaybeAnimatePresence, {
      children: settingsOpen &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(MaybeMotionDiv, {
        className: &quot;block-editor-link-control__drawer&quot;,
        hidden: !settingsOpen,
        id: settingsDrawerId,
        initial: &quot;collapsed&quot;,
        animate: &quot;open&quot;,
        exit: &quot;collapsed&quot;,
        variants: {
          open: {
            opacity: 1,
            height: &#039;auto&#039;
          },
          collapsed: {
            opacity: 0,
            height: 0
          }
        },
        transition: {
          duration: 0.1
        },
        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
          className: &quot;block-editor-link-control__drawer-inner&quot;,
          children: children
        })
      })
    })]
  });
}
/* harmony default export */ const settings_drawer = (LinkSettingsDrawer);

// EXTERNAL MODULE: external &quot;React&quot;
var external_React_ = __webpack_require__(1609);
;// ./node_modules/@wordpress/block-editor/build-module/components/url-input/index.js
/**
 * External dependencies
 */


/**
 * WordPress dependencies
 */








/**
 * Internal dependencies
 */


/**
 * Whether the argument is a function.
 *
 * @param {*} maybeFunc The argument to check.
 * @return {boolean} True if the argument is a function, false otherwise.
 */


function isFunction(maybeFunc) {
  return typeof maybeFunc === &#039;function&#039;;
}
class URLInput extends external_wp_element_namespaceObject.Component {
  constructor(props) {
    super(props);
    this.onChange = this.onChange.bind(this);
    this.onFocus = this.onFocus.bind(this);
    this.onKeyDown = this.onKeyDown.bind(this);
    this.selectLink = this.selectLink.bind(this);
    this.handleOnClick = this.handleOnClick.bind(this);
    this.bindSuggestionNode = this.bindSuggestionNode.bind(this);
    this.autocompleteRef = props.autocompleteRef || (0,external_wp_element_namespaceObject.createRef)();
    this.inputRef = (0,external_wp_element_namespaceObject.createRef)();
    this.updateSuggestions = (0,external_wp_compose_namespaceObject.debounce)(this.updateSuggestions.bind(this), 200);
    this.suggestionNodes = [];
    this.suggestionsRequest = null;
    this.state = {
      suggestions: [],
      showSuggestions: false,
      suggestionsValue: null,
      selectedSuggestion: null,
      suggestionsListboxId: &#039;&#039;,
      suggestionOptionIdPrefix: &#039;&#039;
    };
  }
  componentDidUpdate(prevProps) {
    const {
      showSuggestions,
      selectedSuggestion
    } = this.state;
    const {
      value,
      __experimentalShowInitialSuggestions = false
    } = this.props;

    // Only have to worry about scrolling selected suggestion into view
    // when already expanded.
    if (showSuggestions &amp;&amp; selectedSuggestion !== null &amp;&amp; this.suggestionNodes[selectedSuggestion]) {
      this.suggestionNodes[selectedSuggestion].scrollIntoView({
        behavior: &#039;instant&#039;,
        block: &#039;nearest&#039;,
        inline: &#039;nearest&#039;
      });
    }

    // Update suggestions when the value changes.
    if (prevProps.value !== value &amp;&amp; !this.props.disableSuggestions) {
      if (value?.length) {
        // If the new value is not empty we need to update with suggestions for it.
        this.updateSuggestions(value);
      } else if (__experimentalShowInitialSuggestions) {
        // If the new value is empty and we can show initial suggestions, then show initial suggestions.
        this.updateSuggestions();
      }
    }
  }
  componentDidMount() {
    if (this.shouldShowInitialSuggestions()) {
      this.updateSuggestions();
    }
  }
  componentWillUnmount() {
    this.suggestionsRequest?.cancel?.();
    this.suggestionsRequest = null;
  }
  bindSuggestionNode(index) {
    return ref =&gt; {
      this.suggestionNodes[index] = ref;
    };
  }
  shouldShowInitialSuggestions() {
    const {
      __experimentalShowInitialSuggestions = false,
      value
    } = this.props;
    return __experimentalShowInitialSuggestions &amp;&amp; !(value &amp;&amp; value.length);
  }
  updateSuggestions(value = &#039;&#039;) {
    const {
      __experimentalFetchLinkSuggestions: fetchLinkSuggestions,
      __experimentalHandleURLSuggestions: handleURLSuggestions
    } = this.props;
    if (!fetchLinkSuggestions) {
      return;
    }

    // Initial suggestions may only show if there is no value
    // (note: this includes whitespace).
    const isInitialSuggestions = !value?.length;

    // Trim only now we&#039;ve determined whether or not it originally had a &quot;length&quot;
    // (even if that value was all whitespace).
    value = value.trim();

    // Allow a suggestions request if:
    // - there are at least 2 characters in the search input (except manual searches where
    //   search input length is not required to trigger a fetch)
    // - this is a direct entry (eg: a URL)
    if (!isInitialSuggestions &amp;&amp; (value.length &lt; 2 || !handleURLSuggestions &amp;&amp; (0,external_wp_url_namespaceObject.isURL)(value))) {
      this.suggestionsRequest?.cancel?.();
      this.suggestionsRequest = null;
      this.setState({
        suggestions: [],
        showSuggestions: false,
        suggestionsValue: value,
        selectedSuggestion: null,
        loading: false
      });
      return;
    }
    this.setState({
      selectedSuggestion: null,
      loading: true
    });
    const request = fetchLinkSuggestions(value, {
      isInitialSuggestions
    });
    request.then(suggestions =&gt; {
      // A fetch Promise doesn&#039;t have an abort option. It&#039;s mimicked by
      // comparing the request reference in on the instance, which is
      // reset or deleted on subsequent requests or unmounting.
      if (this.suggestionsRequest !== request) {
        return;
      }
      this.setState({
        suggestions,
        suggestionsValue: value,
        loading: false,
        showSuggestions: !!suggestions.length
      });
      if (!!suggestions.length) {
        this.props.debouncedSpeak((0,external_wp_i18n_namespaceObject.sprintf)(/* translators: %d: number of results. */
        (0,external_wp_i18n_namespaceObject._n)(&#039;%d result found, use up and down arrow keys to navigate.&#039;, &#039;%d results found, use up and down arrow keys to navigate.&#039;, suggestions.length), suggestions.length), &#039;assertive&#039;);
      } else {
        this.props.debouncedSpeak((0,external_wp_i18n_namespaceObject.__)(&#039;No results.&#039;), &#039;assertive&#039;);
      }
    }).catch(() =&gt; {
      if (this.suggestionsRequest !== request) {
        return;
      }
      this.setState({
        loading: false
      });
    }).finally(() =&gt; {
      // If this is the current promise then reset the reference
      // to allow for checking if a new request is made.
      if (this.suggestionsRequest === request) {
        this.suggestionsRequest = null;
      }
    });

    // Note that this assignment is handled *before* the async search request
    // as a Promise always resolves on the next tick of the event loop.
    this.suggestionsRequest = request;
  }
  onChange(newValue) {
    this.props.onChange(newValue);
  }
  onFocus() {
    const {
      suggestions
    } = this.state;
    const {
      disableSuggestions,
      value
    } = this.props;

    // When opening the link editor, if there&#039;s a value present, we want to load the suggestions pane with the results for this input search value
    // Don&#039;t re-run the suggestions on focus if there are already suggestions present (prevents searching again when tabbing between the input and buttons)
    // or there is already a request in progress.
    if (value &amp;&amp; !disableSuggestions &amp;&amp; !(suggestions &amp;&amp; suggestions.length) &amp;&amp; this.suggestionsRequest === null) {
      // Ensure the suggestions are updated with the current input value.
      this.updateSuggestions(value);
    }
  }
  onKeyDown(event) {
    this.props.onKeyDown?.(event);
    const {
      showSuggestions,
      selectedSuggestion,
      suggestions,
      loading
    } = this.state;

    // If the suggestions are not shown or loading, we shouldn&#039;t handle the arrow keys
    // We shouldn&#039;t preventDefault to allow block arrow keys navigation.
    if (!showSuggestions || !suggestions.length || loading) {
      // In the Windows version of Firefox the up and down arrows don&#039;t move the caret
      // within an input field like they do for Mac Firefox/Chrome/Safari. This causes
      // a form of focus trapping that is disruptive to the user experience. This disruption
      // only happens if the caret is not in the first or last position in the text input.
      // See: https://github.com/WordPress/gutenberg/issues/5693#issuecomment-436684747
      switch (event.keyCode) {
        // When UP is pressed, if the caret is at the start of the text, move it to the 0
        // position.
        case external_wp_keycodes_namespaceObject.UP:
          {
            if (0 !== event.target.selectionStart) {
              event.preventDefault();

              // Set the input caret to position 0.
              event.target.setSelectionRange(0, 0);
            }
            break;
          }
        // When DOWN is pressed, if the caret is not at the end of the text, move it to the
        // last position.
        case external_wp_keycodes_namespaceObject.DOWN:
          {
            if (this.props.value.length !== event.target.selectionStart) {
              event.preventDefault();

              // Set the input caret to the last position.
              event.target.setSelectionRange(this.props.value.length, this.props.value.length);
            }
            break;
          }

        // Submitting while loading should trigger onSubmit.
        case external_wp_keycodes_namespaceObject.ENTER:
          {
            if (this.props.onSubmit) {
              event.preventDefault();
              this.props.onSubmit(null, event);
            }
            break;
          }
      }
      return;
    }
    const suggestion = this.state.suggestions[this.state.selectedSuggestion];
    switch (event.keyCode) {
      case external_wp_keycodes_namespaceObject.UP:
        {
          event.preventDefault();
          const previousIndex = !selectedSuggestion ? suggestions.length - 1 : selectedSuggestion - 1;
          this.setState({
            selectedSuggestion: previousIndex
          });
          break;
        }
      case external_wp_keycodes_namespaceObject.DOWN:
        {
          event.preventDefault();
          const nextIndex = selectedSuggestion === null || selectedSuggestion === suggestions.length - 1 ? 0 : selectedSuggestion + 1;
          this.setState({
            selectedSuggestion: nextIndex
          });
          break;
        }
      case external_wp_keycodes_namespaceObject.TAB:
        {
          if (this.state.selectedSuggestion !== null) {
            this.selectLink(suggestion);
            // Announce a link has been selected when tabbing away from the input field.
            this.props.speak((0,external_wp_i18n_namespaceObject.__)(&#039;Link selected.&#039;));
          }
          break;
        }
      case external_wp_keycodes_namespaceObject.ENTER:
        {
          event.preventDefault();
          if (this.state.selectedSuggestion !== null) {
            this.selectLink(suggestion);
            if (this.props.onSubmit) {
              this.props.onSubmit(suggestion, event);
            }
          } else if (this.props.onSubmit) {
            this.props.onSubmit(null, event);
          }
          break;
        }
    }
  }
  selectLink(suggestion) {
    this.props.onChange(suggestion.url, suggestion);
    this.setState({
      selectedSuggestion: null,
      showSuggestions: false
    });
  }
  handleOnClick(suggestion) {
    this.selectLink(suggestion);
    // Move focus to the input field when a link suggestion is clicked.
    this.inputRef.current.focus();
  }
  static getDerivedStateFromProps({
    value,
    instanceId,
    disableSuggestions,
    __experimentalShowInitialSuggestions = false
  }, {
    showSuggestions
  }) {
    let shouldShowSuggestions = showSuggestions;
    const hasValue = value &amp;&amp; value.length;
    if (!__experimentalShowInitialSuggestions &amp;&amp; !hasValue) {
      shouldShowSuggestions = false;
    }
    if (disableSuggestions === true) {
      shouldShowSuggestions = false;
    }
    return {
      showSuggestions: shouldShowSuggestions,
      suggestionsListboxId: `block-editor-url-input-suggestions-${instanceId}`,
      suggestionOptionIdPrefix: `block-editor-url-input-suggestion-${instanceId}`
    };
  }
  render() {
    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
      children: [this.renderControl(), this.renderSuggestions()]
    });
  }
  renderControl() {
    const {
      label = null,
      className,
      isFullWidth,
      instanceId,
      placeholder = (0,external_wp_i18n_namespaceObject.__)(&#039;Paste URL or type to search&#039;),
      __experimentalRenderControl: renderControl,
      value = &#039;&#039;,
      hideLabelFromVision = false
    } = this.props;
    const {
      loading,
      showSuggestions,
      selectedSuggestion,
      suggestionsListboxId,
      suggestionOptionIdPrefix
    } = this.state;
    const inputId = `url-input-control-${instanceId}`;
    const controlProps = {
      id: inputId,
      // Passes attribute to label for the for attribute
      label,
      className: dist_clsx(&#039;block-editor-url-input&#039;, className, {
        &#039;is-full-width&#039;: isFullWidth
      }),
      hideLabelFromVision
    };
    const inputProps = {
      id: inputId,
      value,
      required: true,
      type: &#039;text&#039;,
      onChange: this.onChange,
      onFocus: this.onFocus,
      placeholder,
      onKeyDown: this.onKeyDown,
      role: &#039;combobox&#039;,
      &#039;aria-label&#039;: label ? undefined : (0,external_wp_i18n_namespaceObject.__)(&#039;URL&#039;),
      // Ensure input always has an accessible label
      &#039;aria-expanded&#039;: showSuggestions,
      &#039;aria-autocomplete&#039;: &#039;list&#039;,
      &#039;aria-owns&#039;: suggestionsListboxId,
      &#039;aria-activedescendant&#039;: selectedSuggestion !== null ? `${suggestionOptionIdPrefix}-${selectedSuggestion}` : undefined,
      ref: this.inputRef,
      suffix: this.props.suffix
    };
    if (renderControl) {
      return renderControl(controlProps, inputProps, loading);
    }
    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.BaseControl, {
      __nextHasNoMarginBottom: true,
      ...controlProps,
      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalInputControl, {
        ...inputProps,
        __next40pxDefaultSize: true
      }), loading &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Spinner, {})]
    });
  }
  renderSuggestions() {
    const {
      className,
      __experimentalRenderSuggestions: renderSuggestions
    } = this.props;
    const {
      showSuggestions,
      suggestions,
      suggestionsValue,
      selectedSuggestion,
      suggestionsListboxId,
      suggestionOptionIdPrefix,
      loading
    } = this.state;
    if (!showSuggestions || suggestions.length === 0) {
      return null;
    }
    const suggestionsListProps = {
      id: suggestionsListboxId,
      ref: this.autocompleteRef,
      role: &#039;listbox&#039;
    };
    const buildSuggestionItemProps = (suggestion, index) =&gt; {
      return {
        role: &#039;option&#039;,
        tabIndex: &#039;-1&#039;,
        id: `${suggestionOptionIdPrefix}-${index}`,
        ref: this.bindSuggestionNode(index),
        &#039;aria-selected&#039;: index === selectedSuggestion ? true : undefined
      };
    };
    if (isFunction(renderSuggestions)) {
      return renderSuggestions({
        suggestions,
        selectedSuggestion,
        suggestionsListProps,
        buildSuggestionItemProps,
        isLoading: loading,
        handleSuggestionClick: this.handleOnClick,
        isInitialSuggestions: !suggestionsValue?.length,
        currentInputValue: suggestionsValue
      });
    }
    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Popover, {
      placement: &quot;bottom&quot;,
      focusOnMount: false,
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
        ...suggestionsListProps,
        className: dist_clsx(&#039;block-editor-url-input__suggestions&#039;, {
          [`${className}__suggestions`]: className
        }),
        children: suggestions.map((suggestion, index) =&gt; /*#__PURE__*/(0,external_React_.createElement)(external_wp_components_namespaceObject.Button, {
          __next40pxDefaultSize: true,
          ...buildSuggestionItemProps(suggestion, index),
          key: suggestion.id,
          className: dist_clsx(&#039;block-editor-url-input__suggestion&#039;, {
            &#039;is-selected&#039;: index === selectedSuggestion
          }),
          onClick: () =&gt; this.handleOnClick(suggestion)
        }, suggestion.title))
      })
    });
  }
}

/**
 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/url-input/README.md
 */
/* 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) =&gt; {
  // If a link suggestions handler is already provided then
  // bail.
  if (isFunction(props.__experimentalFetchLinkSuggestions)) {
    return;
  }
  const {
    getSettings
  } = select(store);
  return {
    __experimentalFetchLinkSuggestions: getSettings().__experimentalFetchLinkSuggestions
  };
}))(URLInput));

;// ./node_modules/@wordpress/icons/build-module/library/plus.js
/**
 * WordPress dependencies
 */


const plus = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;M11 12.5V17.5H12.5V12.5H17.5V11H12.5V6H11V11H6V12.5H11Z&quot;
  })
});
/* harmony default export */ const library_plus = (plus);

;// ./node_modules/@wordpress/block-editor/build-module/components/link-control/search-create-button.js
/**
 * WordPress dependencies
 */





const LinkControlSearchCreate = ({
  searchTerm,
  onClick,
  itemProps,
  buttonText
}) =&gt; {
  if (!searchTerm) {
    return null;
  }
  let text;
  if (buttonText) {
    text = typeof buttonText === &#039;function&#039; ? buttonText(searchTerm) : buttonText;
  } else {
    text = (0,external_wp_element_namespaceObject.createInterpolateElement)((0,external_wp_i18n_namespaceObject.sprintf)(/* translators: %s: search term. */
    (0,external_wp_i18n_namespaceObject.__)(&#039;Create: &lt;mark&gt;%s&lt;/mark&gt;&#039;), searchTerm), {
      mark: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;mark&quot;, {})
    });
  }
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, {
    ...itemProps,
    iconPosition: &quot;left&quot;,
    icon: library_plus,
    className: &quot;block-editor-link-control__search-item&quot;,
    onClick: onClick,
    children: text
  });
};
/* harmony default export */ const search_create_button = (LinkControlSearchCreate);

;// ./node_modules/@wordpress/icons/build-module/library/post-list.js
/**
 * WordPress dependencies
 */


const postList = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  viewBox: &quot;0 0 24 24&quot;,
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;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&quot;
  })
});
/* harmony default export */ const post_list = (postList);

;// ./node_modules/@wordpress/icons/build-module/library/page.js
/**
 * WordPress dependencies
 */


const page = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;M15.5 7.5h-7V9h7V7.5Zm-7 3.5h7v1.5h-7V11Zm7 3.5h-7V16h7v-1.5Z&quot;
  }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;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&quot;
  })]
});
/* harmony default export */ const library_page = (page);

;// ./node_modules/@wordpress/icons/build-module/library/tag.js
/**
 * WordPress dependencies
 */


const tag = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;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&quot;
  })
});
/* harmony default export */ const library_tag = (tag);

;// ./node_modules/@wordpress/icons/build-module/library/category.js
/**
 * WordPress dependencies
 */


const category = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  viewBox: &quot;0 0 24 24&quot;,
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;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&quot;,
    fillRule: &quot;evenodd&quot;,
    clipRule: &quot;evenodd&quot;
  })
});
/* harmony default export */ const library_category = (category);

;// ./node_modules/@wordpress/icons/build-module/library/file.js
/**
 * WordPress dependencies
 */


const file = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  viewBox: &quot;0 0 24 24&quot;,
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    fillRule: &quot;evenodd&quot;,
    clipRule: &quot;evenodd&quot;,
    d: &quot;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&quot;
  })
});
/* harmony default export */ const library_file = (file);

;// ./node_modules/@wordpress/icons/build-module/library/globe.js
/**
 * WordPress dependencies
 */


const globe = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;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&quot;
  })
});
/* harmony default export */ const library_globe = (globe);

;// ./node_modules/@wordpress/icons/build-module/library/home.js
/**
 * WordPress dependencies
 */


const home = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;M12 4L4 7.9V20h16V7.9L12 4zm6.5 14.5H14V13h-4v5.5H5.5V8.8L12 5.7l6.5 3.1v9.7z&quot;
  })
});
/* harmony default export */ const library_home = (home);

;// ./node_modules/@wordpress/icons/build-module/library/verse.js
/**
 * WordPress dependencies
 */


const verse = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  viewBox: &quot;0 0 24 24&quot;,
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;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&quot;
  })
});
/* harmony default export */ const library_verse = (verse);

;// ./node_modules/@wordpress/block-editor/build-module/components/link-control/search-item.js
/**
 * WordPress dependencies
 */








const ICONS_MAP = {
  post: post_list,
  page: library_page,
  post_tag: library_tag,
  category: library_category,
  attachment: library_file
};
function SearchItemIcon({
  isURL,
  suggestion
}) {
  let icon = null;
  if (isURL) {
    icon = library_globe;
  } else if (suggestion.type in ICONS_MAP) {
    icon = ICONS_MAP[suggestion.type];
    if (suggestion.type === &#039;page&#039;) {
      if (suggestion.isFrontPage) {
        icon = library_home;
      }
      if (suggestion.isBlogHome) {
        icon = library_verse;
      }
    }
  }
  if (icon) {
    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(build_module_icon, {
      className: &quot;block-editor-link-control__search-item-icon&quot;,
      icon: icon
    });
  }
  return null;
}

/**
 * Adds a leading slash to a url if it doesn&#039;t already have one.
 * @param {string} url the url to add a leading slash to.
 * @return {string} the url with a leading slash.
 */
function addLeadingSlash(url) {
  const trimmedURL = url?.trim();
  if (!trimmedURL?.length) {
    return url;
  }
  return url?.replace(/^\/?/, &#039;/&#039;);
}
function removeTrailingSlash(url) {
  const trimmedURL = url?.trim();
  if (!trimmedURL?.length) {
    return url;
  }
  return url?.replace(/\/$/, &#039;&#039;);
}
const partialRight = (fn, ...partialArgs) =&gt; (...args) =&gt; fn(...args, ...partialArgs);
const defaultTo = d =&gt; v =&gt; {
  return v === null || v === undefined || v !== v ? d : v;
};

/**
 * Prepares a URL for display in the UI.
 * - decodes the URL.
 * - filters it (removes protocol, www, etc.).
 * - truncates it if necessary.
 * - adds a leading slash.
 * @param {string} url the url.
 * @return {string} the processed url to display.
 */
function getURLForDisplay(url) {
  if (!url) {
    return url;
  }
  return (0,external_wp_compose_namespaceObject.pipe)(external_wp_url_namespaceObject.safeDecodeURI, external_wp_url_namespaceObject.getPath, defaultTo(&#039;&#039;), partialRight(external_wp_url_namespaceObject.filterURLForDisplay, 24), removeTrailingSlash, addLeadingSlash)(url);
}
const LinkControlSearchItem = ({
  itemProps,
  suggestion,
  searchTerm,
  onClick,
  isURL = false,
  shouldShowType = false
}) =&gt; {
  const info = isURL ? (0,external_wp_i18n_namespaceObject.__)(&#039;Press ENTER to add this link&#039;) : getURLForDisplay(suggestion.url);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, {
    ...itemProps,
    info: info,
    iconPosition: &quot;left&quot;,
    icon: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(SearchItemIcon, {
      suggestion: suggestion,
      isURL: isURL
    }),
    onClick: onClick,
    shortcut: shouldShowType &amp;&amp; getVisualTypeName(suggestion),
    className: &quot;block-editor-link-control__search-item&quot;,
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.TextHighlight
    // The component expects a plain text string.
    , {
      text: (0,external_wp_dom_namespaceObject.__unstableStripHTML)(suggestion.title),
      highlight: searchTerm
    })
  });
};
function getVisualTypeName(suggestion) {
  if (suggestion.isFrontPage) {
    return &#039;front page&#039;;
  }
  if (suggestion.isBlogHome) {
    return &#039;blog home&#039;;
  }

  // Rename &#039;post_tag&#039; to &#039;tag&#039;. Ideally, the API would return the localised CPT or taxonomy label.
  return suggestion.type === &#039;post_tag&#039; ? &#039;tag&#039; : suggestion.type;
}
/* harmony default export */ const search_item = (LinkControlSearchItem);
const __experimentalLinkControlSearchItem = props =&gt; {
  external_wp_deprecated_default()(&#039;wp.blockEditor.__experimentalLinkControlSearchItem&#039;, {
    since: &#039;6.8&#039;
  });
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(LinkControlSearchItem, {
    ...props
  });
};

;// ./node_modules/@wordpress/block-editor/build-module/components/link-control/constants.js
/**
 * WordPress dependencies
 */


// Used as a unique identifier for the &quot;Create&quot; option within search results.
// Used to help distinguish the &quot;Create&quot; suggestion within the search results in
// order to handle it as a unique case.
const CREATE_TYPE = &#039;__CREATE__&#039;;
const TEL_TYPE = &#039;tel&#039;;
const URL_TYPE = &#039;link&#039;;
const MAILTO_TYPE = &#039;mailto&#039;;
const INTERNAL_TYPE = &#039;internal&#039;;
const LINK_ENTRY_TYPES = [URL_TYPE, MAILTO_TYPE, TEL_TYPE, INTERNAL_TYPE];
const DEFAULT_LINK_SETTINGS = [{
  id: &#039;opensInNewTab&#039;,
  title: (0,external_wp_i18n_namespaceObject.__)(&#039;Open in new tab&#039;)
}];

;// ./node_modules/@wordpress/block-editor/build-module/components/link-control/search-results.js
/**
 * WordPress dependencies
 */



/**
 * External dependencies
 */


/**
 * Internal dependencies
 */





function LinkControlSearchResults({
  withCreateSuggestion,
  currentInputValue,
  handleSuggestionClick,
  suggestionsListProps,
  buildSuggestionItemProps,
  suggestions,
  selectedSuggestion,
  isLoading,
  isInitialSuggestions,
  createSuggestionButtonText,
  suggestionsQuery
}) {
  const resultsListClasses = dist_clsx(&#039;block-editor-link-control__search-results&#039;, {
    &#039;is-loading&#039;: isLoading
  });
  const isSingleDirectEntryResult = suggestions.length === 1 &amp;&amp; LINK_ENTRY_TYPES.includes(suggestions[0].type);
  const shouldShowCreateSuggestion = withCreateSuggestion &amp;&amp; !isSingleDirectEntryResult &amp;&amp; !isInitialSuggestions;
  // If the query has a specified type, then we can skip showing them in the result. See #24839.
  const shouldShowSuggestionsTypes = !suggestionsQuery?.type;
  const labelText = isInitialSuggestions ? (0,external_wp_i18n_namespaceObject.__)(&#039;Suggestions&#039;) : (0,external_wp_i18n_namespaceObject.sprintf)(/* translators: %s: search term. */
  (0,external_wp_i18n_namespaceObject.__)(&#039;Search results for &quot;%s&quot;&#039;), currentInputValue);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
    className: &quot;block-editor-link-control__search-results-wrapper&quot;,
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
      ...suggestionsListProps,
      className: resultsListClasses,
      &quot;aria-label&quot;: labelText,
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuGroup, {
        children: suggestions.map((suggestion, index) =&gt; {
          if (shouldShowCreateSuggestion &amp;&amp; CREATE_TYPE === suggestion.type) {
            return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(search_create_button, {
              searchTerm: currentInputValue,
              buttonText: createSuggestionButtonText,
              onClick: () =&gt; handleSuggestionClick(suggestion)
              // Intentionally only using `type` here as
              // the constant is enough to uniquely
              // identify the single &quot;CREATE&quot; suggestion.
              ,

              itemProps: buildSuggestionItemProps(suggestion, index),
              isSelected: index === selectedSuggestion
            }, suggestion.type);
          }

          // If we&#039;re not handling &quot;Create&quot; suggestions above then
          // we don&#039;t want them in the main results so exit early.
          if (CREATE_TYPE === suggestion.type) {
            return null;
          }
          return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(search_item, {
            itemProps: buildSuggestionItemProps(suggestion, index),
            suggestion: suggestion,
            index: index,
            onClick: () =&gt; {
              handleSuggestionClick(suggestion);
            },
            isSelected: index === selectedSuggestion,
            isURL: LINK_ENTRY_TYPES.includes(suggestion.type),
            searchTerm: currentInputValue,
            shouldShowType: shouldShowSuggestionsTypes,
            isFrontPage: suggestion?.isFrontPage,
            isBlogHome: suggestion?.isBlogHome
          }, `${suggestion.id}-${suggestion.type}`);
        })
      })
    })
  });
}
/* harmony default export */ const search_results = (LinkControlSearchResults);
const __experimentalLinkControlSearchResults = props =&gt; {
  external_wp_deprecated_default()(&#039;wp.blockEditor.__experimentalLinkControlSearchResults&#039;, {
    since: &#039;6.8&#039;
  });
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(LinkControlSearchResults, {
    ...props
  });
};

;// ./node_modules/@wordpress/block-editor/build-module/components/link-control/is-url-like.js
/**
 * WordPress dependencies
 */


/**
 * Determines whether a given value could be a URL. Note this does not
 * guarantee the value is a URL only that it looks like it might be one. For
 * example, just because a string has `www.` in it doesn&#039;t make it a URL,
 * but it does make it highly likely that it will be so in the context of
 * creating a link it makes sense to treat it like one.
 *
 * @param {string} val the candidate for being URL-like (or not).
 *
 * @return {boolean} whether or not the value is potentially a URL.
 */
function isURLLike(val) {
  const hasSpaces = val.includes(&#039; &#039;);
  if (hasSpaces) {
    return false;
  }
  const protocol = (0,external_wp_url_namespaceObject.getProtocol)(val);
  const protocolIsValid = (0,external_wp_url_namespaceObject.isValidProtocol)(protocol);
  const mayBeTLD = hasPossibleTLD(val);
  const isWWW = val?.startsWith(&#039;www.&#039;);
  const isInternal = val?.startsWith(&#039;#&#039;) &amp;&amp; (0,external_wp_url_namespaceObject.isValidFragment)(val);
  return protocolIsValid || isWWW || isInternal || mayBeTLD;
}

/**
 * Checks if a given URL has a valid Top-Level Domain (TLD).
 *
 * @param {string} url       - The URL to check.
 * @param {number} maxLength - The maximum length of the TLD.
 * @return {boolean} Returns true if the URL has a valid TLD, false otherwise.
 */
function hasPossibleTLD(url, maxLength = 6) {
  // Clean the URL by removing anything after the first occurrence of &quot;?&quot; or &quot;#&quot;.
  const cleanedURL = url.split(/[?#]/)[0];

  // Regular expression explanation:
  // - (?&lt;=\S)                  : Positive lookbehind assertion to ensure there is at least one non-whitespace character before the TLD
  // - \.                       : Matches a literal dot (.)
  // - [a-zA-Z_]{2,maxLength}   : Matches 2 to maxLength letters or underscores, representing the TLD
  // - (?:\/|$)                 : Non-capturing group that matches either a forward slash (/) or the end of the string
  const regex = new RegExp(`(?&lt;=\\S)\\.(?:[a-zA-Z_]{2,${maxLength}})(?:\\/|$)`);
  return regex.test(cleanedURL);
}

;// ./node_modules/@wordpress/block-editor/build-module/components/link-control/use-search-handler.js
/**
 * WordPress dependencies
 */




/**
 * Internal dependencies
 */



const handleNoop = () =&gt; Promise.resolve([]);
const handleDirectEntry = val =&gt; {
  let type = URL_TYPE;
  const protocol = (0,external_wp_url_namespaceObject.getProtocol)(val) || &#039;&#039;;
  if (protocol.includes(&#039;mailto&#039;)) {
    type = MAILTO_TYPE;
  }
  if (protocol.includes(&#039;tel&#039;)) {
    type = TEL_TYPE;
  }
  if (val?.startsWith(&#039;#&#039;)) {
    type = INTERNAL_TYPE;
  }
  return Promise.resolve([{
    id: val,
    title: val,
    url: type === &#039;URL&#039; ? (0,external_wp_url_namespaceObject.prependHTTP)(val) : val,
    type
  }]);
};
const handleEntitySearch = async (val, suggestionsQuery, fetchSearchSuggestions, withCreateSuggestion, pageOnFront, pageForPosts) =&gt; {
  const {
    isInitialSuggestions
  } = suggestionsQuery;
  const results = await fetchSearchSuggestions(val, suggestionsQuery);

  // Identify front page and update type to match.
  results.map(result =&gt; {
    if (Number(result.id) === pageOnFront) {
      result.isFrontPage = true;
      return result;
    } else if (Number(result.id) === pageForPosts) {
      result.isBlogHome = true;
      return result;
    }
    return result;
  });

  // If displaying initial suggestions just return plain results.
  if (isInitialSuggestions) {
    return results;
  }

  // Here we append a faux suggestion to represent a &quot;CREATE&quot; option. This
  // is detected in the rendering of the search results and handled as a
  // special case. This is currently necessary because the suggestions
  // dropdown will only appear if there are valid suggestions and
  // therefore unless the create option is a suggestion it will not
  // display in scenarios where there are no results returned from the
  // API. In addition promoting CREATE to a first class suggestion affords
  // the a11y benefits afforded by `URLInput` to all suggestions (eg:
  // keyboard handling, ARIA roles...etc).
  //
  // Note also that the value of the `title` and `url` properties must correspond
  // to the text value of the `&lt;input&gt;`. This is because `title` is used
  // when creating the suggestion. Similarly `url` is used when using keyboard to select
  // the suggestion (the &lt;form&gt; `onSubmit` handler falls-back to `url`).
  return isURLLike(val) || !withCreateSuggestion ? results : results.concat({
    // the `id` prop is intentionally omitted here because it
    // is never exposed as part of the component&#039;s public API.
    // see: https://github.com/WordPress/gutenberg/pull/19775#discussion_r378931316.
    title: val,
    // Must match the existing `&lt;input&gt;`s text value.
    url: val,
    // Must match the existing `&lt;input&gt;`s text value.
    type: CREATE_TYPE
  });
};
function useSearchHandler(suggestionsQuery, allowDirectEntry, withCreateSuggestion) {
  const {
    fetchSearchSuggestions,
    pageOnFront,
    pageForPosts
  } = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      getSettings
    } = select(store);
    return {
      pageOnFront: getSettings().pageOnFront,
      pageForPosts: getSettings().pageForPosts,
      fetchSearchSuggestions: getSettings().__experimentalFetchLinkSuggestions
    };
  }, []);
  const directEntryHandler = allowDirectEntry ? handleDirectEntry : handleNoop;
  return (0,external_wp_element_namespaceObject.useCallback)((val, {
    isInitialSuggestions
  }) =&gt; {
    return isURLLike(val) ? directEntryHandler(val, {
      isInitialSuggestions
    }) : handleEntitySearch(val, {
      ...suggestionsQuery,
      isInitialSuggestions
    }, fetchSearchSuggestions, withCreateSuggestion, pageOnFront, pageForPosts);
  }, [directEntryHandler, fetchSearchSuggestions, pageOnFront, pageForPosts, suggestionsQuery, withCreateSuggestion]);
}

;// ./node_modules/@wordpress/block-editor/build-module/components/link-control/search-input.js
/**
 * WordPress dependencies
 */



/**
 * Internal dependencies
 */






// Must be a function as otherwise URLInput will default
// to the fetchLinkSuggestions passed in block editor settings
// which will cause an unintended http request.

const noopSearchHandler = () =&gt; Promise.resolve([]);
const noop = () =&gt; {};
const LinkControlSearchInput = (0,external_wp_element_namespaceObject.forwardRef)(({
  value,
  children,
  currentLink = {},
  className = null,
  placeholder = null,
  withCreateSuggestion = false,
  onCreateSuggestion = noop,
  onChange = noop,
  onSelect = noop,
  showSuggestions = true,
  renderSuggestions = props =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(search_results, {
    ...props
  }),
  fetchSuggestions = null,
  allowDirectEntry = true,
  showInitialSuggestions = false,
  suggestionsQuery = {},
  withURLSuggestion = true,
  createSuggestionButtonText,
  hideLabelFromVision = false,
  suffix
}, ref) =&gt; {
  const genericSearchHandler = useSearchHandler(suggestionsQuery, allowDirectEntry, withCreateSuggestion, withURLSuggestion);
  const searchHandler = showSuggestions ? fetchSuggestions || genericSearchHandler : noopSearchHandler;
  const [focusedSuggestion, setFocusedSuggestion] = (0,external_wp_element_namespaceObject.useState)();

  /**
   * Handles the user moving between different suggestions. Does not handle
   * choosing an individual item.
   *
   * @param {string} selection  the url of the selected suggestion.
   * @param {Object} suggestion the suggestion object.
   */
  const onInputChange = (selection, suggestion) =&gt; {
    onChange(selection);
    setFocusedSuggestion(suggestion);
  };
  const handleRenderSuggestions = props =&gt; renderSuggestions({
    ...props,
    withCreateSuggestion,
    createSuggestionButtonText,
    suggestionsQuery,
    handleSuggestionClick: suggestion =&gt; {
      if (props.handleSuggestionClick) {
        props.handleSuggestionClick(suggestion);
      }
      onSuggestionSelected(suggestion);
    }
  });
  const onSuggestionSelected = async selectedSuggestion =&gt; {
    let suggestion = selectedSuggestion;
    if (CREATE_TYPE === selectedSuggestion.type) {
      // Create a new page and call onSelect with the output from the onCreateSuggestion callback.
      try {
        suggestion = await onCreateSuggestion(selectedSuggestion.title);
        if (suggestion?.url) {
          onSelect(suggestion);
        }
      } catch (e) {}
      return;
    }
    if (allowDirectEntry || suggestion &amp;&amp; Object.keys(suggestion).length &gt;= 1) {
      const {
        id,
        url,
        ...restLinkProps
      } = currentLink !== null &amp;&amp; currentLink !== void 0 ? currentLink : {};
      onSelect(
      // Some direct entries don&#039;t have types or IDs, and we still need to clear the previous ones.
      {
        ...restLinkProps,
        ...suggestion
      }, suggestion);
    }
  };
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;div&quot;, {
    className: &quot;block-editor-link-control__search-input-container&quot;,
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(url_input, {
      disableSuggestions: currentLink?.url === value,
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Link&#039;),
      hideLabelFromVision: hideLabelFromVision,
      className: className,
      value: value,
      onChange: onInputChange,
      placeholder: placeholder !== null &amp;&amp; placeholder !== void 0 ? placeholder : (0,external_wp_i18n_namespaceObject.__)(&#039;Search or type URL&#039;),
      __experimentalRenderSuggestions: showSuggestions ? handleRenderSuggestions : null,
      __experimentalFetchLinkSuggestions: searchHandler,
      __experimentalHandleURLSuggestions: true,
      __experimentalShowInitialSuggestions: showInitialSuggestions,
      onSubmit: (suggestion, event) =&gt; {
        const hasSuggestion = suggestion || focusedSuggestion;

        // If there is no suggestion and the value (ie: any manually entered URL) is empty
        // then don&#039;t allow submission otherwise we get empty links.
        if (!hasSuggestion &amp;&amp; !value?.trim()?.length) {
          event.preventDefault();
        } else {
          onSuggestionSelected(hasSuggestion || {
            url: value
          });
        }
      },
      ref: ref,
      suffix: suffix
    }), children]
  });
});
/* harmony default export */ const search_input = (LinkControlSearchInput);
const __experimentalLinkControlSearchInput = props =&gt; {
  external_wp_deprecated_default()(&#039;wp.blockEditor.__experimentalLinkControlSearchInput&#039;, {
    since: &#039;6.8&#039;
  });
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(LinkControlSearchInput, {
    ...props
  });
};

;// ./node_modules/@wordpress/icons/build-module/library/info.js
/**
 * WordPress dependencies
 */


const info = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  viewBox: &quot;0 0 24 24&quot;,
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    fillRule: &quot;evenodd&quot;,
    clipRule: &quot;evenodd&quot;,
    d: &quot;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&quot;
  })
});
/* harmony default export */ const library_info = (info);

;// ./node_modules/@wordpress/icons/build-module/library/pencil.js
/**
 * WordPress dependencies
 */


const pencil = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;m19 7-3-3-8.5 8.5-1 4 4-1L19 7Zm-7 11.5H5V20h7v-1.5Z&quot;
  })
});
/* harmony default export */ const library_pencil = (pencil);

;// ./node_modules/@wordpress/icons/build-module/library/edit.js
/**
 * Internal dependencies
 */


/* harmony default export */ const edit = (library_pencil);

;// ./node_modules/@wordpress/icons/build-module/library/link-off.js
/**
 * WordPress dependencies
 */


const linkOff = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;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&quot;
  })
});
/* harmony default export */ const link_off = (linkOff);

;// ./node_modules/@wordpress/icons/build-module/library/copy-small.js
/**
 * WordPress dependencies
 */


const copySmall = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    fillRule: &quot;evenodd&quot;,
    clipRule: &quot;evenodd&quot;,
    d: &quot;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&quot;
  })
});
/* harmony default export */ const copy_small = (copySmall);

;// ./node_modules/@wordpress/block-editor/build-module/components/link-control/viewer-slot.js
/**
 * WordPress dependencies
 */

const {
  Slot: ViewerSlot,
  Fill: ViewerFill
} = (0,external_wp_components_namespaceObject.createSlotFill)(&#039;BlockEditorLinkControlViewer&#039;);

/* harmony default export */ const viewer_slot = ((/* unused pure expression or super */ null &amp;&amp; (ViewerSlot)));

;// ./node_modules/@wordpress/block-editor/build-module/components/link-control/use-rich-url-data.js
/**
 * Internal dependencies
 */


/**
 * WordPress dependencies
 */


function use_rich_url_data_reducer(state, action) {
  switch (action.type) {
    case &#039;RESOLVED&#039;:
      return {
        ...state,
        isFetching: false,
        richData: action.richData
      };
    case &#039;ERROR&#039;:
      return {
        ...state,
        isFetching: false,
        richData: null
      };
    case &#039;LOADING&#039;:
      return {
        ...state,
        isFetching: true
      };
    default:
      throw new Error(`Unexpected action type ${action.type}`);
  }
}
function useRemoteUrlData(url) {
  const [state, dispatch] = (0,external_wp_element_namespaceObject.useReducer)(use_rich_url_data_reducer, {
    richData: null,
    isFetching: false
  });
  const {
    fetchRichUrlData
  } = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      getSettings
    } = select(store);
    return {
      fetchRichUrlData: getSettings().__experimentalFetchRichUrlData
    };
  }, []);
  (0,external_wp_element_namespaceObject.useEffect)(() =&gt; {
    // Only make the request if we have an actual URL
    // and the fetching util is available. In some editors
    // there may not be such a util.
    if (url?.length &amp;&amp; fetchRichUrlData &amp;&amp; typeof AbortController !== &#039;undefined&#039;) {
      dispatch({
        type: &#039;LOADING&#039;
      });
      const controller = new window.AbortController();
      const signal = controller.signal;
      fetchRichUrlData(url, {
        signal
      }).then(urlData =&gt; {
        dispatch({
          type: &#039;RESOLVED&#039;,
          richData: urlData
        });
      }).catch(() =&gt; {
        // Avoid setting state on unmounted component
        if (!signal.aborted) {
          dispatch({
            type: &#039;ERROR&#039;
          });
        }
      });
      // Cleanup: when the URL changes the abort the current request.
      return () =&gt; {
        controller.abort();
      };
    }
  }, [url]);
  return state;
}
/* harmony default export */ const use_rich_url_data = (useRemoteUrlData);

;// ./node_modules/@wordpress/block-editor/build-module/components/link-control/link-preview.js
/**
 * External dependencies
 */


/**
 * WordPress dependencies
 */










/**
 * Internal dependencies
 */



/**
 * Filters the title for display. Removes the protocol and www prefix.
 *
 * @param {string} title The title to be filtered.
 *
 * @return {string} The filtered title.
 */

function filterTitleForDisplay(title) {
  // Derived from `filterURLForDisplay` in `@wordpress/url`.
  return title.replace(/^[a-z\-.\+]+[0-9]*:(\/\/)?/i, &#039;&#039;).replace(/^www\./i, &#039;&#039;);
}
function LinkPreview({
  value,
  onEditClick,
  hasRichPreviews = false,
  hasUnlinkControl = false,
  onRemove
}) {
  const showIconLabels = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; select(external_wp_preferences_namespaceObject.store).get(&#039;core&#039;, &#039;showIconLabels&#039;), []);

  // Avoid fetching if rich previews are not desired.
  const showRichPreviews = hasRichPreviews ? value?.url : null;
  const {
    richData,
    isFetching
  } = use_rich_url_data(showRichPreviews);

  // Rich data may be an empty object so test for that.
  const hasRichData = richData &amp;&amp; Object.keys(richData).length;
  const displayURL = value &amp;&amp; (0,external_wp_url_namespaceObject.filterURLForDisplay)((0,external_wp_url_namespaceObject.safeDecodeURI)(value.url), 24) || &#039;&#039;;

  // url can be undefined if the href attribute is unset
  const isEmptyURL = !value?.url?.length;
  const displayTitle = !isEmptyURL &amp;&amp; (0,external_wp_dom_namespaceObject.__unstableStripHTML)(richData?.title || value?.title || displayURL);
  const isUrlRedundant = !value?.url || filterTitleForDisplay(displayTitle) === displayURL;
  let icon;
  if (richData?.icon) {
    icon = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;img&quot;, {
      src: richData?.icon,
      alt: &quot;&quot;
    });
  } else if (isEmptyURL) {
    icon = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(build_module_icon, {
      icon: library_info,
      size: 32
    });
  } else {
    icon = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(build_module_icon, {
      icon: library_globe
    });
  }
  const {
    createNotice
  } = (0,external_wp_data_namespaceObject.useDispatch)(external_wp_notices_namespaceObject.store);
  const ref = (0,external_wp_compose_namespaceObject.useCopyToClipboard)(value.url, () =&gt; {
    createNotice(&#039;info&#039;, (0,external_wp_i18n_namespaceObject.__)(&#039;Link copied to clipboard.&#039;), {
      isDismissible: true,
      type: &#039;snackbar&#039;
    });
  });
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
    role: &quot;group&quot;,
    &quot;aria-label&quot;: (0,external_wp_i18n_namespaceObject.__)(&#039;Manage link&#039;),
    className: dist_clsx(&#039;block-editor-link-control__search-item&#039;, {
      &#039;is-current&#039;: true,
      &#039;is-rich&#039;: hasRichData,
      &#039;is-fetching&#039;: !!isFetching,
      &#039;is-preview&#039;: true,
      &#039;is-error&#039;: isEmptyURL,
      &#039;is-url-title&#039;: displayTitle === displayURL
    }),
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;div&quot;, {
      className: &quot;block-editor-link-control__search-item-top&quot;,
      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;span&quot;, {
        className: &quot;block-editor-link-control__search-item-header&quot;,
        role: &quot;figure&quot;,
        &quot;aria-label&quot;: /* translators: Accessibility text for the link preview when editing a link. */
        (0,external_wp_i18n_namespaceObject.__)(&#039;Link information&#039;),
        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;span&quot;, {
          className: dist_clsx(&#039;block-editor-link-control__search-item-icon&#039;, {
            &#039;is-image&#039;: richData?.icon
          }),
          children: icon
        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;span&quot;, {
          className: &quot;block-editor-link-control__search-item-details&quot;,
          children: !isEmptyURL ? /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
            children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ExternalLink, {
              className: &quot;block-editor-link-control__search-item-title&quot;,
              href: value.url,
              children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalTruncate, {
                numberOfLines: 1,
                children: displayTitle
              })
            }), !isUrlRedundant &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;span&quot;, {
              className: &quot;block-editor-link-control__search-item-info&quot;,
              children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalTruncate, {
                numberOfLines: 1,
                children: displayURL
              })
            })]
          }) : /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;span&quot;, {
            className: &quot;block-editor-link-control__search-item-error-notice&quot;,
            children: (0,external_wp_i18n_namespaceObject.__)(&#039;Link is empty&#039;)
          })
        })]
      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
        icon: edit,
        label: (0,external_wp_i18n_namespaceObject.__)(&#039;Edit link&#039;),
        onClick: onEditClick,
        size: &quot;compact&quot;,
        showTooltip: !showIconLabels
      }), hasUnlinkControl &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
        icon: link_off,
        label: (0,external_wp_i18n_namespaceObject.__)(&#039;Remove link&#039;),
        onClick: onRemove,
        size: &quot;compact&quot;,
        showTooltip: !showIconLabels
      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
        icon: copy_small,
        label: (0,external_wp_i18n_namespaceObject.__)(&#039;Copy link&#039;),
        ref: ref,
        accessibleWhenDisabled: true,
        disabled: isEmptyURL,
        size: &quot;compact&quot;,
        showTooltip: !showIconLabels
      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ViewerSlot, {
        fillProps: value
      })]
    })
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/link-control/settings.js
/**
 * WordPress dependencies
 */



const settings_noop = () =&gt; {};
const LinkControlSettings = ({
  value,
  onChange = settings_noop,
  settings
}) =&gt; {
  if (!settings || !settings.length) {
    return null;
  }
  const handleSettingChange = setting =&gt; newValue =&gt; {
    onChange({
      ...value,
      [setting.id]: newValue
    });
  };
  const theSettings = settings.map(setting =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.CheckboxControl, {
    __nextHasNoMarginBottom: true,
    className: &quot;block-editor-link-control__setting&quot;,
    label: setting.title,
    onChange: handleSettingChange(setting),
    checked: value ? !!value[setting.id] : false,
    help: setting?.help
  }, setting.id));
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;fieldset&quot;, {
    className: &quot;block-editor-link-control__settings&quot;,
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.VisuallyHidden, {
      as: &quot;legend&quot;,
      children: (0,external_wp_i18n_namespaceObject.__)(&#039;Currently selected link settings&#039;)
    }), theSettings]
  });
};
/* harmony default export */ const link_control_settings = (LinkControlSettings);

;// ./node_modules/@wordpress/block-editor/build-module/components/link-control/use-create-page.js
/**
 * WordPress dependencies
 */


function useCreatePage(handleCreatePage) {
  const cancelableCreateSuggestion = (0,external_wp_element_namespaceObject.useRef)();
  const [isCreatingPage, setIsCreatingPage] = (0,external_wp_element_namespaceObject.useState)(false);
  const [errorMessage, setErrorMessage] = (0,external_wp_element_namespaceObject.useState)(null);
  const createPage = async function (suggestionTitle) {
    setIsCreatingPage(true);
    setErrorMessage(null);
    try {
      // Make cancellable in order that we can avoid setting State
      // if the component unmounts during the call to `createSuggestion`
      cancelableCreateSuggestion.current = makeCancelable(
      // Using Promise.resolve to allow createSuggestion to return a
      // non-Promise based value.
      Promise.resolve(handleCreatePage(suggestionTitle)));
      return await cancelableCreateSuggestion.current.promise;
    } catch (error) {
      if (error &amp;&amp; error.isCanceled) {
        return; // bail if canceled to avoid setting state
      }
      setErrorMessage(error.message || (0,external_wp_i18n_namespaceObject.__)(&#039;An unknown error occurred during creation. Please try again.&#039;));
      throw error;
    } finally {
      setIsCreatingPage(false);
    }
  };

  /**
   * Handles cancelling any pending Promises that have been made cancelable.
   */
  (0,external_wp_element_namespaceObject.useEffect)(() =&gt; {
    return () =&gt; {
      // componentDidUnmount
      if (cancelableCreateSuggestion.current) {
        cancelableCreateSuggestion.current.cancel();
      }
    };
  }, []);
  return {
    createPage,
    isCreatingPage,
    errorMessage
  };
}

/**
 * Creates a wrapper around a promise which allows it to be programmatically
 * cancelled.
 * See: https://reactjs.org/blog/2015/12/16/ismounted-antipattern.html
 *
 * @param {Promise} promise the Promise to make cancelable
 */
const makeCancelable = promise =&gt; {
  let hasCanceled_ = false;
  const wrappedPromise = new Promise((resolve, reject) =&gt; {
    promise.then(val =&gt; hasCanceled_ ? reject({
      isCanceled: true
    }) : resolve(val), error =&gt; hasCanceled_ ? reject({
      isCanceled: true
    }) : reject(error));
  });
  return {
    promise: wrappedPromise,
    cancel() {
      hasCanceled_ = true;
    }
  };
};

// EXTERNAL MODULE: ./node_modules/fast-deep-equal/index.js
var fast_deep_equal = __webpack_require__(5215);
var fast_deep_equal_default = /*#__PURE__*/__webpack_require__.n(fast_deep_equal);
;// ./node_modules/@wordpress/block-editor/build-module/components/link-control/use-internal-value.js
/**
 * WordPress dependencies
 */


/**
 * External dependencies
 */

function useInternalValue(value) {
  const [internalValue, setInternalValue] = (0,external_wp_element_namespaceObject.useState)(value || {});
  const [previousValue, setPreviousValue] = (0,external_wp_element_namespaceObject.useState)(value);

  // If the value prop changes, update the internal state.
  // See:
  // - https://github.com/WordPress/gutenberg/pull/51387#issuecomment-1722927384.
  // - https://react.dev/reference/react/useState#storing-information-from-previous-renders.
  if (!fast_deep_equal_default()(value, previousValue)) {
    setPreviousValue(value);
    setInternalValue(value);
  }
  const setInternalURLInputValue = nextValue =&gt; {
    setInternalValue({
      ...internalValue,
      url: nextValue
    });
  };
  const setInternalTextInputValue = nextValue =&gt; {
    setInternalValue({
      ...internalValue,
      title: nextValue
    });
  };
  const createSetInternalSettingValueHandler = settingsKeys =&gt; nextValue =&gt; {
    // Only apply settings values which are defined in the settings prop.
    const settingsUpdates = Object.keys(nextValue).reduce((acc, key) =&gt; {
      if (settingsKeys.includes(key)) {
        acc[key] = nextValue[key];
      }
      return acc;
    }, {});
    setInternalValue({
      ...internalValue,
      ...settingsUpdates
    });
  };
  return [internalValue, setInternalValue, setInternalURLInputValue, setInternalTextInputValue, createSetInternalSettingValueHandler];
}

;// ./node_modules/@wordpress/block-editor/build-module/components/link-control/index.js
/**
 * External dependencies
 */


/**
 * WordPress dependencies
 */










/**
 * Internal dependencies
 */










/**
 * Default properties associated with a link control value.
 *
 * @typedef WPLinkControlDefaultValue
 *
 * @property {string}   url           Link URL.
 * @property {string=}  title         Link title.
 * @property {boolean=} opensInNewTab Whether link should open in a new browser
 *                                    tab. This value is only assigned if not
 *                                    providing a custom `settings` prop.
 */

/* eslint-disable jsdoc/valid-types */
/**
 * Custom settings values associated with a link.
 *
 * @typedef {{[setting:string]:any}} WPLinkControlSettingsValue
 */
/* eslint-enable */

/**
 * Custom settings values associated with a link.
 *
 * @typedef WPLinkControlSetting
 *
 * @property {string} id    Identifier to use as property for setting value.
 * @property {string} title Human-readable label to show in user interface.
 */

/**
 * Properties associated with a link control value, composed as a union of the
 * default properties and any custom settings values.
 *
 * @typedef {WPLinkControlDefaultValue&amp;WPLinkControlSettingsValue} WPLinkControlValue
 */

/** @typedef {(nextValue:WPLinkControlValue)=&gt;void} WPLinkControlOnChangeProp */

/**
 * Properties associated with a search suggestion used within the LinkControl.
 *
 * @typedef WPLinkControlSuggestion
 *
 * @property {string} id    Identifier to use to uniquely identify the suggestion.
 * @property {string} type  Identifies the type of the suggestion (eg: `post`,
 *                          `page`, `url`...etc)
 * @property {string} title Human-readable label to show in user interface.
 * @property {string} url   A URL for the suggestion.
 */

/** @typedef {(title:string)=&gt;WPLinkControlSuggestion} WPLinkControlCreateSuggestionProp */

/**
 * @typedef WPLinkControlProps
 *
 * @property {(WPLinkControlSetting[])=}  settings                   An array of settings objects. Each object will used to
 *                                                                   render a `ToggleControl` for that setting.
 * @property {boolean=}                   forceIsEditingLink         If passed as either `true` or `false`, controls the
 *                                                                   internal editing state of the component to respective
 *                                                                   show or not show the URL input field.
 * @property {WPLinkControlValue=}        value                      Current link value.
 * @property {WPLinkControlOnChangeProp=} onChange                   Value change handler, called with the updated value if
 *                                                                   the user selects a new link or updates settings.
 * @property {boolean=}                   noDirectEntry              Whether to allow turning a URL-like search query directly into a link.
 * @property {boolean=}                   showSuggestions            Whether to present suggestions when typing the URL.
 * @property {boolean=}                   showInitialSuggestions     Whether to present initial suggestions immediately.
 * @property {boolean=}                   withCreateSuggestion       Whether to allow creation of link value from suggestion.
 * @property {Object=}                    suggestionsQuery           Query parameters to pass along to wp.blockEditor.__experimentalFetchLinkSuggestions.
 * @property {boolean=}                   noURLSuggestion            Whether to add a fallback suggestion which treats the search query as a URL.
 * @property {boolean=}                   hasTextControl             Whether to add a text field to the UI to update the value.title.
 * @property {string|Function|undefined}  createSuggestionButtonText The text to use in the button that calls createSuggestion.
 * @property {Function}                   renderControlBottom        Optional controls to be rendered at the bottom of the component.
 */

const link_control_noop = () =&gt; {};
const PREFERENCE_SCOPE = &#039;core/block-editor&#039;;
const PREFERENCE_KEY = &#039;linkControlSettingsDrawer&#039;;

/**
 * Renders a link control. A link control is a controlled input which maintains
 * a value associated with a link (HTML anchor element) and relevant settings
 * for how that link is expected to behave.
 *
 * @param {WPLinkControlProps} props Component props.
 */
function LinkControl({
  searchInputPlaceholder,
  value,
  settings = DEFAULT_LINK_SETTINGS,
  onChange = link_control_noop,
  onRemove,
  onCancel,
  noDirectEntry = false,
  showSuggestions = true,
  showInitialSuggestions,
  forceIsEditingLink,
  createSuggestion,
  withCreateSuggestion,
  inputValue: propInputValue = &#039;&#039;,
  suggestionsQuery = {},
  noURLSuggestion = false,
  createSuggestionButtonText,
  hasRichPreviews = false,
  hasTextControl = false,
  renderControlBottom = null
}) {
  if (withCreateSuggestion === undefined &amp;&amp; createSuggestion) {
    withCreateSuggestion = true;
  }
  const [settingsOpen, setSettingsOpen] = (0,external_wp_element_namespaceObject.useState)(false);
  const {
    advancedSettingsPreference
  } = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    var _prefsStore$get;
    const prefsStore = select(external_wp_preferences_namespaceObject.store);
    return {
      advancedSettingsPreference: (_prefsStore$get = prefsStore.get(PREFERENCE_SCOPE, PREFERENCE_KEY)) !== null &amp;&amp; _prefsStore$get !== void 0 ? _prefsStore$get : false
    };
  }, []);
  const {
    set: setPreference
  } = (0,external_wp_data_namespaceObject.useDispatch)(external_wp_preferences_namespaceObject.store);

  /**
   * Sets the open/closed state of the Advanced Settings Drawer,
   * optionlly persisting the state to the user&#039;s preferences.
   *
   * Note that Block Editor components can be consumed by non-WordPress
   * environments which may not have preferences setup.
   * Therefore a local state is also  used as a fallback.
   *
   * @param {boolean} prefVal the open/closed state of the Advanced Settings Drawer.
   */
  const setSettingsOpenWithPreference = prefVal =&gt; {
    if (setPreference) {
      setPreference(PREFERENCE_SCOPE, PREFERENCE_KEY, prefVal);
    }
    setSettingsOpen(prefVal);
  };

  // Block Editor components can be consumed by non-WordPress environments
  // which may not have these preferences setup.
  // Therefore a local state is used as a fallback.
  const isSettingsOpen = advancedSettingsPreference || settingsOpen;
  const isMountingRef = (0,external_wp_element_namespaceObject.useRef)(true);
  const wrapperNode = (0,external_wp_element_namespaceObject.useRef)();
  const textInputRef = (0,external_wp_element_namespaceObject.useRef)();
  const isEndingEditWithFocusRef = (0,external_wp_element_namespaceObject.useRef)(false);
  const settingsKeys = settings.map(({
    id
  }) =&gt; id);
  const [internalControlValue, setInternalControlValue, setInternalURLInputValue, setInternalTextInputValue, createSetInternalSettingValueHandler] = useInternalValue(value);
  const valueHasChanges = value &amp;&amp; !(0,external_wp_isShallowEqual_namespaceObject.isShallowEqualObjects)(internalControlValue, value);
  const [isEditingLink, setIsEditingLink] = (0,external_wp_element_namespaceObject.useState)(forceIsEditingLink !== undefined ? forceIsEditingLink : !value || !value.url);
  const {
    createPage,
    isCreatingPage,
    errorMessage
  } = useCreatePage(createSuggestion);
  (0,external_wp_element_namespaceObject.useEffect)(() =&gt; {
    if (forceIsEditingLink === undefined) {
      return;
    }
    setIsEditingLink(forceIsEditingLink);
  }, [forceIsEditingLink]);
  (0,external_wp_element_namespaceObject.useEffect)(() =&gt; {
    // We don&#039;t auto focus into the Link UI on mount
    // because otherwise using the keyboard to select text
    // *within* the link format is not possible.
    if (isMountingRef.current) {
      return;
    }

    // Scenario - when:
    // - switching between editable and non editable LinkControl
    // - clicking on a link
    // ...then move focus to the *first* element to avoid focus loss
    // and to ensure focus is *within* the Link UI.
    const nextFocusTarget = external_wp_dom_namespaceObject.focus.focusable.find(wrapperNode.current)[0] || wrapperNode.current;
    nextFocusTarget.focus();
    isEndingEditWithFocusRef.current = false;
  }, [isEditingLink, isCreatingPage]);

  // The component mounting reference is maintained separately
  // to correctly reset values in `StrictMode`.
  (0,external_wp_element_namespaceObject.useEffect)(() =&gt; {
    isMountingRef.current = false;
    return () =&gt; {
      isMountingRef.current = true;
    };
  }, []);
  const hasLinkValue = value?.url?.trim()?.length &gt; 0;

  /**
   * Cancels editing state and marks that focus may need to be restored after
   * the next render, if focus was within the wrapper when editing finished.
   */
  const stopEditing = () =&gt; {
    isEndingEditWithFocusRef.current = !!wrapperNode.current?.contains(wrapperNode.current.ownerDocument.activeElement);
    setIsEditingLink(false);
  };
  const handleSelectSuggestion = updatedValue =&gt; {
    // Suggestions may contains &quot;settings&quot; values (e.g. `opensInNewTab`)
    // which should not override any existing settings values set by the
    // user. This filters out any settings values from the suggestion.
    const nonSettingsChanges = Object.keys(updatedValue).reduce((acc, key) =&gt; {
      if (!settingsKeys.includes(key)) {
        acc[key] = updatedValue[key];
      }
      return acc;
    }, {});
    onChange({
      ...internalControlValue,
      ...nonSettingsChanges,
      // As title is not a setting, it must be manually applied
      // in such a way as to preserve the users changes over
      // any &quot;title&quot; value provided by the &quot;suggestion&quot;.
      title: internalControlValue?.title || updatedValue?.title
    });
    stopEditing();
  };
  const handleSubmit = () =&gt; {
    if (valueHasChanges) {
      // Submit the original value with new stored values applied
      // on top. URL is a special case as it may also be a prop.
      onChange({
        ...value,
        ...internalControlValue,
        url: currentUrlInputValue
      });
    }
    stopEditing();
  };
  const handleSubmitWithEnter = event =&gt; {
    const {
      keyCode
    } = event;
    if (keyCode === external_wp_keycodes_namespaceObject.ENTER &amp;&amp; !currentInputIsEmpty // Disallow submitting empty values.
    ) {
      event.preventDefault();
      handleSubmit();
    }
  };
  const resetInternalValues = () =&gt; {
    setInternalControlValue(value);
  };
  const handleCancel = event =&gt; {
    event.preventDefault();
    event.stopPropagation();

    // Ensure that any unsubmitted input changes are reset.
    resetInternalValues();
    if (hasLinkValue) {
      // If there is a link then exist editing mode and show preview.
      stopEditing();
    } else {
      // If there is no link value, then remove the link entirely.
      onRemove?.();
    }
    onCancel?.();
  };
  const currentUrlInputValue = propInputValue || internalControlValue?.url || &#039;&#039;;
  const currentInputIsEmpty = !currentUrlInputValue?.trim()?.length;
  const shownUnlinkControl = onRemove &amp;&amp; value &amp;&amp; !isEditingLink &amp;&amp; !isCreatingPage;
  const showActions = isEditingLink &amp;&amp; hasLinkValue;

  // Only show text control once a URL value has been committed
  // and it isn&#039;t just empty whitespace.
  // See https://github.com/WordPress/gutenberg/pull/33849/#issuecomment-932194927.
  const showTextControl = hasLinkValue &amp;&amp; hasTextControl;
  const isEditing = (isEditingLink || !value) &amp;&amp; !isCreatingPage;
  const isDisabled = !valueHasChanges || currentInputIsEmpty;
  const showSettings = !!settings?.length &amp;&amp; isEditingLink &amp;&amp; hasLinkValue;
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;div&quot;, {
    tabIndex: -1,
    ref: wrapperNode,
    className: &quot;block-editor-link-control&quot;,
    children: [isCreatingPage &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;div&quot;, {
      className: &quot;block-editor-link-control__loading&quot;,
      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Spinner, {}), &quot; &quot;, (0,external_wp_i18n_namespaceObject.__)(&#039;Creating&#039;), &quot;\u2026&quot;]
    }), isEditing &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;div&quot;, {
        className: dist_clsx({
          &#039;block-editor-link-control__search-input-wrapper&#039;: true,
          &#039;has-text-control&#039;: showTextControl,
          &#039;has-actions&#039;: showActions
        }),
        children: [showTextControl &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.TextControl, {
          __nextHasNoMarginBottom: true,
          ref: textInputRef,
          className: &quot;block-editor-link-control__field block-editor-link-control__text-content&quot;,
          label: (0,external_wp_i18n_namespaceObject.__)(&#039;Text&#039;),
          value: internalControlValue?.title,
          onChange: setInternalTextInputValue,
          onKeyDown: handleSubmitWithEnter,
          __next40pxDefaultSize: true
        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(search_input, {
          currentLink: value,
          className: &quot;block-editor-link-control__field block-editor-link-control__search-input&quot;,
          placeholder: searchInputPlaceholder,
          value: currentUrlInputValue,
          withCreateSuggestion: withCreateSuggestion,
          onCreateSuggestion: createPage,
          onChange: setInternalURLInputValue,
          onSelect: handleSelectSuggestion,
          showInitialSuggestions: showInitialSuggestions,
          allowDirectEntry: !noDirectEntry,
          showSuggestions: showSuggestions,
          suggestionsQuery: suggestionsQuery,
          withURLSuggestion: !noURLSuggestion,
          createSuggestionButtonText: createSuggestionButtonText,
          hideLabelFromVision: !showTextControl,
          suffix: showActions ? undefined : /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalInputControlSuffixWrapper, {
            variant: &quot;control&quot;,
            children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
              onClick: isDisabled ? link_control_noop : handleSubmit,
              label: (0,external_wp_i18n_namespaceObject.__)(&#039;Submit&#039;),
              icon: keyboard_return,
              className: &quot;block-editor-link-control__search-submit&quot;,
              &quot;aria-disabled&quot;: isDisabled,
              size: &quot;small&quot;
            })
          })
        })]
      }), errorMessage &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Notice, {
        className: &quot;block-editor-link-control__search-error&quot;,
        status: &quot;error&quot;,
        isDismissible: false,
        children: errorMessage
      })]
    }), value &amp;&amp; !isEditingLink &amp;&amp; !isCreatingPage &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(LinkPreview, {
      // force remount when URL changes to avoid race conditions for rich previews
      value: value,
      onEditClick: () =&gt; setIsEditingLink(true),
      hasRichPreviews: hasRichPreviews,
      hasUnlinkControl: shownUnlinkControl,
      onRemove: () =&gt; {
        onRemove();
        setIsEditingLink(true);
      }
    }, value?.url), showSettings &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
      className: &quot;block-editor-link-control__tools&quot;,
      children: !currentInputIsEmpty &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(settings_drawer, {
        settingsOpen: isSettingsOpen,
        setSettingsOpen: setSettingsOpenWithPreference,
        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(link_control_settings, {
          value: internalControlValue,
          settings: settings,
          onChange: createSetInternalSettingValueHandler(settingsKeys)
        })
      })
    }), showActions &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalHStack, {
      justify: &quot;right&quot;,
      className: &quot;block-editor-link-control__search-actions&quot;,
      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
        __next40pxDefaultSize: true,
        variant: &quot;tertiary&quot;,
        onClick: handleCancel,
        children: (0,external_wp_i18n_namespaceObject.__)(&#039;Cancel&#039;)
      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
        __next40pxDefaultSize: true,
        variant: &quot;primary&quot;,
        onClick: isDisabled ? link_control_noop : handleSubmit,
        className: &quot;block-editor-link-control__search-submit&quot;,
        &quot;aria-disabled&quot;: isDisabled,
        children: (0,external_wp_i18n_namespaceObject.__)(&#039;Save&#039;)
      })]
    }), !isCreatingPage &amp;&amp; renderControlBottom &amp;&amp; renderControlBottom()]
  });
}
LinkControl.ViewerFill = ViewerFill;
LinkControl.DEFAULT_LINK_SETTINGS = DEFAULT_LINK_SETTINGS;
const DeprecatedExperimentalLinkControl = props =&gt; {
  external_wp_deprecated_default()(&#039;wp.blockEditor.__experimentalLinkControl&#039;, {
    since: &#039;6.8&#039;,
    alternative: &#039;wp.blockEditor.LinkControl&#039;
  });
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(LinkControl, {
    ...props
  });
};
DeprecatedExperimentalLinkControl.ViewerFill = LinkControl.ViewerFill;
DeprecatedExperimentalLinkControl.DEFAULT_LINK_SETTINGS = LinkControl.DEFAULT_LINK_SETTINGS;

/* harmony default export */ const link_control = (LinkControl);

;// ./node_modules/@wordpress/block-editor/build-module/components/media-replace-flow/index.js
/**
 * WordPress dependencies
 */










/**
 * Internal dependencies
 */





const media_replace_flow_noop = () =&gt; {};
let uniqueId = 0;
const MediaReplaceFlow = ({
  mediaURL,
  mediaId,
  mediaIds,
  allowedTypes,
  accept,
  onError,
  onSelect,
  onSelectURL,
  onReset,
  onToggleFeaturedImage,
  useFeaturedImage,
  onFilesUpload = media_replace_flow_noop,
  name = (0,external_wp_i18n_namespaceObject.__)(&#039;Replace&#039;),
  createNotice,
  removeNotice,
  children,
  multiple = false,
  addToGallery,
  handleUpload = true,
  popoverProps,
  renderToggle
}) =&gt; {
  const {
    getSettings
  } = (0,external_wp_data_namespaceObject.useSelect)(store);
  const errorNoticeID = `block-editor/media-replace-flow/error-notice/${++uniqueId}`;
  const onUploadError = message =&gt; {
    const safeMessage = (0,external_wp_dom_namespaceObject.__unstableStripHTML)(message);
    if (onError) {
      onError(safeMessage);
      return;
    }
    // We need to set a timeout for showing the notice
    // so that VoiceOver and possibly other screen readers
    // can announce the error after the toolbar button
    // regains focus once the upload dialog closes.
    // Otherwise VO simply skips over the notice and announces
    // the focused element and the open menu.
    setTimeout(() =&gt; {
      createNotice(&#039;error&#039;, safeMessage, {
        speak: true,
        id: errorNoticeID,
        isDismissible: true
      });
    }, 1000);
  };
  const selectMedia = (media, closeMenu) =&gt; {
    if (useFeaturedImage &amp;&amp; onToggleFeaturedImage) {
      onToggleFeaturedImage();
    }
    closeMenu();
    // Calling `onSelect` after the state update since it might unmount the component.
    onSelect(media);
    (0,external_wp_a11y_namespaceObject.speak)((0,external_wp_i18n_namespaceObject.__)(&#039;The media file has been replaced&#039;));
    removeNotice(errorNoticeID);
  };
  const uploadFiles = (event, closeMenu) =&gt; {
    const files = event.target.files;
    if (!handleUpload) {
      closeMenu();
      return onSelect(files);
    }
    onFilesUpload(files);
    getSettings().mediaUpload({
      allowedTypes,
      filesList: files,
      onFileChange: ([media]) =&gt; {
        selectMedia(media, closeMenu);
      },
      onError: onUploadError
    });
  };
  const openOnArrowDown = event =&gt; {
    if (event.keyCode === external_wp_keycodes_namespaceObject.DOWN) {
      event.preventDefault();
      event.target.click();
    }
  };
  const onlyAllowsImages = () =&gt; {
    if (!allowedTypes || allowedTypes.length === 0) {
      return false;
    }
    return allowedTypes.every(allowedType =&gt; allowedType === &#039;image&#039; || allowedType.startsWith(&#039;image/&#039;));
  };
  const gallery = multiple &amp;&amp; onlyAllowsImages();
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Dropdown, {
    popoverProps: popoverProps,
    contentClassName: &quot;block-editor-media-replace-flow__options&quot;,
    renderToggle: ({
      isOpen,
      onToggle
    }) =&gt; {
      if (renderToggle) {
        return renderToggle({
          &#039;aria-expanded&#039;: isOpen,
          &#039;aria-haspopup&#039;: &#039;true&#039;,
          onClick: onToggle,
          onKeyDown: openOnArrowDown,
          children: name
        });
      }
      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarButton, {
        &quot;aria-expanded&quot;: isOpen,
        &quot;aria-haspopup&quot;: &quot;true&quot;,
        onClick: onToggle,
        onKeyDown: openOnArrowDown,
        children: name
      });
    },
    renderContent: ({
      onClose
    }) =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.NavigableMenu, {
        className: &quot;block-editor-media-replace-flow__media-upload-menu&quot;,
        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(check, {
          children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(media_upload, {
            gallery: gallery,
            addToGallery: addToGallery,
            multiple: multiple,
            value: multiple ? mediaIds : mediaId,
            onSelect: media =&gt; selectMedia(media, onClose),
            allowedTypes: allowedTypes,
            render: ({
              open
            }) =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, {
              icon: library_media,
              onClick: open,
              children: (0,external_wp_i18n_namespaceObject.__)(&#039;Open Media Library&#039;)
            })
          }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FormFileUpload, {
            onChange: event =&gt; {
              uploadFiles(event, onClose);
            },
            accept: accept,
            multiple: !!multiple,
            render: ({
              openFileDialog
            }) =&gt; {
              return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, {
                icon: library_upload,
                onClick: () =&gt; {
                  openFileDialog();
                },
                children: (0,external_wp_i18n_namespaceObject._x)(&#039;Upload&#039;, &#039;verb&#039;)
              });
            }
          })]
        }), onToggleFeaturedImage &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, {
          icon: post_featured_image,
          onClick: onToggleFeaturedImage,
          isPressed: useFeaturedImage,
          children: (0,external_wp_i18n_namespaceObject.__)(&#039;Use featured image&#039;)
        }), mediaURL &amp;&amp; onReset &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, {
          onClick: () =&gt; {
            onReset();
            onClose();
          },
          children: (0,external_wp_i18n_namespaceObject.__)(&#039;Reset&#039;)
        }), typeof children === &#039;function&#039; ? children({
          onClose
        }) : children]
      }), onSelectURL &amp;&amp;
      /*#__PURE__*/
      // eslint-disable-next-line jsx-a11y/no-noninteractive-element-interactions
      (0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;form&quot;, {
        className: &quot;block-editor-media-flow__url-input&quot;,
        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;span&quot;, {
          className: &quot;block-editor-media-replace-flow__image-url-label&quot;,
          children: (0,external_wp_i18n_namespaceObject.__)(&#039;Current media URL:&#039;)
        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(link_control, {
          value: {
            url: mediaURL
          },
          settings: [],
          showSuggestions: false,
          onChange: ({
            url
          }) =&gt; {
            onSelectURL(url);
          }
        })]
      })]
    })
  });
};

/**
 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/media-replace-flow/README.md
 */
/* harmony default export */ const media_replace_flow = ((0,external_wp_compose_namespaceObject.compose)([(0,external_wp_data_namespaceObject.withDispatch)(dispatch =&gt; {
  const {
    createNotice,
    removeNotice
  } = dispatch(external_wp_notices_namespaceObject.store);
  return {
    createNotice,
    removeNotice
  };
}), (0,external_wp_components_namespaceObject.withFilters)(&#039;editor.MediaReplaceFlow&#039;)])(MediaReplaceFlow));

;// ./node_modules/@wordpress/block-editor/build-module/components/background-image-control/index.js
/**
 * External dependencies
 */


/**
 * WordPress dependencies
 */









/**
 * Internal dependencies
 */







const IMAGE_BACKGROUND_TYPE = &#039;image&#039;;
const BACKGROUND_POPOVER_PROPS = {
  placement: &#039;left-start&#039;,
  offset: 36,
  shift: true,
  className: &#039;block-editor-global-styles-background-panel__popover&#039;
};
const background_image_control_noop = () =&gt; {};

/**
 * Get the help text for the background size control.
 *
 * @param {string} value backgroundSize value.
 * @return {string}      Translated help text.
 */
function backgroundSizeHelpText(value) {
  if (value === &#039;cover&#039; || value === undefined) {
    return (0,external_wp_i18n_namespaceObject.__)(&#039;Image covers the space evenly.&#039;);
  }
  if (value === &#039;contain&#039;) {
    return (0,external_wp_i18n_namespaceObject.__)(&#039;Image is contained without distortion.&#039;);
  }
  return (0,external_wp_i18n_namespaceObject.__)(&#039;Image has a fixed width.&#039;);
}

/**
 * Converts decimal x and y coords from FocalPointPicker to percentage-based values
 * to use as backgroundPosition value.
 *
 * @param {{x?:number, y?:number}} value FocalPointPicker coords.
 * @return {string}      				 backgroundPosition value.
 */
const coordsToBackgroundPosition = value =&gt; {
  if (!value || isNaN(value.x) &amp;&amp; isNaN(value.y)) {
    return undefined;
  }
  const x = isNaN(value.x) ? 0.5 : value.x;
  const y = isNaN(value.y) ? 0.5 : value.y;
  return `${x * 100}% ${y * 100}%`;
};

/**
 * Converts backgroundPosition value to x and y coords for FocalPointPicker.
 *
 * @param {string} value backgroundPosition value.
 * @return {{x?:number, y?:number}}       FocalPointPicker coords.
 */
const backgroundPositionToCoords = value =&gt; {
  if (!value) {
    return {
      x: undefined,
      y: undefined
    };
  }
  let [x, y] = value.split(&#039; &#039;).map(v =&gt; parseFloat(v) / 100);
  x = isNaN(x) ? undefined : x;
  y = isNaN(y) ? x : y;
  return {
    x,
    y
  };
};
function InspectorImagePreviewItem({
  as = &#039;span&#039;,
  imgUrl,
  toggleProps = {},
  filename,
  label,
  className,
  onToggleCallback = background_image_control_noop
}) {
  (0,external_wp_element_namespaceObject.useEffect)(() =&gt; {
    if (typeof toggleProps?.isOpen !== &#039;undefined&#039;) {
      onToggleCallback(toggleProps?.isOpen);
    }
  }, [toggleProps?.isOpen, onToggleCallback]);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalItemGroup, {
    as: as,
    className: className,
    ...toggleProps,
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalHStack, {
      justify: &quot;flex-start&quot;,
      as: &quot;span&quot;,
      className: &quot;block-editor-global-styles-background-panel__inspector-preview-inner&quot;,
      children: [imgUrl &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;span&quot;, {
        className: &quot;block-editor-global-styles-background-panel__inspector-image-indicator-wrapper&quot;,
        &quot;aria-hidden&quot;: true,
        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;span&quot;, {
          className: &quot;block-editor-global-styles-background-panel__inspector-image-indicator&quot;,
          style: {
            backgroundImage: `url(${imgUrl})`
          }
        })
      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.FlexItem, {
        as: &quot;span&quot;,
        style: imgUrl ? {} : {
          flexGrow: 1
        },
        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalTruncate, {
          numberOfLines: 1,
          className: &quot;block-editor-global-styles-background-panel__inspector-media-replace-title&quot;,
          children: label
        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.VisuallyHidden, {
          as: &quot;span&quot;,
          children: imgUrl ? (0,external_wp_i18n_namespaceObject.sprintf)(/* translators: %s: file name */
          (0,external_wp_i18n_namespaceObject.__)(&#039;Background image: %s&#039;), filename || label) : (0,external_wp_i18n_namespaceObject.__)(&#039;No background image selected&#039;)
        })]
      })]
    })
  });
}
function BackgroundControlsPanel({
  label,
  filename,
  url: imgUrl,
  children,
  onToggle: onToggleCallback = background_image_control_noop,
  hasImageValue
}) {
  if (!hasImageValue) {
    return;
  }
  const imgLabel = label || (0,external_wp_url_namespaceObject.getFilename)(imgUrl) || (0,external_wp_i18n_namespaceObject.__)(&#039;Add background image&#039;);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Dropdown, {
    popoverProps: BACKGROUND_POPOVER_PROPS,
    renderToggle: ({
      onToggle,
      isOpen
    }) =&gt; {
      const toggleProps = {
        onClick: onToggle,
        className: &#039;block-editor-global-styles-background-panel__dropdown-toggle&#039;,
        &#039;aria-expanded&#039;: isOpen,
        &#039;aria-label&#039;: (0,external_wp_i18n_namespaceObject.__)(&#039;Background size, position and repeat options.&#039;),
        isOpen
      };
      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(InspectorImagePreviewItem, {
        imgUrl: imgUrl,
        filename: filename,
        label: imgLabel,
        toggleProps: toggleProps,
        as: &quot;button&quot;,
        onToggleCallback: onToggleCallback
      });
    },
    renderContent: () =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalDropdownContentWrapper, {
      className: &quot;block-editor-global-styles-background-panel__dropdown-content-wrapper&quot;,
      paddingSize: &quot;medium&quot;,
      children: children
    })
  });
}
function LoadingSpinner() {
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Placeholder, {
    className: &quot;block-editor-global-styles-background-panel__loading&quot;,
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Spinner, {})
  });
}
function BackgroundImageControls({
  onChange,
  style,
  inheritedValue,
  onRemoveImage = background_image_control_noop,
  onResetImage = background_image_control_noop,
  displayInPanel,
  defaultValues
}) {
  const [isUploading, setIsUploading] = (0,external_wp_element_namespaceObject.useState)(false);
  const {
    getSettings
  } = (0,external_wp_data_namespaceObject.useSelect)(store);
  const {
    id,
    title,
    url
  } = style?.background?.backgroundImage || {
    ...inheritedValue?.background?.backgroundImage
  };
  const replaceContainerRef = (0,external_wp_element_namespaceObject.useRef)();
  const {
    createErrorNotice
  } = (0,external_wp_data_namespaceObject.useDispatch)(external_wp_notices_namespaceObject.store);
  const onUploadError = message =&gt; {
    createErrorNotice(message, {
      type: &#039;snackbar&#039;
    });
    setIsUploading(false);
  };
  const resetBackgroundImage = () =&gt; onChange(setImmutably(style, [&#039;background&#039;, &#039;backgroundImage&#039;], undefined));
  const onSelectMedia = media =&gt; {
    if (!media || !media.url) {
      resetBackgroundImage();
      setIsUploading(false);
      return;
    }
    if ((0,external_wp_blob_namespaceObject.isBlobURL)(media.url)) {
      setIsUploading(true);
      return;
    }

    // For media selections originated from a file upload.
    if (media.media_type &amp;&amp; media.media_type !== IMAGE_BACKGROUND_TYPE || !media.media_type &amp;&amp; media.type &amp;&amp; media.type !== IMAGE_BACKGROUND_TYPE) {
      onUploadError((0,external_wp_i18n_namespaceObject.__)(&#039;Only images can be used as a background image.&#039;));
      return;
    }
    const sizeValue = style?.background?.backgroundSize || defaultValues?.backgroundSize;
    const positionValue = style?.background?.backgroundPosition;
    onChange(setImmutably(style, [&#039;background&#039;], {
      ...style?.background,
      backgroundImage: {
        url: media.url,
        id: media.id,
        source: &#039;file&#039;,
        title: media.title || undefined
      },
      backgroundPosition:
      /*
       * A background image uploaded and set in the editor receives a default background position of &#039;50% 0&#039;,
       * when the background image size is the equivalent of &quot;Tile&quot;.
       * This is to increase the chance that the image&#039;s focus point is visible.
       * This is in-editor only to assist with the user experience.
       */
      !positionValue &amp;&amp; (&#039;auto&#039; === sizeValue || !sizeValue) ? &#039;50% 0&#039; : positionValue,
      backgroundSize: sizeValue
    }));
    setIsUploading(false);
  };

  // Drag and drop callback, restricting image to one.
  const onFilesDrop = filesList =&gt; {
    getSettings().mediaUpload({
      allowedTypes: [IMAGE_BACKGROUND_TYPE],
      filesList,
      onFileChange([image]) {
        onSelectMedia(image);
      },
      onError: onUploadError,
      multiple: false
    });
  };
  const hasValue = hasBackgroundImageValue(style);
  const closeAndFocus = () =&gt; {
    const [toggleButton] = external_wp_dom_namespaceObject.focus.tabbable.find(replaceContainerRef.current);
    // Focus the toggle button and close the dropdown menu.
    // This ensures similar behaviour as to selecting an image, where the dropdown is
    // closed and focus is redirected to the dropdown toggle button.
    toggleButton?.focus();
    toggleButton?.click();
  };
  const onRemove = () =&gt; onChange(setImmutably(style, [&#039;background&#039;], {
    backgroundImage: &#039;none&#039;
  }));
  const canRemove = !hasValue &amp;&amp; hasBackgroundImageValue(inheritedValue);
  const imgLabel = title || (0,external_wp_url_namespaceObject.getFilename)(url) || (0,external_wp_i18n_namespaceObject.__)(&#039;Add background image&#039;);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;div&quot;, {
    ref: replaceContainerRef,
    className: &quot;block-editor-global-styles-background-panel__image-tools-panel-item&quot;,
    children: [isUploading &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(LoadingSpinner, {}), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(media_replace_flow, {
      mediaId: id,
      mediaURL: url,
      allowedTypes: [IMAGE_BACKGROUND_TYPE],
      accept: &quot;image/*&quot;,
      onSelect: onSelectMedia,
      popoverProps: {
        className: dist_clsx({
          &#039;block-editor-global-styles-background-panel__media-replace-popover&#039;: displayInPanel
        })
      },
      name: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(InspectorImagePreviewItem, {
        className: &quot;block-editor-global-styles-background-panel__image-preview&quot;,
        imgUrl: url,
        filename: title,
        label: imgLabel
      }),
      renderToggle: props =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
        ...props,
        __next40pxDefaultSize: true
      }),
      onError: onUploadError,
      onReset: () =&gt; {
        closeAndFocus();
        onResetImage();
      },
      children: canRemove &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, {
        onClick: () =&gt; {
          closeAndFocus();
          onRemove();
          onRemoveImage();
        },
        children: (0,external_wp_i18n_namespaceObject.__)(&#039;Remove&#039;)
      })
    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.DropZone, {
      onFilesDrop: onFilesDrop,
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Drop to upload&#039;)
    })]
  });
}
function BackgroundSizeControls({
  onChange,
  style,
  inheritedValue,
  defaultValues
}) {
  const sizeValue = style?.background?.backgroundSize || inheritedValue?.background?.backgroundSize;
  const repeatValue = style?.background?.backgroundRepeat || inheritedValue?.background?.backgroundRepeat;
  const imageValue = style?.background?.backgroundImage?.url || inheritedValue?.background?.backgroundImage?.url;
  const isUploadedImage = style?.background?.backgroundImage?.id;
  const positionValue = style?.background?.backgroundPosition || inheritedValue?.background?.backgroundPosition;
  const attachmentValue = style?.background?.backgroundAttachment || inheritedValue?.background?.backgroundAttachment;

  /*
   * Set default values for uploaded images.
   * The default values are passed by the consumer.
   * Block-level controls may have different defaults to root-level controls.
   * A falsy value is treated by default as `auto` (Tile).
   */
  let currentValueForToggle = !sizeValue &amp;&amp; isUploadedImage ? defaultValues?.backgroundSize : sizeValue || &#039;auto&#039;;
  /*
   * The incoming value could be a value + unit, e.g. &#039;20px&#039;.
   * In this case set the value to &#039;tile&#039;.
   */
  currentValueForToggle = ![&#039;cover&#039;, &#039;contain&#039;, &#039;auto&#039;].includes(currentValueForToggle) ? &#039;auto&#039; : currentValueForToggle;
  /*
   * If the current value is `cover` and the repeat value is `undefined`, then
   * the toggle should be unchecked as the default state. Otherwise, the toggle
   * should reflect the current repeat value.
   */
  const repeatCheckedValue = !(repeatValue === &#039;no-repeat&#039; || currentValueForToggle === &#039;cover&#039; &amp;&amp; repeatValue === undefined);
  const updateBackgroundSize = next =&gt; {
    // When switching to &#039;contain&#039; toggle the repeat off.
    let nextRepeat = repeatValue;
    let nextPosition = positionValue;
    if (next === &#039;contain&#039;) {
      nextRepeat = &#039;no-repeat&#039;;
      nextPosition = undefined;
    }
    if (next === &#039;cover&#039;) {
      nextRepeat = undefined;
      nextPosition = undefined;
    }
    if ((currentValueForToggle === &#039;cover&#039; || currentValueForToggle === &#039;contain&#039;) &amp;&amp; next === &#039;auto&#039;) {
      nextRepeat = undefined;
      /*
       * A background image uploaded and set in the editor (an image with a record id),
       * receives a default background position of &#039;50% 0&#039;,
       * when the toggle switches to &quot;Tile&quot;. This is to increase the chance that
       * the image&#039;s focus point is visible.
       * This is in-editor only to assist with the user experience.
       */
      if (!!style?.background?.backgroundImage?.id) {
        nextPosition = &#039;50% 0&#039;;
      }
    }

    /*
     * Next will be null when the input is cleared,
     * in which case the value should be &#039;auto&#039;.
     */
    if (!next &amp;&amp; currentValueForToggle === &#039;auto&#039;) {
      next = &#039;auto&#039;;
    }
    onChange(setImmutably(style, [&#039;background&#039;], {
      ...style?.background,
      backgroundPosition: nextPosition,
      backgroundRepeat: nextRepeat,
      backgroundSize: next
    }));
  };
  const updateBackgroundPosition = next =&gt; {
    onChange(setImmutably(style, [&#039;background&#039;, &#039;backgroundPosition&#039;], coordsToBackgroundPosition(next)));
  };
  const toggleIsRepeated = () =&gt; onChange(setImmutably(style, [&#039;background&#039;, &#039;backgroundRepeat&#039;], repeatCheckedValue === true ? &#039;no-repeat&#039; : &#039;repeat&#039;));
  const toggleScrollWithPage = () =&gt; onChange(setImmutably(style, [&#039;background&#039;, &#039;backgroundAttachment&#039;], attachmentValue === &#039;fixed&#039; ? &#039;scroll&#039; : &#039;fixed&#039;));

  // Set a default background position for non-site-wide, uploaded images with a size of &#039;contain&#039;.
  const backgroundPositionValue = !positionValue &amp;&amp; isUploadedImage &amp;&amp; &#039;contain&#039; === sizeValue ? defaultValues?.backgroundPosition : positionValue;
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalVStack, {
    spacing: 3,
    className: &quot;single-column&quot;,
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FocalPointPicker, {
      __nextHasNoMarginBottom: true,
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Focal point&#039;),
      url: imageValue,
      value: backgroundPositionToCoords(backgroundPositionValue),
      onChange: updateBackgroundPosition
    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToggleControl, {
      __nextHasNoMarginBottom: true,
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Fixed background&#039;),
      checked: attachmentValue === &#039;fixed&#039;,
      onChange: toggleScrollWithPage
    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalToggleGroupControl, {
      __nextHasNoMarginBottom: true,
      size: &quot;__unstable-large&quot;,
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Size&#039;),
      value: currentValueForToggle,
      onChange: updateBackgroundSize,
      isBlock: true,
      help: backgroundSizeHelpText(sizeValue || defaultValues?.backgroundSize),
      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControlOption, {
        value: &quot;cover&quot;,
        label: (0,external_wp_i18n_namespaceObject._x)(&#039;Cover&#039;, &#039;Size option for background image control&#039;)
      }, &quot;cover&quot;), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControlOption, {
        value: &quot;contain&quot;,
        label: (0,external_wp_i18n_namespaceObject._x)(&#039;Contain&#039;, &#039;Size option for background image control&#039;)
      }, &quot;contain&quot;), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControlOption, {
        value: &quot;auto&quot;,
        label: (0,external_wp_i18n_namespaceObject._x)(&#039;Tile&#039;, &#039;Size option for background image control&#039;)
      }, &quot;tile&quot;)]
    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalHStack, {
      justify: &quot;flex-start&quot;,
      spacing: 2,
      as: &quot;span&quot;,
      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalUnitControl, {
        &quot;aria-label&quot;: (0,external_wp_i18n_namespaceObject.__)(&#039;Background image width&#039;),
        onChange: updateBackgroundSize,
        value: sizeValue,
        size: &quot;__unstable-large&quot;,
        __unstableInputWidth: &quot;100px&quot;,
        min: 0,
        placeholder: (0,external_wp_i18n_namespaceObject.__)(&#039;Auto&#039;),
        disabled: currentValueForToggle !== &#039;auto&#039; || currentValueForToggle === undefined
      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToggleControl, {
        __nextHasNoMarginBottom: true,
        label: (0,external_wp_i18n_namespaceObject.__)(&#039;Repeat&#039;),
        checked: repeatCheckedValue,
        onChange: toggleIsRepeated,
        disabled: currentValueForToggle === &#039;cover&#039;
      })]
    })]
  });
}
function BackgroundImagePanel({
  value,
  onChange,
  inheritedValue = value,
  settings,
  defaultValues = {}
}) {
  /*
   * Resolve any inherited &quot;ref&quot; pointers.
   * Should the block editor need resolved, inherited values
   * across all controls, this could be abstracted into a hook,
   * e.g., useResolveGlobalStyle
   */
  const {
    globalStyles,
    _links
  } = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      getSettings
    } = select(store);
    const _settings = getSettings();
    return {
      globalStyles: _settings[globalStylesDataKey],
      _links: _settings[globalStylesLinksDataKey]
    };
  }, []);
  const resolvedInheritedValue = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; {
    const resolvedValues = {
      background: {}
    };
    if (!inheritedValue?.background) {
      return inheritedValue;
    }
    Object.entries(inheritedValue?.background).forEach(([key, backgroundValue]) =&gt; {
      resolvedValues.background[key] = getResolvedValue(backgroundValue, {
        styles: globalStyles,
        _links
      });
    });
    return resolvedValues;
  }, [globalStyles, _links, inheritedValue]);
  const resetBackground = () =&gt; onChange(setImmutably(value, [&#039;background&#039;], {}));
  const {
    title,
    url
  } = value?.background?.backgroundImage || {
    ...resolvedInheritedValue?.background?.backgroundImage
  };
  const hasImageValue = hasBackgroundImageValue(value) || hasBackgroundImageValue(resolvedInheritedValue);
  const imageValue = value?.background?.backgroundImage || inheritedValue?.background?.backgroundImage;
  const shouldShowBackgroundImageControls = hasImageValue &amp;&amp; &#039;none&#039; !== imageValue &amp;&amp; (settings?.background?.backgroundSize || settings?.background?.backgroundPosition || settings?.background?.backgroundRepeat);
  const [isDropDownOpen, setIsDropDownOpen] = (0,external_wp_element_namespaceObject.useState)(false);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
    className: dist_clsx(&#039;block-editor-global-styles-background-panel__inspector-media-replace-container&#039;, {
      &#039;is-open&#039;: isDropDownOpen
    }),
    children: shouldShowBackgroundImageControls ? /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BackgroundControlsPanel, {
      label: title,
      filename: title,
      url: url,
      onToggle: setIsDropDownOpen,
      hasImageValue: hasImageValue,
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalVStack, {
        spacing: 3,
        className: &quot;single-column&quot;,
        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BackgroundImageControls, {
          onChange: onChange,
          style: value,
          inheritedValue: resolvedInheritedValue,
          displayInPanel: true,
          onResetImage: () =&gt; {
            setIsDropDownOpen(false);
            resetBackground();
          },
          onRemoveImage: () =&gt; setIsDropDownOpen(false),
          defaultValues: defaultValues
        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BackgroundSizeControls, {
          onChange: onChange,
          style: value,
          defaultValues: defaultValues,
          inheritedValue: resolvedInheritedValue
        })]
      })
    }) : /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BackgroundImageControls, {
      onChange: onChange,
      style: value,
      inheritedValue: resolvedInheritedValue,
      defaultValues: defaultValues,
      onResetImage: () =&gt; {
        setIsDropDownOpen(false);
        resetBackground();
      },
      onRemoveImage: () =&gt; setIsDropDownOpen(false)
    })
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/global-styles/background-panel.js
/**
 * WordPress dependencies
 */


/**
 * Internal dependencies
 */





const background_panel_DEFAULT_CONTROLS = {
  backgroundImage: true
};

/**
 * Checks site settings to see if the background panel may be used.
 * `settings.background.backgroundSize` exists also,
 * but can only be used if settings?.background?.backgroundImage is `true`.
 *
 * @param {Object} settings Site settings
 * @return {boolean}        Whether site settings has activated background panel.
 */
function useHasBackgroundPanel(settings) {
  return external_wp_element_namespaceObject.Platform.OS === &#039;web&#039; &amp;&amp; settings?.background?.backgroundImage;
}

/**
 * Checks if there is a current value in the background size block support
 * attributes. Background size values include background size as well
 * as background position.
 *
 * @param {Object} style Style attribute.
 * @return {boolean}     Whether the block has a background size value set.
 */
function hasBackgroundSizeValue(style) {
  return style?.background?.backgroundPosition !== undefined || style?.background?.backgroundSize !== undefined;
}

/**
 * Checks if there is a current value in the background image block support
 * attributes.
 *
 * @param {Object} style Style attribute.
 * @return {boolean}     Whether the block has a background image value set.
 */
function hasBackgroundImageValue(style) {
  return !!style?.background?.backgroundImage?.id ||
  // Supports url() string values in theme.json.
  &#039;string&#039; === typeof style?.background?.backgroundImage || !!style?.background?.backgroundImage?.url;
}
function BackgroundToolsPanel({
  resetAllFilter,
  onChange,
  value,
  panelId,
  children,
  headerLabel
}) {
  const dropdownMenuProps = useToolsPanelDropdownMenuProps();
  const resetAll = () =&gt; {
    const updatedValue = resetAllFilter(value);
    onChange(updatedValue);
  };
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanel, {
    label: headerLabel,
    resetAll: resetAll,
    panelId: panelId,
    dropdownMenuProps: dropdownMenuProps,
    children: children
  });
}
function background_panel_BackgroundImagePanel({
  as: Wrapper = BackgroundToolsPanel,
  value,
  onChange,
  inheritedValue,
  settings,
  panelId,
  defaultControls = background_panel_DEFAULT_CONTROLS,
  defaultValues = {},
  headerLabel = (0,external_wp_i18n_namespaceObject.__)(&#039;Background image&#039;)
}) {
  const showBackgroundImageControl = useHasBackgroundPanel(settings);
  const resetBackground = () =&gt; onChange(setImmutably(value, [&#039;background&#039;], {}));
  const resetAllFilter = (0,external_wp_element_namespaceObject.useCallback)(previousValue =&gt; {
    return {
      ...previousValue,
      background: {}
    };
  }, []);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Wrapper, {
    resetAllFilter: resetAllFilter,
    value: value,
    onChange: onChange,
    panelId: panelId,
    headerLabel: headerLabel,
    children: showBackgroundImageControl &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanelItem, {
      hasValue: () =&gt; !!value?.background,
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Image&#039;),
      onDeselect: resetBackground,
      isShownByDefault: defaultControls.backgroundImage,
      panelId: panelId,
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BackgroundImagePanel, {
        value: value,
        onChange: onChange,
        settings: settings,
        inheritedValue: inheritedValue,
        defaultControls: defaultControls,
        defaultValues: defaultValues
      })
    })
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/hooks/background.js
/**
 * WordPress dependencies
 */




/**
 * Internal dependencies
 */






const BACKGROUND_SUPPORT_KEY = &#039;background&#039;;

// Initial control values.
const BACKGROUND_BLOCK_DEFAULT_VALUES = {
  backgroundSize: &#039;cover&#039;,
  backgroundPosition: &#039;50% 50%&#039; // used only when backgroundSize is &#039;contain&#039;.
};

/**
 * Determine whether there is block support for background.
 *
 * @param {string} blockName Block name.
 * @param {string} feature   Background image feature to check for.
 *
 * @return {boolean} Whether there is support.
 */
function hasBackgroundSupport(blockName, feature = &#039;any&#039;) {
  const support = (0,external_wp_blocks_namespaceObject.getBlockSupport)(blockName, BACKGROUND_SUPPORT_KEY);
  if (support === true) {
    return true;
  }
  if (feature === &#039;any&#039;) {
    return !!support?.backgroundImage || !!support?.backgroundSize || !!support?.backgroundRepeat;
  }
  return !!support?.[feature];
}
function setBackgroundStyleDefaults(backgroundStyle) {
  if (!backgroundStyle || !backgroundStyle?.backgroundImage?.url) {
    return;
  }
  let backgroundStylesWithDefaults;

  // Set block background defaults.
  if (!backgroundStyle?.backgroundSize) {
    backgroundStylesWithDefaults = {
      backgroundSize: BACKGROUND_BLOCK_DEFAULT_VALUES.backgroundSize
    };
  }
  if (&#039;contain&#039; === backgroundStyle?.backgroundSize &amp;&amp; !backgroundStyle?.backgroundPosition) {
    backgroundStylesWithDefaults = {
      backgroundPosition: BACKGROUND_BLOCK_DEFAULT_VALUES.backgroundPosition
    };
  }
  return backgroundStylesWithDefaults;
}
function background_useBlockProps({
  name,
  style
}) {
  if (!hasBackgroundSupport(name) || !style?.background?.backgroundImage) {
    return;
  }
  const backgroundStyles = setBackgroundStyleDefaults(style?.background);
  if (!backgroundStyles) {
    return;
  }
  return {
    style: {
      ...backgroundStyles
    }
  };
}

/**
 * Generates a CSS class name if an background image is set.
 *
 * @param {Object} style A block&#039;s style attribute.
 *
 * @return {string} CSS class name.
 */
function getBackgroundImageClasses(style) {
  return hasBackgroundImageValue(style) ? &#039;has-background&#039; : &#039;&#039;;
}
function BackgroundInspectorControl({
  children
}) {
  const resetAllFilter = (0,external_wp_element_namespaceObject.useCallback)(attributes =&gt; {
    return {
      ...attributes,
      style: {
        ...attributes.style,
        background: undefined
      }
    };
  }, []);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls, {
    group: &quot;background&quot;,
    resetAllFilter: resetAllFilter,
    children: children
  });
}
function background_BackgroundImagePanel({
  clientId,
  name,
  setAttributes,
  settings
}) {
  const {
    style,
    inheritedValue
  } = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      getBlockAttributes,
      getSettings
    } = select(store);
    const _settings = getSettings();
    return {
      style: getBlockAttributes(clientId)?.style,
      /*
       * To ensure we pass down the right inherited values:
       * @TODO 1. Pass inherited value down to all block style controls,
       *   See: packages/block-editor/src/hooks/style.js
       * @TODO 2. Add support for block style variations,
       *   See implementation: packages/block-editor/src/hooks/block-style-variation.js
       */
      inheritedValue: _settings[globalStylesDataKey]?.blocks?.[name]
    };
  }, [clientId, name]);
  if (!useHasBackgroundPanel(settings) || !hasBackgroundSupport(name, &#039;backgroundImage&#039;)) {
    return null;
  }
  const onChange = newStyle =&gt; {
    setAttributes({
      style: utils_cleanEmptyObject(newStyle)
    });
  };
  const updatedSettings = {
    ...settings,
    background: {
      ...settings.background,
      backgroundSize: settings?.background?.backgroundSize &amp;&amp; hasBackgroundSupport(name, &#039;backgroundSize&#039;)
    }
  };
  const defaultControls = (0,external_wp_blocks_namespaceObject.getBlockSupport)(name, [BACKGROUND_SUPPORT_KEY, &#039;defaultControls&#039;]);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(background_panel_BackgroundImagePanel, {
    inheritedValue: inheritedValue,
    as: BackgroundInspectorControl,
    panelId: clientId,
    defaultValues: BACKGROUND_BLOCK_DEFAULT_VALUES,
    settings: updatedSettings,
    onChange: onChange,
    defaultControls: defaultControls,
    value: style
  });
}
/* harmony default export */ const background = ({
  useBlockProps: background_useBlockProps,
  attributeKeys: [&#039;style&#039;],
  hasSupport: hasBackgroundSupport
});

;// ./node_modules/@wordpress/block-editor/build-module/hooks/lock.js
/**
 * WordPress dependencies
 */


/**
 * Filters registered block settings, extending attributes to include `lock`.
 *
 * @param {Object} settings Original block settings.
 *
 * @return {Object} Filtered block settings.
 */
function lock_addAttribute(settings) {
  var _settings$attributes$;
  // Allow blocks to specify their own attribute definition with default values if needed.
  if (&#039;type&#039; in ((_settings$attributes$ = settings.attributes?.lock) !== null &amp;&amp; _settings$attributes$ !== void 0 ? _settings$attributes$ : {})) {
    return settings;
  }
  // Gracefully handle if settings.attributes is undefined.
  settings.attributes = {
    ...settings.attributes,
    lock: {
      type: &#039;object&#039;
    }
  };
  return settings;
}
(0,external_wp_hooks_namespaceObject.addFilter)(&#039;blocks.registerBlockType&#039;, &#039;core/lock/addAttribute&#039;, lock_addAttribute);

;// ./node_modules/@wordpress/block-editor/build-module/hooks/anchor.js
/**
 * WordPress dependencies
 */






/**
 * Internal dependencies
 */



/**
 * Regular expression matching invalid anchor characters for replacement.
 *
 * @type {RegExp}
 */

const ANCHOR_REGEX = /[\s#]/g;
const ANCHOR_SCHEMA = {
  type: &#039;string&#039;,
  source: &#039;attribute&#039;,
  attribute: &#039;id&#039;,
  selector: &#039;*&#039;
};

/**
 * Filters registered block settings, extending attributes with anchor using ID
 * of the first node.
 *
 * @param {Object} settings Original block settings.
 *
 * @return {Object} Filtered block settings.
 */
function anchor_addAttribute(settings) {
  var _settings$attributes$;
  // Allow blocks to specify their own attribute definition with default values if needed.
  if (&#039;type&#039; in ((_settings$attributes$ = settings.attributes?.anchor) !== null &amp;&amp; _settings$attributes$ !== void 0 ? _settings$attributes$ : {})) {
    return settings;
  }
  if ((0,external_wp_blocks_namespaceObject.hasBlockSupport)(settings, &#039;anchor&#039;)) {
    // Gracefully handle if settings.attributes is undefined.
    settings.attributes = {
      ...settings.attributes,
      anchor: ANCHOR_SCHEMA
    };
  }
  return settings;
}
function BlockEditAnchorControlPure({
  anchor,
  setAttributes
}) {
  const blockEditingMode = useBlockEditingMode();
  if (blockEditingMode !== &#039;default&#039;) {
    return null;
  }
  const isWeb = external_wp_element_namespaceObject.Platform.OS === &#039;web&#039;;
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls, {
    group: &quot;advanced&quot;,
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.TextControl, {
      __nextHasNoMarginBottom: true,
      __next40pxDefaultSize: true,
      className: &quot;html-anchor-control&quot;,
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;HTML anchor&#039;),
      help: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
        children: [(0,external_wp_i18n_namespaceObject.__)(&#039;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.&#039;), isWeb &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
          children: [&#039; &#039;, /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ExternalLink, {
            href: (0,external_wp_i18n_namespaceObject.__)(&#039;https://wordpress.org/documentation/article/page-jumps/&#039;),
            children: (0,external_wp_i18n_namespaceObject.__)(&#039;Learn more about anchors&#039;)
          })]
        })]
      }),
      value: anchor || &#039;&#039;,
      placeholder: !isWeb ? (0,external_wp_i18n_namespaceObject.__)(&#039;Add an anchor&#039;) : null,
      onChange: nextValue =&gt; {
        nextValue = nextValue.replace(ANCHOR_REGEX, &#039;-&#039;);
        setAttributes({
          anchor: nextValue
        });
      },
      autoCapitalize: &quot;none&quot;,
      autoComplete: &quot;off&quot;
    })
  });
}
/* harmony default export */ const hooks_anchor = ({
  addSaveProps,
  edit: BlockEditAnchorControlPure,
  attributeKeys: [&#039;anchor&#039;],
  hasSupport(name) {
    return (0,external_wp_blocks_namespaceObject.hasBlockSupport)(name, &#039;anchor&#039;);
  }
});

/**
 * Override props assigned to save component to inject anchor ID, if block
 * supports anchor. This is only applied if the block&#039;s save result is an
 * element and not a markup string.
 *
 * @param {Object} extraProps Additional props applied to save element.
 * @param {Object} blockType  Block type.
 * @param {Object} attributes Current block attributes.
 *
 * @return {Object} Filtered props applied to save element.
 */
function addSaveProps(extraProps, blockType, attributes) {
  if ((0,external_wp_blocks_namespaceObject.hasBlockSupport)(blockType, &#039;anchor&#039;)) {
    extraProps.id = attributes.anchor === &#039;&#039; ? null : attributes.anchor;
  }
  return extraProps;
}
(0,external_wp_hooks_namespaceObject.addFilter)(&#039;blocks.registerBlockType&#039;, &#039;core/anchor/attribute&#039;, anchor_addAttribute);

;// ./node_modules/@wordpress/block-editor/build-module/hooks/aria-label.js
/**
 * WordPress dependencies
 */



/**
 * Filters registered block settings, extending attributes with ariaLabel using aria-label
 * of the first node.
 *
 * @param {Object} settings Original block settings.
 *
 * @return {Object} Filtered block settings.
 */
function aria_label_addAttribute(settings) {
  // Allow blocks to specify their own attribute definition with default values if needed.
  if (settings?.attributes?.ariaLabel?.type) {
    return settings;
  }
  if ((0,external_wp_blocks_namespaceObject.hasBlockSupport)(settings, &#039;ariaLabel&#039;)) {
    // Gracefully handle if settings.attributes is undefined.
    settings.attributes = {
      ...settings.attributes,
      ariaLabel: {
        type: &#039;string&#039;
      }
    };
  }
  return settings;
}

/**
 * Override props assigned to save component to inject aria-label, if block
 * supports ariaLabel. This is only applied if the block&#039;s save result is an
 * element and not a markup string.
 *
 * @param {Object} extraProps Additional props applied to save element.
 * @param {Object} blockType  Block type.
 * @param {Object} attributes Current block attributes.
 *
 * @return {Object} Filtered props applied to save element.
 */
function aria_label_addSaveProps(extraProps, blockType, attributes) {
  if ((0,external_wp_blocks_namespaceObject.hasBlockSupport)(blockType, &#039;ariaLabel&#039;)) {
    extraProps[&#039;aria-label&#039;] = attributes.ariaLabel === &#039;&#039; ? null : attributes.ariaLabel;
  }
  return extraProps;
}
/* harmony default export */ const aria_label = ({
  addSaveProps: aria_label_addSaveProps,
  attributeKeys: [&#039;ariaLabel&#039;],
  hasSupport(name) {
    return (0,external_wp_blocks_namespaceObject.hasBlockSupport)(name, &#039;ariaLabel&#039;);
  }
});
(0,external_wp_hooks_namespaceObject.addFilter)(&#039;blocks.registerBlockType&#039;, &#039;core/ariaLabel/attribute&#039;, aria_label_addAttribute);

;// ./node_modules/@wordpress/block-editor/build-module/hooks/custom-class-name.js
/**
 * External dependencies
 */


/**
 * WordPress dependencies
 */





/**
 * Internal dependencies
 */



/**
 * Filters registered block settings, extending attributes to include `className`.
 *
 * @param {Object} settings Original block settings.
 *
 * @return {Object} Filtered block settings.
 */

function custom_class_name_addAttribute(settings) {
  if ((0,external_wp_blocks_namespaceObject.hasBlockSupport)(settings, &#039;customClassName&#039;, true)) {
    // Gracefully handle if settings.attributes is undefined.
    settings.attributes = {
      ...settings.attributes,
      className: {
        type: &#039;string&#039;
      }
    };
  }
  return settings;
}
function CustomClassNameControlsPure({
  className,
  setAttributes
}) {
  const blockEditingMode = useBlockEditingMode();
  if (blockEditingMode !== &#039;default&#039;) {
    return null;
  }
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls, {
    group: &quot;advanced&quot;,
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.TextControl, {
      __nextHasNoMarginBottom: true,
      __next40pxDefaultSize: true,
      autoComplete: &quot;off&quot;,
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Additional CSS class(es)&#039;),
      value: className || &#039;&#039;,
      onChange: nextValue =&gt; {
        setAttributes({
          className: nextValue !== &#039;&#039; ? nextValue : undefined
        });
      },
      help: (0,external_wp_i18n_namespaceObject.__)(&#039;Separate multiple classes with spaces.&#039;)
    })
  });
}
/* harmony default export */ const custom_class_name = ({
  edit: CustomClassNameControlsPure,
  addSaveProps: custom_class_name_addSaveProps,
  attributeKeys: [&#039;className&#039;],
  hasSupport(name) {
    return (0,external_wp_blocks_namespaceObject.hasBlockSupport)(name, &#039;customClassName&#039;, true);
  }
});

/**
 * Override props assigned to save component to inject the className, if block
 * supports customClassName. This is only applied if the block&#039;s save result is an
 * element and not a markup string.
 *
 * @param {Object} extraProps Additional props applied to save element.
 * @param {Object} blockType  Block type.
 * @param {Object} attributes Current block attributes.
 *
 * @return {Object} Filtered props applied to save element.
 */
function custom_class_name_addSaveProps(extraProps, blockType, attributes) {
  if ((0,external_wp_blocks_namespaceObject.hasBlockSupport)(blockType, &#039;customClassName&#039;, true) &amp;&amp; attributes.className) {
    extraProps.className = dist_clsx(extraProps.className, attributes.className);
  }
  return extraProps;
}
function addTransforms(result, source, index, results) {
  if (!(0,external_wp_blocks_namespaceObject.hasBlockSupport)(result.name, &#039;customClassName&#039;, true)) {
    return result;
  }

  // If the condition verifies we are probably in the presence of a wrapping transform
  // e.g: nesting paragraphs in a group or columns and in that case the class should not be kept.
  if (results.length === 1 &amp;&amp; result.innerBlocks.length === source.length) {
    return result;
  }

  // If we are transforming one block to multiple blocks or multiple blocks to one block,
  // we ignore the class during the transform.
  if (results.length === 1 &amp;&amp; source.length &gt; 1 || results.length &gt; 1 &amp;&amp; source.length === 1) {
    return result;
  }

  // If we are in presence of transform between one or more block in the source
  // that have one or more blocks in the result
  // we apply the class on source N to the result N,
  // if source N does not exists we do nothing.
  if (source[index]) {
    const originClassName = source[index]?.attributes.className;
    // Avoid overriding classes if the transformed block already includes them.
    if (originClassName &amp;&amp; result.attributes.className === undefined) {
      return {
        ...result,
        attributes: {
          ...result.attributes,
          className: originClassName
        }
      };
    }
  }
  return result;
}
(0,external_wp_hooks_namespaceObject.addFilter)(&#039;blocks.registerBlockType&#039;, &#039;core/editor/custom-class-name/attribute&#039;, custom_class_name_addAttribute);
(0,external_wp_hooks_namespaceObject.addFilter)(&#039;blocks.switchToBlockType.transformedBlock&#039;, &#039;core/color/addTransforms&#039;, addTransforms);

;// ./node_modules/@wordpress/block-editor/build-module/hooks/generated-class-name.js
/**
 * WordPress dependencies
 */



/**
 * Override props assigned to save component to inject generated className if
 * block supports it. This is only applied if the block&#039;s save result is an
 * element and not a markup string.
 *
 * @param {Object} extraProps Additional props applied to save element.
 * @param {Object} blockType  Block type.
 *
 * @return {Object} Filtered props applied to save element.
 */
function addGeneratedClassName(extraProps, blockType) {
  // Adding the generated className.
  if ((0,external_wp_blocks_namespaceObject.hasBlockSupport)(blockType, &#039;className&#039;, true)) {
    if (typeof extraProps.className === &#039;string&#039;) {
      // We have some extra classes and want to add the default classname
      // We use uniq to prevent duplicate classnames.

      extraProps.className = [...new Set([(0,external_wp_blocks_namespaceObject.getBlockDefaultClassName)(blockType.name), ...extraProps.className.split(&#039; &#039;)])].join(&#039; &#039;).trim();
    } else {
      // There is no string in the className variable,
      // so we just dump the default name in there.
      extraProps.className = (0,external_wp_blocks_namespaceObject.getBlockDefaultClassName)(blockType.name);
    }
  }
  return extraProps;
}
(0,external_wp_hooks_namespaceObject.addFilter)(&#039;blocks.getSaveContent.extraProps&#039;, &#039;core/generated-class-name/save-props&#039;, addGeneratedClassName);

;// ./node_modules/colord/index.mjs
var colord_r={grad:.9,turn:360,rad:360/(2*Math.PI)},t=function(r){return&quot;string&quot;==typeof r?r.length&gt;0:&quot;number&quot;==typeof r},n=function(r,t,n){return void 0===t&amp;&amp;(t=0),void 0===n&amp;&amp;(n=Math.pow(10,t)),Math.round(n*r)/n+0},e=function(r,t,n){return void 0===t&amp;&amp;(t=0),void 0===n&amp;&amp;(n=1),r&gt;n?n:r&gt;t?r:t},u=function(r){return(r=isFinite(r)?r%360:0)&gt;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&lt;2?&quot;0&quot;+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&lt;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)&lt;50?e:100-e)/100)&gt;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)&gt;0&amp;&amp;u&lt;200?n*e/100/(u&lt;=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&lt;=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},&quot;hex&quot;],[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},&quot;rgb&quot;],[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&amp;&amp;(u=&quot;deg&quot;),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)},&quot;hsl&quot;]],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)&amp;&amp;t(e)&amp;&amp;t(u)?a({r:Number(n),g:Number(e),b:Number(u),a:Number(i)}):null},&quot;rgb&quot;],[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)},&quot;hsl&quot;],[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)},&quot;hsv&quot;]]},N=function(r,t){for(var n=0;n&lt;t.length;n++){var e=t[n][0](r);if(e)return[e,t[n][1]]}return[null,void 0]},x=function(r){return&quot;string&quot;==typeof r?N(r.trim(),y.string):&quot;object&quot;==typeof r&amp;&amp;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)&lt;.5},r.prototype.isLight=function(){return H(this.rgba)&gt;=.5},r.prototype.toHex=function(){return r=o(this.rgba),t=r.r,e=r.g,u=r.b,i=(a=r.a)&lt;1?s(n(255*a)):&quot;&quot;,&quot;#&quot;+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)&lt;1?&quot;rgba(&quot;+t+&quot;, &quot;+n+&quot;, &quot;+e+&quot;, &quot;+u+&quot;)&quot;:&quot;rgb(&quot;+t+&quot;, &quot;+n+&quot;, &quot;+e+&quot;)&quot;;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)&lt;1?&quot;hsla(&quot;+t+&quot;, &quot;+n+&quot;%, &quot;+e+&quot;%, &quot;+u+&quot;)&quot;:&quot;hsl(&quot;+t+&quot;, &quot;+n+&quot;%, &quot;+e+&quot;%)&quot;;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&amp;&amp;(r=.1),w(M(this.rgba,r))},r.prototype.desaturate=function(r){return void 0===r&amp;&amp;(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&amp;&amp;(r=.1),w($(this.rgba,r))},r.prototype.darken=function(r){return void 0===r&amp;&amp;(r=.1),w($(this.rgba,-r))},r.prototype.rotate=function(r){return void 0===r&amp;&amp;(r=15),this.hue(this.hue()+r)},r.prototype.alpha=function(r){return&quot;number&quot;==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&quot;number&quot;==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)&lt;0&amp;&amp;(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()})};

;// ./node_modules/colord/plugins/names.mjs
/* harmony default export */ function names(e,f){var a={white:&quot;#ffffff&quot;,bisque:&quot;#ffe4c4&quot;,blue:&quot;#0000ff&quot;,cadetblue:&quot;#5f9ea0&quot;,chartreuse:&quot;#7fff00&quot;,chocolate:&quot;#d2691e&quot;,coral:&quot;#ff7f50&quot;,antiquewhite:&quot;#faebd7&quot;,aqua:&quot;#00ffff&quot;,azure:&quot;#f0ffff&quot;,whitesmoke:&quot;#f5f5f5&quot;,papayawhip:&quot;#ffefd5&quot;,plum:&quot;#dda0dd&quot;,blanchedalmond:&quot;#ffebcd&quot;,black:&quot;#000000&quot;,gold:&quot;#ffd700&quot;,goldenrod:&quot;#daa520&quot;,gainsboro:&quot;#dcdcdc&quot;,cornsilk:&quot;#fff8dc&quot;,cornflowerblue:&quot;#6495ed&quot;,burlywood:&quot;#deb887&quot;,aquamarine:&quot;#7fffd4&quot;,beige:&quot;#f5f5dc&quot;,crimson:&quot;#dc143c&quot;,cyan:&quot;#00ffff&quot;,darkblue:&quot;#00008b&quot;,darkcyan:&quot;#008b8b&quot;,darkgoldenrod:&quot;#b8860b&quot;,darkkhaki:&quot;#bdb76b&quot;,darkgray:&quot;#a9a9a9&quot;,darkgreen:&quot;#006400&quot;,darkgrey:&quot;#a9a9a9&quot;,peachpuff:&quot;#ffdab9&quot;,darkmagenta:&quot;#8b008b&quot;,darkred:&quot;#8b0000&quot;,darkorchid:&quot;#9932cc&quot;,darkorange:&quot;#ff8c00&quot;,darkslateblue:&quot;#483d8b&quot;,gray:&quot;#808080&quot;,darkslategray:&quot;#2f4f4f&quot;,darkslategrey:&quot;#2f4f4f&quot;,deeppink:&quot;#ff1493&quot;,deepskyblue:&quot;#00bfff&quot;,wheat:&quot;#f5deb3&quot;,firebrick:&quot;#b22222&quot;,floralwhite:&quot;#fffaf0&quot;,ghostwhite:&quot;#f8f8ff&quot;,darkviolet:&quot;#9400d3&quot;,magenta:&quot;#ff00ff&quot;,green:&quot;#008000&quot;,dodgerblue:&quot;#1e90ff&quot;,grey:&quot;#808080&quot;,honeydew:&quot;#f0fff0&quot;,hotpink:&quot;#ff69b4&quot;,blueviolet:&quot;#8a2be2&quot;,forestgreen:&quot;#228b22&quot;,lawngreen:&quot;#7cfc00&quot;,indianred:&quot;#cd5c5c&quot;,indigo:&quot;#4b0082&quot;,fuchsia:&quot;#ff00ff&quot;,brown:&quot;#a52a2a&quot;,maroon:&quot;#800000&quot;,mediumblue:&quot;#0000cd&quot;,lightcoral:&quot;#f08080&quot;,darkturquoise:&quot;#00ced1&quot;,lightcyan:&quot;#e0ffff&quot;,ivory:&quot;#fffff0&quot;,lightyellow:&quot;#ffffe0&quot;,lightsalmon:&quot;#ffa07a&quot;,lightseagreen:&quot;#20b2aa&quot;,linen:&quot;#faf0e6&quot;,mediumaquamarine:&quot;#66cdaa&quot;,lemonchiffon:&quot;#fffacd&quot;,lime:&quot;#00ff00&quot;,khaki:&quot;#f0e68c&quot;,mediumseagreen:&quot;#3cb371&quot;,limegreen:&quot;#32cd32&quot;,mediumspringgreen:&quot;#00fa9a&quot;,lightskyblue:&quot;#87cefa&quot;,lightblue:&quot;#add8e6&quot;,midnightblue:&quot;#191970&quot;,lightpink:&quot;#ffb6c1&quot;,mistyrose:&quot;#ffe4e1&quot;,moccasin:&quot;#ffe4b5&quot;,mintcream:&quot;#f5fffa&quot;,lightslategray:&quot;#778899&quot;,lightslategrey:&quot;#778899&quot;,navajowhite:&quot;#ffdead&quot;,navy:&quot;#000080&quot;,mediumvioletred:&quot;#c71585&quot;,powderblue:&quot;#b0e0e6&quot;,palegoldenrod:&quot;#eee8aa&quot;,oldlace:&quot;#fdf5e6&quot;,paleturquoise:&quot;#afeeee&quot;,mediumturquoise:&quot;#48d1cc&quot;,mediumorchid:&quot;#ba55d3&quot;,rebeccapurple:&quot;#663399&quot;,lightsteelblue:&quot;#b0c4de&quot;,mediumslateblue:&quot;#7b68ee&quot;,thistle:&quot;#d8bfd8&quot;,tan:&quot;#d2b48c&quot;,orchid:&quot;#da70d6&quot;,mediumpurple:&quot;#9370db&quot;,purple:&quot;#800080&quot;,pink:&quot;#ffc0cb&quot;,skyblue:&quot;#87ceeb&quot;,springgreen:&quot;#00ff7f&quot;,palegreen:&quot;#98fb98&quot;,red:&quot;#ff0000&quot;,yellow:&quot;#ffff00&quot;,slateblue:&quot;#6a5acd&quot;,lavenderblush:&quot;#fff0f5&quot;,peru:&quot;#cd853f&quot;,palevioletred:&quot;#db7093&quot;,violet:&quot;#ee82ee&quot;,teal:&quot;#008080&quot;,slategray:&quot;#708090&quot;,slategrey:&quot;#708090&quot;,aliceblue:&quot;#f0f8ff&quot;,darkseagreen:&quot;#8fbc8f&quot;,darkolivegreen:&quot;#556b2f&quot;,greenyellow:&quot;#adff2f&quot;,seagreen:&quot;#2e8b57&quot;,seashell:&quot;#fff5ee&quot;,tomato:&quot;#ff6347&quot;,silver:&quot;#c0c0c0&quot;,sienna:&quot;#a0522d&quot;,lavender:&quot;#e6e6fa&quot;,lightgreen:&quot;#90ee90&quot;,orange:&quot;#ffa500&quot;,orangered:&quot;#ff4500&quot;,steelblue:&quot;#4682b4&quot;,royalblue:&quot;#4169e1&quot;,turquoise:&quot;#40e0d0&quot;,yellowgreen:&quot;#9acd32&quot;,salmon:&quot;#fa8072&quot;,saddlebrown:&quot;#8b4513&quot;,sandybrown:&quot;#f4a460&quot;,rosybrown:&quot;#bc8f8f&quot;,darksalmon:&quot;#e9967a&quot;,lightgoldenrodyellow:&quot;#fafad2&quot;,snow:&quot;#fffafa&quot;,lightgrey:&quot;#d3d3d3&quot;,lightgray:&quot;#d3d3d3&quot;,dimgray:&quot;#696969&quot;,dimgrey:&quot;#696969&quot;,olivedrab:&quot;#6b8e23&quot;,olive:&quot;#808000&quot;},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&quot;transparent&quot;;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=&quot;black&quot;;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&lt;t&amp;&amp;(t=u,b=g)}return b}};f.string.push([function(f){var r=f.toLowerCase(),d=&quot;transparent&quot;===r?&quot;#0000&quot;:a[r];return d?new e(d).toRgb():null},&quot;name&quot;])}

;// ./node_modules/colord/plugins/a11y.mjs
var a11y_o=function(o){var t=o/255;return t&lt;.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)&amp;&amp;(r=0),void 0===n&amp;&amp;(n=Math.pow(10,r)),Math.round(n*o)/n+0;var o,r,n},o.prototype.contrast=function(r){void 0===r&amp;&amp;(r=&quot;#FFF&quot;);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&gt;d?(u+.05)/(d+.05):(d+.05)/(u+.05),void 0===(a=2)&amp;&amp;(a=0),void 0===i&amp;&amp;(i=Math.pow(10,a)),Math.floor(i*n)/i+0},o.prototype.isReadable=function(o,t){return void 0===o&amp;&amp;(o=&quot;#FFF&quot;),void 0===t&amp;&amp;(t={}),this.contrast(o)&gt;=(e=void 0===(i=(r=t).size)?&quot;normal&quot;:i,&quot;AAA&quot;===(a=void 0===(n=r.level)?&quot;AA&quot;:n)&amp;&amp;&quot;normal&quot;===e?7:&quot;AA&quot;===a&amp;&amp;&quot;large&quot;===e?3:4.5);var r,n,a,i,e}}

;// ./node_modules/@wordpress/block-editor/build-module/components/colors/utils.js
/**
 * External dependencies
 */




/**
 * WordPress dependencies
 */


/**
 * Internal dependencies
 */

k([names, a11y]);
const {
  kebabCase
} = unlock(external_wp_components_namespaceObject.privateApis);

/**
 * Provided an array of color objects as set by the theme or by the editor defaults,
 * and the values of the defined color or custom color returns a color object describing the color.
 *
 * @param {Array}   colors       Array of color objects as set by the theme or by the editor defaults.
 * @param {?string} definedColor A string containing the color slug.
 * @param {?string} customColor  A string containing the customColor value.
 *
 * @return {?Object} If definedColor is passed and the name is found in colors,
 *                   the color object exactly as set by the theme or editor defaults is returned.
 *                   Otherwise, an object that just sets the color is defined.
 */
const getColorObjectByAttributeValues = (colors, definedColor, customColor) =&gt; {
  if (definedColor) {
    const colorObj = colors?.find(color =&gt; color.slug === definedColor);
    if (colorObj) {
      return colorObj;
    }
  }
  return {
    color: customColor
  };
};

/**
 * 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.
 *
 * @param {Array}   colors     Array of color objects as set by the theme or by the editor defaults.
 * @param {?string} colorValue A string containing the color value.
 *
 * @return {?Object} Color object included in the colors array whose color property equals colorValue.
 *                   Returns undefined if no color object matches this requirement.
 */
const getColorObjectByColorValue = (colors, colorValue) =&gt; {
  return colors?.find(color =&gt; color.color === colorValue);
};

/**
 * Returns a class based on the context a color is being used and its slug.
 *
 * @param {string} colorContextName Context/place where color is being used e.g: background, text etc...
 * @param {string} colorSlug        Slug of the color.
 *
 * @return {?string} String with the class corresponding to the color in the provided context.
 *                   Returns undefined if either colorContextName or colorSlug are not provided.
 */
function getColorClassName(colorContextName, colorSlug) {
  if (!colorContextName || !colorSlug) {
    return undefined;
  }
  return `has-${kebabCase(colorSlug)}-${colorContextName}`;
}

/**
 * Given an array of color objects and a color value returns the color value of the most readable color in the array.
 *
 * @param {Array}   colors     Array of color objects as set by the theme or by the editor defaults.
 * @param {?string} colorValue A string containing the color value.
 *
 * @return {string} String with the color value of the most readable color.
 */
function getMostReadableColor(colors, colorValue) {
  const colordColor = w(colorValue);
  const getColorContrast = ({
    color
  }) =&gt; colordColor.contrast(color);
  const maxContrast = Math.max(...colors.map(getColorContrast));
  return colors.find(color =&gt; getColorContrast(color) === maxContrast).color;
}

;// ./node_modules/@wordpress/block-editor/build-module/components/colors-gradients/use-multiple-origin-colors-and-gradients.js
/**
 * WordPress dependencies
 */



/**
 * Internal dependencies
 */


/**
 * Retrieves color and gradient related settings.
 *
 * The arrays for colors and gradients are made up of color palettes from each
 * origin i.e. &quot;Core&quot;, &quot;Theme&quot;, and &quot;User&quot;.
 *
 * @return {Object} Color and gradient related settings.
 */
function useMultipleOriginColorsAndGradients() {
  const [enableCustomColors, customColors, themeColors, defaultColors, shouldDisplayDefaultColors, enableCustomGradients, customGradients, themeGradients, defaultGradients, shouldDisplayDefaultGradients] = use_settings_useSettings(&#039;color.custom&#039;, &#039;color.palette.custom&#039;, &#039;color.palette.theme&#039;, &#039;color.palette.default&#039;, &#039;color.defaultPalette&#039;, &#039;color.customGradient&#039;, &#039;color.gradients.custom&#039;, &#039;color.gradients.theme&#039;, &#039;color.gradients.default&#039;, &#039;color.defaultGradients&#039;);
  const colorGradientSettings = {
    disableCustomColors: !enableCustomColors,
    disableCustomGradients: !enableCustomGradients
  };
  colorGradientSettings.colors = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; {
    const result = [];
    if (themeColors &amp;&amp; themeColors.length) {
      result.push({
        name: (0,external_wp_i18n_namespaceObject._x)(&#039;Theme&#039;, &#039;Indicates this palette comes from the theme.&#039;),
        slug: &#039;theme&#039;,
        colors: themeColors
      });
    }
    if (shouldDisplayDefaultColors &amp;&amp; defaultColors &amp;&amp; defaultColors.length) {
      result.push({
        name: (0,external_wp_i18n_namespaceObject._x)(&#039;Default&#039;, &#039;Indicates this palette comes from WordPress.&#039;),
        slug: &#039;default&#039;,
        colors: defaultColors
      });
    }
    if (customColors &amp;&amp; customColors.length) {
      result.push({
        name: (0,external_wp_i18n_namespaceObject._x)(&#039;Custom&#039;, &#039;Indicates this palette is created by the user.&#039;),
        slug: &#039;custom&#039;,
        colors: customColors
      });
    }
    return result;
  }, [customColors, themeColors, defaultColors, shouldDisplayDefaultColors]);
  colorGradientSettings.gradients = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; {
    const result = [];
    if (themeGradients &amp;&amp; themeGradients.length) {
      result.push({
        name: (0,external_wp_i18n_namespaceObject._x)(&#039;Theme&#039;, &#039;Indicates this palette comes from the theme.&#039;),
        slug: &#039;theme&#039;,
        gradients: themeGradients
      });
    }
    if (shouldDisplayDefaultGradients &amp;&amp; defaultGradients &amp;&amp; defaultGradients.length) {
      result.push({
        name: (0,external_wp_i18n_namespaceObject._x)(&#039;Default&#039;, &#039;Indicates this palette comes from WordPress.&#039;),
        slug: &#039;default&#039;,
        gradients: defaultGradients
      });
    }
    if (customGradients &amp;&amp; customGradients.length) {
      result.push({
        name: (0,external_wp_i18n_namespaceObject._x)(&#039;Custom&#039;, &#039;Indicates this palette is created by the user.&#039;),
        slug: &#039;custom&#039;,
        gradients: customGradients
      });
    }
    return result;
  }, [customGradients, themeGradients, defaultGradients, shouldDisplayDefaultGradients]);
  colorGradientSettings.hasColorsOrGradients = !!colorGradientSettings.colors.length || !!colorGradientSettings.gradients.length;
  return colorGradientSettings;
}

;// ./node_modules/@wordpress/block-editor/build-module/components/border-radius-control/utils.js
/**
 * WordPress dependencies
 */


/**
 * Gets the (non-undefined) item with the highest occurrence within an array
 * Based in part on: https://stackoverflow.com/a/20762713
 *
 * Undefined values are always sorted to the end by `sort`, so this function
 * returns the first element, to always prioritize real values over undefined
 * values.
 *
 * See: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort#description
 *
 * @param {Array&lt;any&gt;} inputArray Array of items to check.
 * @return {any}                  The item with the most occurrences.
 */
function mode(inputArray) {
  const arr = [...inputArray];
  return arr.sort((a, b) =&gt; inputArray.filter(v =&gt; v === b).length - inputArray.filter(v =&gt; v === a).length).shift();
}

/**
 * Returns the most common CSS unit from the current CSS unit selections.
 *
 * - If a single flat border radius is set, its unit will be used
 * - If individual corner selections, the most common of those will be used
 * - Failing any unit selections a default of &#039;px&#039; is returned.
 *
 * @param {Object} selectedUnits Unit selections for flat radius &amp; each corner.
 * @return {string} Most common CSS unit from current selections. Default: `px`.
 */
function getAllUnit(selectedUnits = {}) {
  const {
    flat,
    ...cornerUnits
  } = selectedUnits;
  return flat || mode(Object.values(cornerUnits).filter(Boolean)) || &#039;px&#039;;
}

/**
 * Gets the &#039;all&#039; input value and unit from values data.
 *
 * @param {Object|string} values Radius values.
 * @return {string}              A value + unit for the &#039;all&#039; input.
 */
function getAllValue(values = {}) {
  /**
   * Border radius support was originally a single pixel value.
   *
   * To maintain backwards compatibility treat this case as the all value.
   */
  if (typeof values === &#039;string&#039;) {
    return values;
  }
  const parsedQuantitiesAndUnits = Object.values(values).map(value =&gt; (0,external_wp_components_namespaceObject.__experimentalParseQuantityAndUnitFromRawValue)(value));
  const allValues = parsedQuantitiesAndUnits.map(value =&gt; {
    var _value$;
    return (_value$ = value[0]) !== null &amp;&amp; _value$ !== void 0 ? _value$ : &#039;&#039;;
  });
  const allUnits = parsedQuantitiesAndUnits.map(value =&gt; value[1]);
  const value = allValues.every(v =&gt; v === allValues[0]) ? allValues[0] : &#039;&#039;;
  const unit = mode(allUnits);
  const allValue = value === 0 || value ? `${value}${unit}` : undefined;
  return allValue;
}

/**
 * Checks to determine if values are mixed.
 *
 * @param {Object} values Radius values.
 * @return {boolean}      Whether values are mixed.
 */
function hasMixedValues(values = {}) {
  const allValue = getAllValue(values);
  const isMixed = typeof values === &#039;string&#039; ? false : isNaN(parseFloat(allValue));
  return isMixed;
}

/**
 * Checks to determine if values are defined.
 *
 * @param {Object} values Radius values.
 * @return {boolean}      Whether values are mixed.
 */
function hasDefinedValues(values) {
  if (!values) {
    return false;
  }

  // A string value represents a shorthand value.
  if (typeof values === &#039;string&#039;) {
    return true;
  }

  // An object represents longhand border radius values, if any are set
  // flag values as being defined.
  const filteredValues = Object.values(values).filter(value =&gt; {
    return !!value || value === 0;
  });
  return !!filteredValues.length;
}

;// ./node_modules/@wordpress/block-editor/build-module/components/border-radius-control/all-input-control.js
/**
 * WordPress dependencies
 */



/**
 * Internal dependencies
 */


function AllInputControl({
  onChange,
  selectedUnits,
  setSelectedUnits,
  values,
  ...props
}) {
  let allValue = getAllValue(values);
  if (allValue === undefined) {
    // If we don&#039;t have any value set the unit to any current selection
    // or the most common unit from the individual radii values.
    allValue = getAllUnit(selectedUnits);
  }
  const hasValues = hasDefinedValues(values);
  const isMixed = hasValues &amp;&amp; hasMixedValues(values);
  const allPlaceholder = isMixed ? (0,external_wp_i18n_namespaceObject.__)(&#039;Mixed&#039;) : null;

  // Filter out CSS-unit-only values to prevent invalid styles.
  const handleOnChange = next =&gt; {
    const isNumeric = !isNaN(parseFloat(next));
    const nextValue = isNumeric ? next : undefined;
    onChange(nextValue);
  };

  // Store current unit selection for use as fallback for individual
  // radii controls.
  const handleOnUnitChange = unit =&gt; {
    setSelectedUnits({
      topLeft: unit,
      topRight: unit,
      bottomLeft: unit,
      bottomRight: unit
    });
  };
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalUnitControl, {
    ...props,
    &quot;aria-label&quot;: (0,external_wp_i18n_namespaceObject.__)(&#039;Border radius&#039;),
    disableUnits: isMixed,
    isOnly: true,
    value: allValue,
    onChange: handleOnChange,
    onUnitChange: handleOnUnitChange,
    placeholder: allPlaceholder,
    size: &quot;__unstable-large&quot;
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/border-radius-control/input-controls.js
/**
 * WordPress dependencies
 */



const CORNERS = {
  topLeft: (0,external_wp_i18n_namespaceObject.__)(&#039;Top left&#039;),
  topRight: (0,external_wp_i18n_namespaceObject.__)(&#039;Top right&#039;),
  bottomLeft: (0,external_wp_i18n_namespaceObject.__)(&#039;Bottom left&#039;),
  bottomRight: (0,external_wp_i18n_namespaceObject.__)(&#039;Bottom right&#039;)
};
function BoxInputControls({
  onChange,
  selectedUnits,
  setSelectedUnits,
  values: valuesProp,
  ...props
}) {
  const createHandleOnChange = corner =&gt; next =&gt; {
    if (!onChange) {
      return;
    }

    // Filter out CSS-unit-only values to prevent invalid styles.
    const isNumeric = !isNaN(parseFloat(next));
    const nextValue = isNumeric ? next : undefined;
    onChange({
      ...values,
      [corner]: nextValue
    });
  };
  const createHandleOnUnitChange = side =&gt; next =&gt; {
    const newUnits = {
      ...selectedUnits
    };
    newUnits[side] = next;
    setSelectedUnits(newUnits);
  };

  // For shorthand style &amp; backwards compatibility, handle flat string value.
  const values = typeof valuesProp !== &#039;string&#039; ? valuesProp : {
    topLeft: valuesProp,
    topRight: valuesProp,
    bottomLeft: valuesProp,
    bottomRight: valuesProp
  };

  // Controls are wrapped in tooltips as visible labels aren&#039;t desired here.
  // Tooltip rendering also requires the UnitControl to be wrapped. See:
  // https://github.com/WordPress/gutenberg/pull/24966#issuecomment-685875026
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
    className: &quot;components-border-radius-control__input-controls-wrapper&quot;,
    children: Object.entries(CORNERS).map(([corner, label]) =&gt; {
      const [parsedQuantity, parsedUnit] = (0,external_wp_components_namespaceObject.__experimentalParseQuantityAndUnitFromRawValue)(values[corner]);
      const computedUnit = values[corner] ? parsedUnit : selectedUnits[corner] || selectedUnits.flat;
      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Tooltip, {
        text: label,
        placement: &quot;top&quot;,
        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
          className: &quot;components-border-radius-control__tooltip-wrapper&quot;,
          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalUnitControl, {
            ...props,
            &quot;aria-label&quot;: label,
            value: [parsedQuantity, computedUnit].join(&#039;&#039;),
            onChange: createHandleOnChange(corner),
            onUnitChange: createHandleOnUnitChange(corner),
            size: &quot;__unstable-large&quot;
          })
        })
      }, corner);
    })
  });
}

;// ./node_modules/@wordpress/icons/build-module/library/link.js
/**
 * WordPress dependencies
 */


const link_link = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;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&quot;
  })
});
/* harmony default export */ const library_link = (link_link);

;// ./node_modules/@wordpress/block-editor/build-module/components/border-radius-control/linked-button.js
/**
 * WordPress dependencies
 */




function LinkedButton({
  isLinked,
  ...props
}) {
  const label = isLinked ? (0,external_wp_i18n_namespaceObject.__)(&#039;Unlink radii&#039;) : (0,external_wp_i18n_namespaceObject.__)(&#039;Link radii&#039;);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
    ...props,
    className: &quot;component-border-radius-control__linked-button&quot;,
    size: &quot;small&quot;,
    icon: isLinked ? library_link : link_off,
    iconSize: 24,
    label: label
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/border-radius-control/index.js
/**
 * WordPress dependencies
 */




/**
 * Internal dependencies
 */






const border_radius_control_DEFAULT_VALUES = {
  topLeft: undefined,
  topRight: undefined,
  bottomLeft: undefined,
  bottomRight: undefined
};
const MIN_BORDER_RADIUS_VALUE = 0;
const MAX_BORDER_RADIUS_VALUES = {
  px: 100,
  em: 20,
  rem: 20
};

/**
 * Control to display border radius options.
 *
 * @param {Object}   props          Component props.
 * @param {Function} props.onChange Callback to handle onChange.
 * @param {Object}   props.values   Border radius values.
 *
 * @return {Element}              Custom border radius control.
 */
function BorderRadiusControl({
  onChange,
  values
}) {
  const [isLinked, setIsLinked] = (0,external_wp_element_namespaceObject.useState)(!hasDefinedValues(values) || !hasMixedValues(values));

  // Tracking selected units via internal state allows filtering of CSS unit
  // only values from being saved while maintaining preexisting unit selection
  // behaviour. Filtering CSS unit only values prevents invalid style values.
  const [selectedUnits, setSelectedUnits] = (0,external_wp_element_namespaceObject.useState)({
    flat: typeof values === &#039;string&#039; ? (0,external_wp_components_namespaceObject.__experimentalParseQuantityAndUnitFromRawValue)(values)[1] : undefined,
    topLeft: (0,external_wp_components_namespaceObject.__experimentalParseQuantityAndUnitFromRawValue)(values?.topLeft)[1],
    topRight: (0,external_wp_components_namespaceObject.__experimentalParseQuantityAndUnitFromRawValue)(values?.topRight)[1],
    bottomLeft: (0,external_wp_components_namespaceObject.__experimentalParseQuantityAndUnitFromRawValue)(values?.bottomLeft)[1],
    bottomRight: (0,external_wp_components_namespaceObject.__experimentalParseQuantityAndUnitFromRawValue)(values?.bottomRight)[1]
  });
  const [availableUnits] = use_settings_useSettings(&#039;spacing.units&#039;);
  const units = (0,external_wp_components_namespaceObject.__experimentalUseCustomUnits)({
    availableUnits: availableUnits || [&#039;px&#039;, &#039;em&#039;, &#039;rem&#039;]
  });
  const unit = getAllUnit(selectedUnits);
  const unitConfig = units &amp;&amp; units.find(item =&gt; item.value === unit);
  const step = unitConfig?.step || 1;
  const [allValue] = (0,external_wp_components_namespaceObject.__experimentalParseQuantityAndUnitFromRawValue)(getAllValue(values));
  const toggleLinked = () =&gt; setIsLinked(!isLinked);
  const handleSliderChange = next =&gt; {
    onChange(next !== undefined ? `${next}${unit}` : undefined);
  };
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;fieldset&quot;, {
    className: &quot;components-border-radius-control&quot;,
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.BaseControl.VisualLabel, {
      as: &quot;legend&quot;,
      children: (0,external_wp_i18n_namespaceObject.__)(&#039;Radius&#039;)
    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;div&quot;, {
      className: &quot;components-border-radius-control__wrapper&quot;,
      children: [isLinked ? /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(AllInputControl, {
          className: &quot;components-border-radius-control__unit-control&quot;,
          values: values,
          min: MIN_BORDER_RADIUS_VALUE,
          onChange: onChange,
          selectedUnits: selectedUnits,
          setSelectedUnits: setSelectedUnits,
          units: units
        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.RangeControl, {
          __next40pxDefaultSize: true,
          label: (0,external_wp_i18n_namespaceObject.__)(&#039;Border radius&#039;),
          hideLabelFromVision: true,
          className: &quot;components-border-radius-control__range-control&quot;,
          value: allValue !== null &amp;&amp; allValue !== void 0 ? allValue : &#039;&#039;,
          min: MIN_BORDER_RADIUS_VALUE,
          max: MAX_BORDER_RADIUS_VALUES[unit],
          initialPosition: 0,
          withInputField: false,
          onChange: handleSliderChange,
          step: step,
          __nextHasNoMarginBottom: true
        })]
      }) : /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BoxInputControls, {
        min: MIN_BORDER_RADIUS_VALUE,
        onChange: onChange,
        selectedUnits: selectedUnits,
        setSelectedUnits: setSelectedUnits,
        values: values || border_radius_control_DEFAULT_VALUES,
        units: units
      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(LinkedButton, {
        onClick: toggleLinked,
        isLinked: isLinked
      })]
    })]
  });
}

;// ./node_modules/@wordpress/icons/build-module/library/check.js
/**
 * WordPress dependencies
 */


const check_check = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;M16.7 7.1l-6.3 8.5-3.3-2.5-.9 1.2 4.5 3.4L17.9 8z&quot;
  })
});
/* harmony default export */ const library_check = (check_check);

;// ./node_modules/@wordpress/icons/build-module/library/shadow.js
/**
 * WordPress dependencies
 */


const shadow = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  viewBox: &quot;0 0 24 24&quot;,
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;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&quot;
  })
});
/* harmony default export */ const library_shadow = (shadow);

;// ./node_modules/@wordpress/icons/build-module/library/reset.js
/**
 * WordPress dependencies
 */


const reset_reset = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;M7 11.5h10V13H7z&quot;
  })
});
/* harmony default export */ const library_reset = (reset_reset);

;// ./node_modules/@wordpress/block-editor/build-module/components/global-styles/shadow-panel-components.js
/**
 * WordPress dependencies
 */





/**
 * External dependencies
 */


/**
 * Shared reference to an empty array for cases where it is important to avoid
 * returning a new array reference on every invocation.
 *
 * @type {Array}
 */

const shadow_panel_components_EMPTY_ARRAY = [];
function ShadowPopoverContainer({
  shadow,
  onShadowChange,
  settings
}) {
  const shadows = useShadowPresets(settings);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
    className: &quot;block-editor-global-styles__shadow-popover-container&quot;,
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalVStack, {
      spacing: 4,
      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalHeading, {
        level: 5,
        children: (0,external_wp_i18n_namespaceObject.__)(&#039;Drop shadow&#039;)
      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ShadowPresets, {
        presets: shadows,
        activeShadow: shadow,
        onSelect: onShadowChange
      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
        className: &quot;block-editor-global-styles__clear-shadow&quot;,
        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
          __next40pxDefaultSize: true,
          variant: &quot;tertiary&quot;,
          onClick: () =&gt; onShadowChange(undefined),
          disabled: !shadow,
          accessibleWhenDisabled: true,
          children: (0,external_wp_i18n_namespaceObject.__)(&#039;Clear&#039;)
        })
      })]
    })
  });
}
function ShadowPresets({
  presets,
  activeShadow,
  onSelect
}) {
  return !presets ? null : /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Composite, {
    role: &quot;listbox&quot;,
    className: &quot;block-editor-global-styles__shadow__list&quot;,
    &quot;aria-label&quot;: (0,external_wp_i18n_namespaceObject.__)(&#039;Drop shadows&#039;),
    children: presets.map(({
      name,
      slug,
      shadow
    }) =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ShadowIndicator, {
      label: name,
      isActive: shadow === activeShadow,
      type: slug === &#039;unset&#039; ? &#039;unset&#039; : &#039;preset&#039;,
      onSelect: () =&gt; onSelect(shadow === activeShadow ? undefined : shadow),
      shadow: shadow
    }, slug))
  });
}
function ShadowIndicator({
  type,
  label,
  isActive,
  onSelect,
  shadow
}) {
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Tooltip, {
    text: label,
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Composite.Item, {
      role: &quot;option&quot;,
      &quot;aria-label&quot;: label,
      &quot;aria-selected&quot;: isActive,
      className: dist_clsx(&#039;block-editor-global-styles__shadow__item&#039;, {
        &#039;is-active&#039;: isActive
      }),
      render: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;button&quot;, {
        className: dist_clsx(&#039;block-editor-global-styles__shadow-indicator&#039;, {
          unset: type === &#039;unset&#039;
        }),
        onClick: onSelect,
        style: {
          boxShadow: shadow
        },
        &quot;aria-label&quot;: label,
        children: isActive &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(build_module_icon, {
          icon: library_check
        })
      })
    })
  });
}
function ShadowPopover({
  shadow,
  onShadowChange,
  settings
}) {
  const popoverProps = {
    placement: &#039;left-start&#039;,
    offset: 36,
    shift: true
  };
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Dropdown, {
    popoverProps: popoverProps,
    className: &quot;block-editor-global-styles__shadow-dropdown&quot;,
    renderToggle: renderShadowToggle(shadow, onShadowChange),
    renderContent: () =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalDropdownContentWrapper, {
      paddingSize: &quot;medium&quot;,
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ShadowPopoverContainer, {
        shadow: shadow,
        onShadowChange: onShadowChange,
        settings: settings
      })
    })
  });
}
function renderShadowToggle(shadow, onShadowChange) {
  return ({
    onToggle,
    isOpen
  }) =&gt; {
    const shadowButtonRef = (0,external_wp_element_namespaceObject.useRef)(undefined);
    const toggleProps = {
      onClick: onToggle,
      className: dist_clsx({
        &#039;is-open&#039;: isOpen
      }),
      &#039;aria-expanded&#039;: isOpen,
      ref: shadowButtonRef
    };
    const removeButtonProps = {
      onClick: () =&gt; {
        if (isOpen) {
          onToggle();
        }
        onShadowChange(undefined);
        // Return focus to parent button.
        shadowButtonRef.current?.focus();
      },
      className: dist_clsx(&#039;block-editor-global-styles__shadow-editor__remove-button&#039;, {
        &#039;is-open&#039;: isOpen
      }),
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Remove&#039;)
    };
    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
        __next40pxDefaultSize: true,
        ...toggleProps,
        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalHStack, {
          justify: &quot;flex-start&quot;,
          children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(build_module_icon, {
            className: &quot;block-editor-global-styles__toggle-icon&quot;,
            icon: library_shadow,
            size: 24
          }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FlexItem, {
            children: (0,external_wp_i18n_namespaceObject.__)(&#039;Drop shadow&#039;)
          })]
        })
      }), !!shadow &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
        __next40pxDefaultSize: true,
        size: &quot;small&quot;,
        icon: library_reset,
        ...removeButtonProps
      })]
    });
  };
}
function useShadowPresets(settings) {
  return (0,external_wp_element_namespaceObject.useMemo)(() =&gt; {
    var _settings$shadow$pres;
    if (!settings?.shadow) {
      return shadow_panel_components_EMPTY_ARRAY;
    }
    const defaultPresetsEnabled = settings?.shadow?.defaultPresets;
    const {
      default: defaultShadows,
      theme: themeShadows,
      custom: customShadows
    } = (_settings$shadow$pres = settings?.shadow?.presets) !== null &amp;&amp; _settings$shadow$pres !== void 0 ? _settings$shadow$pres : {};
    const unsetShadow = {
      name: (0,external_wp_i18n_namespaceObject.__)(&#039;Unset&#039;),
      slug: &#039;unset&#039;,
      shadow: &#039;none&#039;
    };
    const shadowPresets = [...(defaultPresetsEnabled &amp;&amp; defaultShadows || shadow_panel_components_EMPTY_ARRAY), ...(themeShadows || shadow_panel_components_EMPTY_ARRAY), ...(customShadows || shadow_panel_components_EMPTY_ARRAY)];
    if (shadowPresets.length) {
      shadowPresets.unshift(unsetShadow);
    }
    return shadowPresets;
  }, [settings]);
}

;// ./node_modules/@wordpress/block-editor/build-module/components/global-styles/border-panel.js
/**
 * WordPress dependencies
 */




/**
 * Internal dependencies
 */







function useHasBorderPanel(settings) {
  const controls = Object.values(useHasBorderPanelControls(settings));
  return controls.some(Boolean);
}
function useHasBorderPanelControls(settings) {
  const controls = {
    hasBorderColor: useHasBorderColorControl(settings),
    hasBorderRadius: useHasBorderRadiusControl(settings),
    hasBorderStyle: useHasBorderStyleControl(settings),
    hasBorderWidth: useHasBorderWidthControl(settings),
    hasShadow: useHasShadowControl(settings)
  };
  return controls;
}
function useHasBorderColorControl(settings) {
  return settings?.border?.color;
}
function useHasBorderRadiusControl(settings) {
  return settings?.border?.radius;
}
function useHasBorderStyleControl(settings) {
  return settings?.border?.style;
}
function useHasBorderWidthControl(settings) {
  return settings?.border?.width;
}
function useHasShadowControl(settings) {
  const shadows = useShadowPresets(settings);
  return !!settings?.shadow &amp;&amp; shadows.length &gt; 0;
}
function BorderToolsPanel({
  resetAllFilter,
  onChange,
  value,
  panelId,
  children,
  label
}) {
  const dropdownMenuProps = useToolsPanelDropdownMenuProps();
  const resetAll = () =&gt; {
    const updatedValue = resetAllFilter(value);
    onChange(updatedValue);
  };
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanel, {
    label: label,
    resetAll: resetAll,
    panelId: panelId,
    dropdownMenuProps: dropdownMenuProps,
    children: children
  });
}
const border_panel_DEFAULT_CONTROLS = {
  radius: true,
  color: true,
  width: true,
  shadow: true
};
function BorderPanel({
  as: Wrapper = BorderToolsPanel,
  value,
  onChange,
  inheritedValue = value,
  settings,
  panelId,
  name,
  defaultControls = border_panel_DEFAULT_CONTROLS
}) {
  var _settings$shadow$pres, _ref, _ref2, _shadowPresets$custom;
  const colors = useColorsPerOrigin(settings);
  const decodeValue = (0,external_wp_element_namespaceObject.useCallback)(rawValue =&gt; getValueFromVariable({
    settings
  }, &#039;&#039;, rawValue), [settings]);
  const encodeColorValue = colorValue =&gt; {
    const allColors = colors.flatMap(({
      colors: originColors
    }) =&gt; originColors);
    const colorObject = allColors.find(({
      color
    }) =&gt; color === colorValue);
    return colorObject ? &#039;var:preset|color|&#039; + colorObject.slug : colorValue;
  };
  const border = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; {
    if ((0,external_wp_components_namespaceObject.__experimentalHasSplitBorders)(inheritedValue?.border)) {
      const borderValue = {
        ...inheritedValue?.border
      };
      [&#039;top&#039;, &#039;right&#039;, &#039;bottom&#039;, &#039;left&#039;].forEach(side =&gt; {
        borderValue[side] = {
          ...borderValue[side],
          color: decodeValue(borderValue[side]?.color)
        };
      });
      return borderValue;
    }
    return {
      ...inheritedValue?.border,
      color: inheritedValue?.border?.color ? decodeValue(inheritedValue?.border?.color) : undefined
    };
  }, [inheritedValue?.border, decodeValue]);
  const setBorder = newBorder =&gt; onChange({
    ...value,
    border: newBorder
  });
  const showBorderColor = useHasBorderColorControl(settings);
  const showBorderStyle = useHasBorderStyleControl(settings);
  const showBorderWidth = useHasBorderWidthControl(settings);

  // Border radius.
  const showBorderRadius = useHasBorderRadiusControl(settings);
  const borderRadiusValues = decodeValue(border?.radius);
  const setBorderRadius = newBorderRadius =&gt; setBorder({
    ...border,
    radius: newBorderRadius
  });
  const hasBorderRadius = () =&gt; {
    const borderValues = value?.border?.radius;
    if (typeof borderValues === &#039;object&#039;) {
      return Object.entries(borderValues).some(Boolean);
    }
    return !!borderValues;
  };
  const hasShadowControl = useHasShadowControl(settings);

  // Shadow
  const shadow = decodeValue(inheritedValue?.shadow);
  const shadowPresets = (_settings$shadow$pres = settings?.shadow?.presets) !== null &amp;&amp; _settings$shadow$pres !== void 0 ? _settings$shadow$pres : {};
  const mergedShadowPresets = (_ref = (_ref2 = (_shadowPresets$custom = shadowPresets.custom) !== null &amp;&amp; _shadowPresets$custom !== void 0 ? _shadowPresets$custom : shadowPresets.theme) !== null &amp;&amp; _ref2 !== void 0 ? _ref2 : shadowPresets.default) !== null &amp;&amp; _ref !== void 0 ? _ref : [];
  const setShadow = newValue =&gt; {
    const slug = mergedShadowPresets?.find(({
      shadow: shadowName
    }) =&gt; shadowName === newValue)?.slug;
    onChange(setImmutably(value, [&#039;shadow&#039;], slug ? `var:preset|shadow|${slug}` : newValue || undefined));
  };
  const hasShadow = () =&gt; !!value?.shadow;
  const resetShadow = () =&gt; setShadow(undefined);
  const resetBorder = () =&gt; {
    if (hasBorderRadius()) {
      return setBorder({
        radius: value?.border?.radius
      });
    }
    setBorder(undefined);
  };
  const onBorderChange = newBorder =&gt; {
    // Ensure we have a visible border style when a border width or
    // color is being selected.
    const updatedBorder = {
      ...newBorder
    };
    if ((0,external_wp_components_namespaceObject.__experimentalHasSplitBorders)(updatedBorder)) {
      [&#039;top&#039;, &#039;right&#039;, &#039;bottom&#039;, &#039;left&#039;].forEach(side =&gt; {
        if (updatedBorder[side]) {
          updatedBorder[side] = {
            ...updatedBorder[side],
            color: encodeColorValue(updatedBorder[side]?.color)
          };
        }
      });
    } else if (updatedBorder) {
      updatedBorder.color = encodeColorValue(updatedBorder.color);
    }

    // As radius is maintained separately to color, style, and width
    // maintain its value. Undefined values here will be cleaned when
    // global styles are saved.
    setBorder({
      radius: border?.radius,
      ...updatedBorder
    });
  };
  const resetAllFilter = (0,external_wp_element_namespaceObject.useCallback)(previousValue =&gt; {
    return {
      ...previousValue,
      border: undefined,
      shadow: undefined
    };
  }, []);
  const showBorderByDefault = defaultControls?.color || defaultControls?.width;
  const hasBorderControl = showBorderColor || showBorderStyle || showBorderWidth || showBorderRadius;
  const label = useBorderPanelLabel({
    blockName: name,
    hasShadowControl,
    hasBorderControl
  });
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(Wrapper, {
    resetAllFilter: resetAllFilter,
    value: value,
    onChange: onChange,
    panelId: panelId,
    label: label,
    children: [(showBorderWidth || showBorderColor) &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanelItem, {
      hasValue: () =&gt; (0,external_wp_components_namespaceObject.__experimentalIsDefinedBorder)(value?.border),
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Border&#039;),
      onDeselect: () =&gt; resetBorder(),
      isShownByDefault: showBorderByDefault,
      panelId: panelId,
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.BorderBoxControl, {
        colors: colors,
        enableAlpha: true,
        enableStyle: showBorderStyle,
        onChange: onBorderChange,
        popoverOffset: 40,
        popoverPlacement: &quot;left-start&quot;,
        value: border,
        __experimentalIsRenderedInSidebar: true,
        size: &quot;__unstable-large&quot;,
        hideLabelFromVision: !hasShadowControl,
        label: (0,external_wp_i18n_namespaceObject.__)(&#039;Border&#039;)
      })
    }), showBorderRadius &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanelItem, {
      hasValue: hasBorderRadius,
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Radius&#039;),
      onDeselect: () =&gt; setBorderRadius(undefined),
      isShownByDefault: defaultControls.radius,
      panelId: panelId,
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BorderRadiusControl, {
        values: borderRadiusValues,
        onChange: newValue =&gt; {
          setBorderRadius(newValue || undefined);
        }
      })
    }), hasShadowControl &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalToolsPanelItem, {
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Shadow&#039;),
      hasValue: hasShadow,
      onDeselect: resetShadow,
      isShownByDefault: defaultControls.shadow,
      panelId: panelId,
      children: [hasBorderControl ? /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.BaseControl.VisualLabel, {
        as: &quot;legend&quot;,
        children: (0,external_wp_i18n_namespaceObject.__)(&#039;Shadow&#039;)
      }) : null, /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalItemGroup, {
        isBordered: true,
        isSeparated: true,
        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ShadowPopover, {
          shadow: shadow,
          onShadowChange: setShadow,
          settings: settings
        })
      })]
    })]
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/hooks/border.js
/**
 * External dependencies
 */


/**
 * WordPress dependencies
 */






/**
 * Internal dependencies
 */








const BORDER_SUPPORT_KEY = &#039;__experimentalBorder&#039;;
const SHADOW_SUPPORT_KEY = &#039;shadow&#039;;
const getColorByProperty = (colors, property, value) =&gt; {
  let matchedColor;
  colors.some(origin =&gt; origin.colors.some(color =&gt; {
    if (color[property] === value) {
      matchedColor = color;
      return true;
    }
    return false;
  }));
  return matchedColor;
};
const getMultiOriginColor = ({
  colors,
  namedColor,
  customColor
}) =&gt; {
  // Search each origin (default, theme, or user) for matching color by name.
  if (namedColor) {
    const colorObject = getColorByProperty(colors, &#039;slug&#039;, namedColor);
    if (colorObject) {
      return colorObject;
    }
  }

  // Skip if no custom color or matching named color.
  if (!customColor) {
    return {
      color: undefined
    };
  }

  // Attempt to find color via custom color value or build new object.
  const colorObject = getColorByProperty(colors, &#039;color&#039;, customColor);
  return colorObject ? colorObject : {
    color: customColor
  };
};
function getColorSlugFromVariable(value) {
  const namedColor = /var:preset\|color\|(.+)/.exec(value);
  if (namedColor &amp;&amp; namedColor[1]) {
    return namedColor[1];
  }
  return null;
}
function styleToAttributes(style) {
  if ((0,external_wp_components_namespaceObject.__experimentalHasSplitBorders)(style?.border)) {
    return {
      style,
      borderColor: undefined
    };
  }
  const borderColorValue = style?.border?.color;
  const borderColorSlug = borderColorValue?.startsWith(&#039;var:preset|color|&#039;) ? borderColorValue.substring(&#039;var:preset|color|&#039;.length) : undefined;
  const updatedStyle = {
    ...style
  };
  updatedStyle.border = {
    ...updatedStyle.border,
    color: borderColorSlug ? undefined : borderColorValue
  };
  return {
    style: utils_cleanEmptyObject(updatedStyle),
    borderColor: borderColorSlug
  };
}
function attributesToStyle(attributes) {
  if ((0,external_wp_components_namespaceObject.__experimentalHasSplitBorders)(attributes.style?.border)) {
    return attributes.style;
  }
  return {
    ...attributes.style,
    border: {
      ...attributes.style?.border,
      color: attributes.borderColor ? &#039;var:preset|color|&#039; + attributes.borderColor : attributes.style?.border?.color
    }
  };
}
function BordersInspectorControl({
  label,
  children,
  resetAllFilter
}) {
  const attributesResetAllFilter = (0,external_wp_element_namespaceObject.useCallback)(attributes =&gt; {
    const existingStyle = attributesToStyle(attributes);
    const updatedStyle = resetAllFilter(existingStyle);
    return {
      ...attributes,
      ...styleToAttributes(updatedStyle)
    };
  }, [resetAllFilter]);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls, {
    group: &quot;border&quot;,
    resetAllFilter: attributesResetAllFilter,
    label: label,
    children: children
  });
}
function border_BorderPanel({
  clientId,
  name,
  setAttributes,
  settings
}) {
  const isEnabled = useHasBorderPanel(settings);
  function selector(select) {
    const {
      style,
      borderColor
    } = select(store).getBlockAttributes(clientId) || {};
    return {
      style,
      borderColor
    };
  }
  const {
    style,
    borderColor
  } = (0,external_wp_data_namespaceObject.useSelect)(selector, [clientId]);
  const value = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; {
    return attributesToStyle({
      style,
      borderColor
    });
  }, [style, borderColor]);
  const onChange = newStyle =&gt; {
    setAttributes(styleToAttributes(newStyle));
  };
  if (!isEnabled) {
    return null;
  }
  const defaultControls = {
    ...(0,external_wp_blocks_namespaceObject.getBlockSupport)(name, [BORDER_SUPPORT_KEY, &#039;__experimentalDefaultControls&#039;]),
    ...(0,external_wp_blocks_namespaceObject.getBlockSupport)(name, [SHADOW_SUPPORT_KEY, &#039;__experimentalDefaultControls&#039;])
  };
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BorderPanel, {
    as: BordersInspectorControl,
    panelId: clientId,
    settings: settings,
    value: value,
    onChange: onChange,
    defaultControls: defaultControls
  });
}

/**
 * Determine whether there is block support for border properties.
 *
 * @param {string} blockName Block name.
 * @param {string} feature   Border feature to check support for.
 *
 * @return {boolean} Whether there is support.
 */
function hasBorderSupport(blockName, feature = &#039;any&#039;) {
  if (external_wp_element_namespaceObject.Platform.OS !== &#039;web&#039;) {
    return false;
  }
  const support = (0,external_wp_blocks_namespaceObject.getBlockSupport)(blockName, BORDER_SUPPORT_KEY);
  if (support === true) {
    return true;
  }
  if (feature === &#039;any&#039;) {
    return !!(support?.color || support?.radius || support?.width || support?.style);
  }
  return !!support?.[feature];
}

/**
 * Determine whether there is block support for shadow properties.
 *
 * @param {string} blockName Block name.
 *
 * @return {boolean} Whether there is support.
 */
function hasShadowSupport(blockName) {
  return hasBlockSupport(blockName, SHADOW_SUPPORT_KEY);
}
function useBorderPanelLabel({
  blockName,
  hasBorderControl,
  hasShadowControl
} = {}) {
  const settings = useBlockSettings(blockName);
  const controls = useHasBorderPanelControls(settings);
  if (!hasBorderControl &amp;&amp; !hasShadowControl &amp;&amp; blockName) {
    hasBorderControl = controls?.hasBorderColor || controls?.hasBorderStyle || controls?.hasBorderWidth || controls?.hasBorderRadius;
    hasShadowControl = controls?.hasShadow;
  }
  if (hasBorderControl &amp;&amp; hasShadowControl) {
    return (0,external_wp_i18n_namespaceObject.__)(&#039;Border &amp; Shadow&#039;);
  }
  if (hasShadowControl) {
    return (0,external_wp_i18n_namespaceObject.__)(&#039;Shadow&#039;);
  }
  return (0,external_wp_i18n_namespaceObject.__)(&#039;Border&#039;);
}

/**
 * Returns a new style object where the specified border attribute has been
 * removed.
 *
 * @param {Object} style     Styles from block attributes.
 * @param {string} attribute The border style attribute to clear.
 *
 * @return {Object} Style object with the specified attribute removed.
 */
function removeBorderAttribute(style, attribute) {
  return cleanEmptyObject({
    ...style,
    border: {
      ...style?.border,
      [attribute]: undefined
    }
  });
}

/**
 * Filters registered block settings, extending attributes to include
 * `borderColor` if needed.
 *
 * @param {Object} settings Original block settings.
 *
 * @return {Object} Updated block settings.
 */
function addAttributes(settings) {
  if (!hasBorderSupport(settings, &#039;color&#039;)) {
    return settings;
  }

  // Allow blocks to specify default value if needed.
  if (settings.attributes.borderColor) {
    return settings;
  }

  // Add new borderColor attribute to block settings.
  return {
    ...settings,
    attributes: {
      ...settings.attributes,
      borderColor: {
        type: &#039;string&#039;
      }
    }
  };
}

/**
 * Override props assigned to save component to inject border color.
 *
 * @param {Object}        props           Additional props applied to save element.
 * @param {Object|string} blockNameOrType Block type definition.
 * @param {Object}        attributes      Block&#039;s attributes.
 *
 * @return {Object} Filtered props to apply to save element.
 */
function border_addSaveProps(props, blockNameOrType, attributes) {
  if (!hasBorderSupport(blockNameOrType, &#039;color&#039;) || shouldSkipSerialization(blockNameOrType, BORDER_SUPPORT_KEY, &#039;color&#039;)) {
    return props;
  }
  const borderClasses = getBorderClasses(attributes);
  const newClassName = dist_clsx(props.className, borderClasses);

  // If we are clearing the last of the previous classes in `className`
  // set it to `undefined` to avoid rendering empty DOM attributes.
  props.className = newClassName ? newClassName : undefined;
  return props;
}

/**
 * Generates a CSS class name consisting of all the applicable border color
 * classes given the current block attributes.
 *
 * @param {Object} attributes Block&#039;s attributes.
 *
 * @return {string} CSS class name.
 */
function getBorderClasses(attributes) {
  const {
    borderColor,
    style
  } = attributes;
  const borderColorClass = getColorClassName(&#039;border-color&#039;, borderColor);
  return dist_clsx({
    &#039;has-border-color&#039;: borderColor || style?.border?.color,
    [borderColorClass]: !!borderColorClass
  });
}
function border_useBlockProps({
  name,
  borderColor,
  style
}) {
  const {
    colors
  } = useMultipleOriginColorsAndGradients();
  if (!hasBorderSupport(name, &#039;color&#039;) || shouldSkipSerialization(name, BORDER_SUPPORT_KEY, &#039;color&#039;)) {
    return {};
  }
  const {
    color: borderColorValue
  } = getMultiOriginColor({
    colors,
    namedColor: borderColor
  });
  const {
    color: borderTopColor
  } = getMultiOriginColor({
    colors,
    namedColor: getColorSlugFromVariable(style?.border?.top?.color)
  });
  const {
    color: borderRightColor
  } = getMultiOriginColor({
    colors,
    namedColor: getColorSlugFromVariable(style?.border?.right?.color)
  });
  const {
    color: borderBottomColor
  } = getMultiOriginColor({
    colors,
    namedColor: getColorSlugFromVariable(style?.border?.bottom?.color)
  });
  const {
    color: borderLeftColor
  } = getMultiOriginColor({
    colors,
    namedColor: getColorSlugFromVariable(style?.border?.left?.color)
  });
  const extraStyles = {
    borderTopColor: borderTopColor || borderColorValue,
    borderRightColor: borderRightColor || borderColorValue,
    borderBottomColor: borderBottomColor || borderColorValue,
    borderLeftColor: borderLeftColor || borderColorValue
  };
  return border_addSaveProps({
    style: utils_cleanEmptyObject(extraStyles) || {}
  }, name, {
    borderColor,
    style
  });
}
/* harmony default export */ const border = ({
  useBlockProps: border_useBlockProps,
  addSaveProps: border_addSaveProps,
  attributeKeys: [&#039;borderColor&#039;, &#039;style&#039;],
  hasSupport(name) {
    return hasBorderSupport(name, &#039;color&#039;);
  }
});
(0,external_wp_hooks_namespaceObject.addFilter)(&#039;blocks.registerBlockType&#039;, &#039;core/border/addAttributes&#039;, addAttributes);

;// ./node_modules/@wordpress/block-editor/build-module/components/gradients/use-gradient.js
/**
 * WordPress dependencies
 */



/**
 * Internal dependencies
 */



function __experimentalGetGradientClass(gradientSlug) {
  if (!gradientSlug) {
    return undefined;
  }
  return `has-${gradientSlug}-gradient-background`;
}

/**
 * Retrieves the gradient value per slug.
 *
 * @param {Array}  gradients Gradient Palette
 * @param {string} slug      Gradient slug
 *
 * @return {string} Gradient value.
 */
function getGradientValueBySlug(gradients, slug) {
  const gradient = gradients?.find(g =&gt; g.slug === slug);
  return gradient &amp;&amp; gradient.gradient;
}
function __experimentalGetGradientObjectByGradientValue(gradients, value) {
  const gradient = gradients?.find(g =&gt; g.gradient === value);
  return gradient;
}

/**
 * Retrieves the gradient slug per slug.
 *
 * @param {Array}  gradients Gradient Palette
 * @param {string} value     Gradient value
 * @return {string} Gradient slug.
 */
function getGradientSlugByValue(gradients, value) {
  const gradient = __experimentalGetGradientObjectByGradientValue(gradients, value);
  return gradient &amp;&amp; gradient.slug;
}
function __experimentalUseGradient({
  gradientAttribute = &#039;gradient&#039;,
  customGradientAttribute = &#039;customGradient&#039;
} = {}) {
  const {
    clientId
  } = useBlockEditContext();
  const [userGradientPalette, themeGradientPalette, defaultGradientPalette] = use_settings_useSettings(&#039;color.gradients.custom&#039;, &#039;color.gradients.theme&#039;, &#039;color.gradients.default&#039;);
  const allGradients = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; [...(userGradientPalette || []), ...(themeGradientPalette || []), ...(defaultGradientPalette || [])], [userGradientPalette, themeGradientPalette, defaultGradientPalette]);
  const {
    gradient,
    customGradient
  } = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      getBlockAttributes
    } = select(store);
    const attributes = getBlockAttributes(clientId) || {};
    return {
      customGradient: attributes[customGradientAttribute],
      gradient: attributes[gradientAttribute]
    };
  }, [clientId, gradientAttribute, customGradientAttribute]);
  const {
    updateBlockAttributes
  } = (0,external_wp_data_namespaceObject.useDispatch)(store);
  const setGradient = (0,external_wp_element_namespaceObject.useCallback)(newGradientValue =&gt; {
    const slug = getGradientSlugByValue(allGradients, newGradientValue);
    if (slug) {
      updateBlockAttributes(clientId, {
        [gradientAttribute]: slug,
        [customGradientAttribute]: undefined
      });
      return;
    }
    updateBlockAttributes(clientId, {
      [gradientAttribute]: undefined,
      [customGradientAttribute]: newGradientValue
    });
  }, [allGradients, clientId, updateBlockAttributes]);
  const gradientClass = __experimentalGetGradientClass(gradient);
  let gradientValue;
  if (gradient) {
    gradientValue = getGradientValueBySlug(allGradients, gradient);
  } else {
    gradientValue = customGradient;
  }
  return {
    gradientClass,
    gradientValue,
    setGradient
  };
}

;// ./node_modules/@wordpress/block-editor/build-module/components/colors-gradients/control.js
/**
 * External dependencies
 */


/**
 * WordPress dependencies
 */



/**
 * Internal dependencies
 */



const {
  Tabs
} = unlock(external_wp_components_namespaceObject.privateApis);
const colorsAndGradientKeys = [&#039;colors&#039;, &#039;disableCustomColors&#039;, &#039;gradients&#039;, &#039;disableCustomGradients&#039;];
const TAB_IDS = {
  color: &#039;color&#039;,
  gradient: &#039;gradient&#039;
};
function ColorGradientControlInner({
  colors,
  gradients,
  disableCustomColors,
  disableCustomGradients,
  __experimentalIsRenderedInSidebar,
  className,
  label,
  onColorChange,
  onGradientChange,
  colorValue,
  gradientValue,
  clearable,
  showTitle = true,
  enableAlpha,
  headingLevel
}) {
  const canChooseAColor = onColorChange &amp;&amp; (colors &amp;&amp; colors.length &gt; 0 || !disableCustomColors);
  const canChooseAGradient = onGradientChange &amp;&amp; (gradients &amp;&amp; gradients.length &gt; 0 || !disableCustomGradients);
  if (!canChooseAColor &amp;&amp; !canChooseAGradient) {
    return null;
  }
  const tabPanels = {
    [TAB_IDS.color]: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ColorPalette, {
      value: colorValue,
      onChange: canChooseAGradient ? newColor =&gt; {
        onColorChange(newColor);
        onGradientChange();
      } : onColorChange,
      colors,
      disableCustomColors,
      __experimentalIsRenderedInSidebar: __experimentalIsRenderedInSidebar,
      clearable: clearable,
      enableAlpha: enableAlpha,
      headingLevel: headingLevel
    }),
    [TAB_IDS.gradient]: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.GradientPicker, {
      value: gradientValue,
      onChange: canChooseAColor ? newGradient =&gt; {
        onGradientChange(newGradient);
        onColorChange();
      } : onGradientChange,
      gradients,
      disableCustomGradients,
      __experimentalIsRenderedInSidebar: __experimentalIsRenderedInSidebar,
      clearable: clearable,
      headingLevel: headingLevel
    })
  };
  const renderPanelType = type =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
    className: &quot;block-editor-color-gradient-control__panel&quot;,
    children: tabPanels[type]
  });
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.BaseControl, {
    __nextHasNoMarginBottom: true,
    className: dist_clsx(&#039;block-editor-color-gradient-control&#039;, className),
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;fieldset&quot;, {
      className: &quot;block-editor-color-gradient-control__fieldset&quot;,
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalVStack, {
        spacing: 1,
        children: [showTitle &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;legend&quot;, {
          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
            className: &quot;block-editor-color-gradient-control__color-indicator&quot;,
            children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.BaseControl.VisualLabel, {
              children: label
            })
          })
        }), canChooseAColor &amp;&amp; canChooseAGradient &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(Tabs, {
            defaultTabId: gradientValue ? TAB_IDS.gradient : !!canChooseAColor &amp;&amp; TAB_IDS.color,
            children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(Tabs.TabList, {
              children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Tabs.Tab, {
                tabId: TAB_IDS.color,
                children: (0,external_wp_i18n_namespaceObject.__)(&#039;Color&#039;)
              }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Tabs.Tab, {
                tabId: TAB_IDS.gradient,
                children: (0,external_wp_i18n_namespaceObject.__)(&#039;Gradient&#039;)
              })]
            }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Tabs.TabPanel, {
              tabId: TAB_IDS.color,
              className: &quot;block-editor-color-gradient-control__panel&quot;,
              focusable: false,
              children: tabPanels.color
            }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Tabs.TabPanel, {
              tabId: TAB_IDS.gradient,
              className: &quot;block-editor-color-gradient-control__panel&quot;,
              focusable: false,
              children: tabPanels.gradient
            })]
          })
        }), !canChooseAGradient &amp;&amp; renderPanelType(TAB_IDS.color), !canChooseAColor &amp;&amp; renderPanelType(TAB_IDS.gradient)]
      })
    })
  });
}
function ColorGradientControlSelect(props) {
  const [colors, gradients, customColors, customGradients] = use_settings_useSettings(&#039;color.palette&#039;, &#039;color.gradients&#039;, &#039;color.custom&#039;, &#039;color.customGradient&#039;);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ColorGradientControlInner, {
    colors: colors,
    gradients: gradients,
    disableCustomColors: !customColors,
    disableCustomGradients: !customGradients,
    ...props
  });
}
function ColorGradientControl(props) {
  if (colorsAndGradientKeys.every(key =&gt; props.hasOwnProperty(key))) {
    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ColorGradientControlInner, {
      ...props
    });
  }
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ColorGradientControlSelect, {
    ...props
  });
}
/* harmony default export */ const control = (ColorGradientControl);

;// ./node_modules/@wordpress/block-editor/build-module/components/global-styles/color-panel.js
/**
 * External dependencies
 */


/**
 * WordPress dependencies
 */




/**
 * Internal dependencies
 */







function useHasColorPanel(settings) {
  const hasTextPanel = useHasTextPanel(settings);
  const hasBackgroundPanel = useHasBackgroundColorPanel(settings);
  const hasLinkPanel = useHasLinkPanel(settings);
  const hasHeadingPanel = useHasHeadingPanel(settings);
  const hasButtonPanel = useHasButtonPanel(settings);
  const hasCaptionPanel = useHasCaptionPanel(settings);
  return hasTextPanel || hasBackgroundPanel || hasLinkPanel || hasHeadingPanel || hasButtonPanel || hasCaptionPanel;
}
function useHasTextPanel(settings) {
  const colors = useColorsPerOrigin(settings);
  return settings?.color?.text &amp;&amp; (colors?.length &gt; 0 || settings?.color?.custom);
}
function useHasLinkPanel(settings) {
  const colors = useColorsPerOrigin(settings);
  return settings?.color?.link &amp;&amp; (colors?.length &gt; 0 || settings?.color?.custom);
}
function useHasCaptionPanel(settings) {
  const colors = useColorsPerOrigin(settings);
  return settings?.color?.caption &amp;&amp; (colors?.length &gt; 0 || settings?.color?.custom);
}
function useHasHeadingPanel(settings) {
  const colors = useColorsPerOrigin(settings);
  const gradients = useGradientsPerOrigin(settings);
  return settings?.color?.heading &amp;&amp; (colors?.length &gt; 0 || settings?.color?.custom || gradients?.length &gt; 0 || settings?.color?.customGradient);
}
function useHasButtonPanel(settings) {
  const colors = useColorsPerOrigin(settings);
  const gradients = useGradientsPerOrigin(settings);
  return settings?.color?.button &amp;&amp; (colors?.length &gt; 0 || settings?.color?.custom || gradients?.length &gt; 0 || settings?.color?.customGradient);
}
function useHasBackgroundColorPanel(settings) {
  const colors = useColorsPerOrigin(settings);
  const gradients = useGradientsPerOrigin(settings);
  return settings?.color?.background &amp;&amp; (colors?.length &gt; 0 || settings?.color?.custom || gradients?.length &gt; 0 || settings?.color?.customGradient);
}
function ColorToolsPanel({
  resetAllFilter,
  onChange,
  value,
  panelId,
  children
}) {
  const dropdownMenuProps = useToolsPanelDropdownMenuProps();
  const resetAll = () =&gt; {
    const updatedValue = resetAllFilter(value);
    onChange(updatedValue);
  };
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanel, {
    label: (0,external_wp_i18n_namespaceObject.__)(&#039;Elements&#039;),
    resetAll: resetAll,
    panelId: panelId,
    hasInnerWrapper: true,
    headingLevel: 3,
    className: &quot;color-block-support-panel&quot;,
    __experimentalFirstVisibleItemClass: &quot;first&quot;,
    __experimentalLastVisibleItemClass: &quot;last&quot;,
    dropdownMenuProps: dropdownMenuProps,
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
      className: &quot;color-block-support-panel__inner-wrapper&quot;,
      children: children
    })
  });
}
const color_panel_DEFAULT_CONTROLS = {
  text: true,
  background: true,
  link: true,
  heading: true,
  button: true,
  caption: true
};
const popoverProps = {
  placement: &#039;left-start&#039;,
  offset: 36,
  shift: true
};
const {
  Tabs: color_panel_Tabs
} = unlock(external_wp_components_namespaceObject.privateApis);
const LabeledColorIndicators = ({
  indicators,
  label
}) =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalHStack, {
  justify: &quot;flex-start&quot;,
  children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalZStack, {
    isLayered: false,
    offset: -8,
    children: indicators.map((indicator, index) =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Flex, {
      expanded: false,
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ColorIndicator, {
        colorValue: indicator
      })
    }, index))
  }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FlexItem, {
    className: &quot;block-editor-panel-color-gradient-settings__color-name&quot;,
    children: label
  })]
});
function ColorPanelTab({
  isGradient,
  inheritedValue,
  userValue,
  setValue,
  colorGradientControlSettings
}) {
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(control, {
    ...colorGradientControlSettings,
    showTitle: false,
    enableAlpha: true,
    __experimentalIsRenderedInSidebar: true,
    colorValue: isGradient ? undefined : inheritedValue,
    gradientValue: isGradient ? inheritedValue : undefined,
    onColorChange: isGradient ? undefined : setValue,
    onGradientChange: isGradient ? setValue : undefined,
    clearable: inheritedValue === userValue,
    headingLevel: 3
  });
}
function ColorPanelDropdown({
  label,
  hasValue,
  resetValue,
  isShownByDefault,
  indicators,
  tabs,
  colorGradientControlSettings,
  panelId
}) {
  var _tabs$;
  const currentTab = tabs.find(tab =&gt; tab.userValue !== undefined);
  const {
    key: firstTabKey,
    ...firstTab
  } = (_tabs$ = tabs[0]) !== null &amp;&amp; _tabs$ !== void 0 ? _tabs$ : {};
  const colorGradientDropdownButtonRef = (0,external_wp_element_namespaceObject.useRef)(undefined);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanelItem, {
    className: &quot;block-editor-tools-panel-color-gradient-settings__item&quot;,
    hasValue: hasValue,
    label: label,
    onDeselect: resetValue,
    isShownByDefault: isShownByDefault,
    panelId: panelId,
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Dropdown, {
      popoverProps: popoverProps,
      className: &quot;block-editor-tools-panel-color-gradient-settings__dropdown&quot;,
      renderToggle: ({
        onToggle,
        isOpen
      }) =&gt; {
        const toggleProps = {
          onClick: onToggle,
          className: dist_clsx(&#039;block-editor-panel-color-gradient-settings__dropdown&#039;, {
            &#039;is-open&#039;: isOpen
          }),
          &#039;aria-expanded&#039;: isOpen,
          ref: colorGradientDropdownButtonRef
        };
        return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
          children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
            ...toggleProps,
            __next40pxDefaultSize: true,
            children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(LabeledColorIndicators, {
              indicators: indicators,
              label: label
            })
          }), hasValue() &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
            __next40pxDefaultSize: true,
            label: (0,external_wp_i18n_namespaceObject.__)(&#039;Reset&#039;),
            className: &quot;block-editor-panel-color-gradient-settings__reset&quot;,
            size: &quot;small&quot;,
            icon: library_reset,
            onClick: () =&gt; {
              resetValue();
              if (isOpen) {
                onToggle();
              }
              // Return focus to parent button
              colorGradientDropdownButtonRef.current?.focus();
            }
          })]
        });
      },
      renderContent: () =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalDropdownContentWrapper, {
        paddingSize: &quot;none&quot;,
        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;div&quot;, {
          className: &quot;block-editor-panel-color-gradient-settings__dropdown-content&quot;,
          children: [tabs.length === 1 &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ColorPanelTab, {
            ...firstTab,
            colorGradientControlSettings: colorGradientControlSettings
          }, firstTabKey), tabs.length &gt; 1 &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(color_panel_Tabs, {
            defaultTabId: currentTab?.key,
            children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(color_panel_Tabs.TabList, {
              children: tabs.map(tab =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(color_panel_Tabs.Tab, {
                tabId: tab.key,
                children: tab.label
              }, tab.key))
            }), tabs.map(tab =&gt; {
              const {
                key: tabKey,
                ...restTabProps
              } = tab;
              return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(color_panel_Tabs.TabPanel, {
                tabId: tabKey,
                focusable: false,
                children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ColorPanelTab, {
                  ...restTabProps,
                  colorGradientControlSettings: colorGradientControlSettings
                }, tabKey)
              }, tabKey);
            })]
          })]
        })
      })
    })
  });
}
function ColorPanel({
  as: Wrapper = ColorToolsPanel,
  value,
  onChange,
  inheritedValue = value,
  settings,
  panelId,
  defaultControls = color_panel_DEFAULT_CONTROLS,
  children
}) {
  const colors = useColorsPerOrigin(settings);
  const gradients = useGradientsPerOrigin(settings);
  const areCustomSolidsEnabled = settings?.color?.custom;
  const areCustomGradientsEnabled = settings?.color?.customGradient;
  const hasSolidColors = colors.length &gt; 0 || areCustomSolidsEnabled;
  const hasGradientColors = gradients.length &gt; 0 || areCustomGradientsEnabled;
  const decodeValue = rawValue =&gt; getValueFromVariable({
    settings
  }, &#039;&#039;, rawValue);
  const encodeColorValue = colorValue =&gt; {
    const allColors = colors.flatMap(({
      colors: originColors
    }) =&gt; originColors);
    const colorObject = allColors.find(({
      color
    }) =&gt; color === colorValue);
    return colorObject ? &#039;var:preset|color|&#039; + colorObject.slug : colorValue;
  };
  const encodeGradientValue = gradientValue =&gt; {
    const allGradients = gradients.flatMap(({
      gradients: originGradients
    }) =&gt; originGradients);
    const gradientObject = allGradients.find(({
      gradient
    }) =&gt; gradient === gradientValue);
    return gradientObject ? &#039;var:preset|gradient|&#039; + gradientObject.slug : gradientValue;
  };

  // BackgroundColor
  const showBackgroundPanel = useHasBackgroundColorPanel(settings);
  const backgroundColor = decodeValue(inheritedValue?.color?.background);
  const userBackgroundColor = decodeValue(value?.color?.background);
  const gradient = decodeValue(inheritedValue?.color?.gradient);
  const userGradient = decodeValue(value?.color?.gradient);
  const hasBackground = () =&gt; !!userBackgroundColor || !!userGradient;
  const setBackgroundColor = newColor =&gt; {
    const newValue = setImmutably(value, [&#039;color&#039;, &#039;background&#039;], encodeColorValue(newColor));
    newValue.color.gradient = undefined;
    onChange(newValue);
  };
  const setGradient = newGradient =&gt; {
    const newValue = setImmutably(value, [&#039;color&#039;, &#039;gradient&#039;], encodeGradientValue(newGradient));
    newValue.color.background = undefined;
    onChange(newValue);
  };
  const resetBackground = () =&gt; {
    const newValue = setImmutably(value, [&#039;color&#039;, &#039;background&#039;], undefined);
    newValue.color.gradient = undefined;
    onChange(newValue);
  };

  // Links
  const showLinkPanel = useHasLinkPanel(settings);
  const linkColor = decodeValue(inheritedValue?.elements?.link?.color?.text);
  const userLinkColor = decodeValue(value?.elements?.link?.color?.text);
  const setLinkColor = newColor =&gt; {
    onChange(setImmutably(value, [&#039;elements&#039;, &#039;link&#039;, &#039;color&#039;, &#039;text&#039;], encodeColorValue(newColor)));
  };
  const hoverLinkColor = decodeValue(inheritedValue?.elements?.link?.[&#039;:hover&#039;]?.color?.text);
  const userHoverLinkColor = decodeValue(value?.elements?.link?.[&#039;:hover&#039;]?.color?.text);
  const setHoverLinkColor = newColor =&gt; {
    onChange(setImmutably(value, [&#039;elements&#039;, &#039;link&#039;, &#039;:hover&#039;, &#039;color&#039;, &#039;text&#039;], encodeColorValue(newColor)));
  };
  const hasLink = () =&gt; !!userLinkColor || !!userHoverLinkColor;
  const resetLink = () =&gt; {
    let newValue = setImmutably(value, [&#039;elements&#039;, &#039;link&#039;, &#039;:hover&#039;, &#039;color&#039;, &#039;text&#039;], undefined);
    newValue = setImmutably(newValue, [&#039;elements&#039;, &#039;link&#039;, &#039;color&#039;, &#039;text&#039;], undefined);
    onChange(newValue);
  };

  // Text Color
  const showTextPanel = useHasTextPanel(settings);
  const textColor = decodeValue(inheritedValue?.color?.text);
  const userTextColor = decodeValue(value?.color?.text);
  const hasTextColor = () =&gt; !!userTextColor;
  const setTextColor = newColor =&gt; {
    let changedObject = setImmutably(value, [&#039;color&#039;, &#039;text&#039;], encodeColorValue(newColor));
    if (textColor === linkColor) {
      changedObject = setImmutably(changedObject, [&#039;elements&#039;, &#039;link&#039;, &#039;color&#039;, &#039;text&#039;], encodeColorValue(newColor));
    }
    onChange(changedObject);
  };
  const resetTextColor = () =&gt; setTextColor(undefined);

  // Elements
  const elements = [{
    name: &#039;caption&#039;,
    label: (0,external_wp_i18n_namespaceObject.__)(&#039;Captions&#039;),
    showPanel: useHasCaptionPanel(settings)
  }, {
    name: &#039;button&#039;,
    label: (0,external_wp_i18n_namespaceObject.__)(&#039;Button&#039;),
    showPanel: useHasButtonPanel(settings)
  }, {
    name: &#039;heading&#039;,
    label: (0,external_wp_i18n_namespaceObject.__)(&#039;Heading&#039;),
    showPanel: useHasHeadingPanel(settings)
  }, {
    name: &#039;h1&#039;,
    label: (0,external_wp_i18n_namespaceObject.__)(&#039;H1&#039;),
    showPanel: useHasHeadingPanel(settings)
  }, {
    name: &#039;h2&#039;,
    label: (0,external_wp_i18n_namespaceObject.__)(&#039;H2&#039;),
    showPanel: useHasHeadingPanel(settings)
  }, {
    name: &#039;h3&#039;,
    label: (0,external_wp_i18n_namespaceObject.__)(&#039;H3&#039;),
    showPanel: useHasHeadingPanel(settings)
  }, {
    name: &#039;h4&#039;,
    label: (0,external_wp_i18n_namespaceObject.__)(&#039;H4&#039;),
    showPanel: useHasHeadingPanel(settings)
  }, {
    name: &#039;h5&#039;,
    label: (0,external_wp_i18n_namespaceObject.__)(&#039;H5&#039;),
    showPanel: useHasHeadingPanel(settings)
  }, {
    name: &#039;h6&#039;,
    label: (0,external_wp_i18n_namespaceObject.__)(&#039;H6&#039;),
    showPanel: useHasHeadingPanel(settings)
  }];
  const resetAllFilter = (0,external_wp_element_namespaceObject.useCallback)(previousValue =&gt; {
    return {
      ...previousValue,
      color: undefined,
      elements: {
        ...previousValue?.elements,
        link: {
          ...previousValue?.elements?.link,
          color: undefined,
          &#039;:hover&#039;: {
            color: undefined
          }
        },
        ...elements.reduce((acc, element) =&gt; {
          return {
            ...acc,
            [element.name]: {
              ...previousValue?.elements?.[element.name],
              color: undefined
            }
          };
        }, {})
      }
    };
  }, []);
  const items = [showTextPanel &amp;&amp; {
    key: &#039;text&#039;,
    label: (0,external_wp_i18n_namespaceObject.__)(&#039;Text&#039;),
    hasValue: hasTextColor,
    resetValue: resetTextColor,
    isShownByDefault: defaultControls.text,
    indicators: [textColor],
    tabs: [{
      key: &#039;text&#039;,
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Text&#039;),
      inheritedValue: textColor,
      setValue: setTextColor,
      userValue: userTextColor
    }]
  }, showBackgroundPanel &amp;&amp; {
    key: &#039;background&#039;,
    label: (0,external_wp_i18n_namespaceObject.__)(&#039;Background&#039;),
    hasValue: hasBackground,
    resetValue: resetBackground,
    isShownByDefault: defaultControls.background,
    indicators: [gradient !== null &amp;&amp; gradient !== void 0 ? gradient : backgroundColor],
    tabs: [hasSolidColors &amp;&amp; {
      key: &#039;background&#039;,
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Color&#039;),
      inheritedValue: backgroundColor,
      setValue: setBackgroundColor,
      userValue: userBackgroundColor
    }, hasGradientColors &amp;&amp; {
      key: &#039;gradient&#039;,
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Gradient&#039;),
      inheritedValue: gradient,
      setValue: setGradient,
      userValue: userGradient,
      isGradient: true
    }].filter(Boolean)
  }, showLinkPanel &amp;&amp; {
    key: &#039;link&#039;,
    label: (0,external_wp_i18n_namespaceObject.__)(&#039;Link&#039;),
    hasValue: hasLink,
    resetValue: resetLink,
    isShownByDefault: defaultControls.link,
    indicators: [linkColor, hoverLinkColor],
    tabs: [{
      key: &#039;link&#039;,
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Default&#039;),
      inheritedValue: linkColor,
      setValue: setLinkColor,
      userValue: userLinkColor
    }, {
      key: &#039;hover&#039;,
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Hover&#039;),
      inheritedValue: hoverLinkColor,
      setValue: setHoverLinkColor,
      userValue: userHoverLinkColor
    }]
  }].filter(Boolean);
  elements.forEach(({
    name,
    label,
    showPanel
  }) =&gt; {
    if (!showPanel) {
      return;
    }
    const elementBackgroundColor = decodeValue(inheritedValue?.elements?.[name]?.color?.background);
    const elementGradient = decodeValue(inheritedValue?.elements?.[name]?.color?.gradient);
    const elementTextColor = decodeValue(inheritedValue?.elements?.[name]?.color?.text);
    const elementBackgroundUserColor = decodeValue(value?.elements?.[name]?.color?.background);
    const elementGradientUserColor = decodeValue(value?.elements?.[name]?.color?.gradient);
    const elementTextUserColor = decodeValue(value?.elements?.[name]?.color?.text);
    const hasElement = () =&gt; !!(elementTextUserColor || elementBackgroundUserColor || elementGradientUserColor);
    const resetElement = () =&gt; {
      const newValue = setImmutably(value, [&#039;elements&#039;, name, &#039;color&#039;, &#039;background&#039;], undefined);
      newValue.elements[name].color.gradient = undefined;
      newValue.elements[name].color.text = undefined;
      onChange(newValue);
    };
    const setElementTextColor = newTextColor =&gt; {
      onChange(setImmutably(value, [&#039;elements&#039;, name, &#039;color&#039;, &#039;text&#039;], encodeColorValue(newTextColor)));
    };
    const setElementBackgroundColor = newBackgroundColor =&gt; {
      const newValue = setImmutably(value, [&#039;elements&#039;, name, &#039;color&#039;, &#039;background&#039;], encodeColorValue(newBackgroundColor));
      newValue.elements[name].color.gradient = undefined;
      onChange(newValue);
    };
    const setElementGradient = newGradient =&gt; {
      const newValue = setImmutably(value, [&#039;elements&#039;, name, &#039;color&#039;, &#039;gradient&#039;], encodeGradientValue(newGradient));
      newValue.elements[name].color.background = undefined;
      onChange(newValue);
    };
    const supportsTextColor = true;
    // Background color is not supported for `caption`
    // as there isn&#039;t yet a way to set padding for the element.
    const supportsBackground = name !== &#039;caption&#039;;
    items.push({
      key: name,
      label,
      hasValue: hasElement,
      resetValue: resetElement,
      isShownByDefault: defaultControls[name],
      indicators: supportsTextColor &amp;&amp; supportsBackground ? [elementTextColor, elementGradient !== null &amp;&amp; elementGradient !== void 0 ? elementGradient : elementBackgroundColor] : [supportsTextColor ? elementTextColor : elementGradient !== null &amp;&amp; elementGradient !== void 0 ? elementGradient : elementBackgroundColor],
      tabs: [hasSolidColors &amp;&amp; supportsTextColor &amp;&amp; {
        key: &#039;text&#039;,
        label: (0,external_wp_i18n_namespaceObject.__)(&#039;Text&#039;),
        inheritedValue: elementTextColor,
        setValue: setElementTextColor,
        userValue: elementTextUserColor
      }, hasSolidColors &amp;&amp; supportsBackground &amp;&amp; {
        key: &#039;background&#039;,
        label: (0,external_wp_i18n_namespaceObject.__)(&#039;Background&#039;),
        inheritedValue: elementBackgroundColor,
        setValue: setElementBackgroundColor,
        userValue: elementBackgroundUserColor
      }, hasGradientColors &amp;&amp; supportsBackground &amp;&amp; {
        key: &#039;gradient&#039;,
        label: (0,external_wp_i18n_namespaceObject.__)(&#039;Gradient&#039;),
        inheritedValue: elementGradient,
        setValue: setElementGradient,
        userValue: elementGradientUserColor,
        isGradient: true
      }].filter(Boolean)
    });
  });
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(Wrapper, {
    resetAllFilter: resetAllFilter,
    value: value,
    onChange: onChange,
    panelId: panelId,
    children: [items.map(item =&gt; {
      const {
        key,
        ...restItem
      } = item;
      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ColorPanelDropdown, {
        ...restItem,
        colorGradientControlSettings: {
          colors,
          disableCustomColors: !areCustomSolidsEnabled,
          gradients,
          disableCustomGradients: !areCustomGradientsEnabled
        },
        panelId: panelId
      }, key);
    }), children]
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/contrast-checker/index.js
/**
 * External dependencies
 */




/**
 * WordPress dependencies
 */




k([names, a11y]);
function ContrastChecker({
  backgroundColor,
  fallbackBackgroundColor,
  fallbackTextColor,
  fallbackLinkColor,
  fontSize,
  // Font size value in pixels.
  isLargeText,
  textColor,
  linkColor,
  enableAlphaChecker = false
}) {
  const currentBackgroundColor = backgroundColor || fallbackBackgroundColor;

  // Must have a background color.
  if (!currentBackgroundColor) {
    return null;
  }
  const currentTextColor = textColor || fallbackTextColor;
  const currentLinkColor = linkColor || fallbackLinkColor;

  // Must have at least one text color.
  if (!currentTextColor &amp;&amp; !currentLinkColor) {
    return null;
  }
  const textColors = [{
    color: currentTextColor,
    description: (0,external_wp_i18n_namespaceObject.__)(&#039;text color&#039;)
  }, {
    color: currentLinkColor,
    description: (0,external_wp_i18n_namespaceObject.__)(&#039;link color&#039;)
  }];
  const colordBackgroundColor = w(currentBackgroundColor);
  const backgroundColorHasTransparency = colordBackgroundColor.alpha() &lt; 1;
  const backgroundColorBrightness = colordBackgroundColor.brightness();
  const isReadableOptions = {
    level: &#039;AA&#039;,
    size: isLargeText || isLargeText !== false &amp;&amp; fontSize &gt;= 24 ? &#039;large&#039; : &#039;small&#039;
  };
  let message = &#039;&#039;;
  let speakMessage = &#039;&#039;;
  for (const item of textColors) {
    // If there is no color, go no further.
    if (!item.color) {
      continue;
    }
    const colordTextColor = w(item.color);
    const isColordTextReadable = colordTextColor.isReadable(colordBackgroundColor, isReadableOptions);
    const textHasTransparency = colordTextColor.alpha() &lt; 1;

    // If the contrast is not readable.
    if (!isColordTextReadable) {
      // Don&#039;t show the message if the background or text is transparent.
      if (backgroundColorHasTransparency || textHasTransparency) {
        continue;
      }
      message = backgroundColorBrightness &lt; colordTextColor.brightness() ? (0,external_wp_i18n_namespaceObject.sprintf)(
      // translators: %s is a type of text color, e.g., &quot;text color&quot; or &quot;link color&quot;.
      (0,external_wp_i18n_namespaceObject.__)(&#039;This color combination may be hard for people to read. Try using a darker background color and/or a brighter %s.&#039;), item.description) : (0,external_wp_i18n_namespaceObject.sprintf)(
      // translators: %s is a type of text color, e.g., &quot;text color&quot; or &quot;link color&quot;.
      (0,external_wp_i18n_namespaceObject.__)(&#039;This color combination may be hard for people to read. Try using a brighter background color and/or a darker %s.&#039;), item.description);
      speakMessage = (0,external_wp_i18n_namespaceObject.__)(&#039;This color combination may be hard for people to read.&#039;);
      // Break from the loop when we have a contrast warning.
      // These messages take priority over the transparency warning.
      break;
    }

    // If there is no contrast warning and the text is transparent,
    // show the transparent warning if alpha check is enabled.
    if (textHasTransparency &amp;&amp; enableAlphaChecker) {
      message = (0,external_wp_i18n_namespaceObject.__)(&#039;Transparent text may be hard for people to read.&#039;);
      speakMessage = (0,external_wp_i18n_namespaceObject.__)(&#039;Transparent text may be hard for people to read.&#039;);
    }
  }
  if (!message) {
    return null;
  }

  // Note: The `Notice` component can speak messages via its `spokenMessage`
  // prop, but the contrast checker requires granular control over when the
  // announcements are made. Notably, the message will be re-announced if a
  // new color combination is selected and the contrast is still insufficient.
  (0,external_wp_a11y_namespaceObject.speak)(speakMessage);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
    className: &quot;block-editor-contrast-checker&quot;,
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Notice, {
      spokenMessage: null,
      status: &quot;warning&quot;,
      isDismissible: false,
      children: message
    })
  });
}

/**
 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/contrast-checker/README.md
 */
/* harmony default export */ const contrast_checker = (ContrastChecker);

;// ./node_modules/@wordpress/block-editor/build-module/components/provider/block-refs-provider.js
/**
 * WordPress dependencies
 */



const BlockRefs = (0,external_wp_element_namespaceObject.createContext)({
  refsMap: (0,external_wp_compose_namespaceObject.observableMap)()
});
function BlockRefsProvider({
  children
}) {
  const value = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; ({
    refsMap: (0,external_wp_compose_namespaceObject.observableMap)()
  }), []);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockRefs.Provider, {
    value: value,
    children: children
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/block-list/use-block-props/use-block-refs.js
/**
 * WordPress dependencies
 */



/**
 * Internal dependencies
 */


/** @typedef {import(&#039;@wordpress/element&#039;).RefCallback} RefCallback */
/** @typedef {import(&#039;@wordpress/element&#039;).Ref} Ref */

/**
 * Provides a ref to the BlockRefs context.
 *
 * @param {string} clientId The client ID of the element ref.
 *
 * @return {RefCallback} Ref callback.
 */
function useBlockRefProvider(clientId) {
  const {
    refsMap
  } = (0,external_wp_element_namespaceObject.useContext)(BlockRefs);
  return (0,external_wp_compose_namespaceObject.useRefEffect)(element =&gt; {
    refsMap.set(clientId, element);
    return () =&gt; refsMap.delete(clientId);
  }, [clientId]);
}
function assignRef(ref, value) {
  if (typeof ref === &#039;function&#039;) {
    ref(value);
  } else if (ref) {
    ref.current = value;
  }
}

/**
 * Tracks the DOM element for the block identified by `clientId` and assigns it to the `ref`
 * whenever it changes.
 *
 * @param {string} clientId The client ID to track.
 * @param {Ref}    ref      The ref object/callback to assign to.
 */
function useBlockElementRef(clientId, ref) {
  const {
    refsMap
  } = (0,external_wp_element_namespaceObject.useContext)(BlockRefs);
  (0,external_wp_element_namespaceObject.useLayoutEffect)(() =&gt; {
    assignRef(ref, refsMap.get(clientId));
    const unsubscribe = refsMap.subscribe(clientId, () =&gt; assignRef(ref, refsMap.get(clientId)));
    return () =&gt; {
      unsubscribe();
      assignRef(ref, null);
    };
  }, [refsMap, clientId, ref]);
}

/**
 * Return the element for a given client ID. Updates whenever the element
 * changes, becomes available, or disappears.
 *
 * @param {string} clientId The client ID to an element for.
 *
 * @return {Element|null} The block&#039;s wrapper element.
 */
function useBlockElement(clientId) {
  const [blockElement, setBlockElement] = (0,external_wp_element_namespaceObject.useState)(null);
  useBlockElementRef(clientId, setBlockElement);
  return blockElement;
}

;// ./node_modules/@wordpress/block-editor/build-module/hooks/contrast-checker.js
/**
 * WordPress dependencies
 */


/**
 * Internal dependencies
 */



function getComputedValue(node, property) {
  return node.ownerDocument.defaultView.getComputedStyle(node).getPropertyValue(property);
}
function getBlockElementColors(blockEl) {
  if (!blockEl) {
    return {};
  }
  const firstLinkElement = blockEl.querySelector(&#039;a&#039;);
  const linkColor = !!firstLinkElement?.innerText ? getComputedValue(firstLinkElement, &#039;color&#039;) : undefined;
  const textColor = getComputedValue(blockEl, &#039;color&#039;);
  let backgroundColorNode = blockEl;
  let backgroundColor = getComputedValue(backgroundColorNode, &#039;background-color&#039;);
  while (backgroundColor === &#039;rgba(0, 0, 0, 0)&#039; &amp;&amp; backgroundColorNode.parentNode &amp;&amp; backgroundColorNode.parentNode.nodeType === backgroundColorNode.parentNode.ELEMENT_NODE) {
    backgroundColorNode = backgroundColorNode.parentNode;
    backgroundColor = getComputedValue(backgroundColorNode, &#039;background-color&#039;);
  }
  return {
    textColor,
    backgroundColor,
    linkColor
  };
}
function contrast_checker_reducer(prevColors, newColors) {
  const hasChanged = Object.keys(newColors).some(key =&gt; prevColors[key] !== newColors[key]);

  // Do not re-render if the colors have not changed.
  return hasChanged ? newColors : prevColors;
}
function BlockColorContrastChecker({
  clientId
}) {
  const blockEl = useBlockElement(clientId);
  const [colors, setColors] = (0,external_wp_element_namespaceObject.useReducer)(contrast_checker_reducer, {});

  // There are so many things that can change the color of a block
  // So we perform this check on every render.
  (0,external_wp_element_namespaceObject.useLayoutEffect)(() =&gt; {
    if (!blockEl) {
      return;
    }
    function updateColors() {
      setColors(getBlockElementColors(blockEl));
    }

    // Combine `useLayoutEffect` and two rAF calls to ensure that values are read
    // after the current paint but before the next paint.
    window.requestAnimationFrame(() =&gt; window.requestAnimationFrame(updateColors));
  });
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(contrast_checker, {
    backgroundColor: colors.backgroundColor,
    textColor: colors.textColor,
    linkColor: colors.linkColor,
    enableAlphaChecker: true
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/hooks/color.js
/**
 * External dependencies
 */


/**
 * WordPress dependencies
 */





/**
 * Internal dependencies
 */










const COLOR_SUPPORT_KEY = &#039;color&#039;;
const hasColorSupport = blockNameOrType =&gt; {
  const colorSupport = (0,external_wp_blocks_namespaceObject.getBlockSupport)(blockNameOrType, COLOR_SUPPORT_KEY);
  return colorSupport &amp;&amp; (colorSupport.link === true || colorSupport.gradient === true || colorSupport.background !== false || colorSupport.text !== false);
};
const hasLinkColorSupport = blockType =&gt; {
  if (external_wp_element_namespaceObject.Platform.OS !== &#039;web&#039;) {
    return false;
  }
  const colorSupport = (0,external_wp_blocks_namespaceObject.getBlockSupport)(blockType, COLOR_SUPPORT_KEY);
  return colorSupport !== null &amp;&amp; typeof colorSupport === &#039;object&#039; &amp;&amp; !!colorSupport.link;
};
const hasGradientSupport = blockNameOrType =&gt; {
  const colorSupport = (0,external_wp_blocks_namespaceObject.getBlockSupport)(blockNameOrType, COLOR_SUPPORT_KEY);
  return colorSupport !== null &amp;&amp; typeof colorSupport === &#039;object&#039; &amp;&amp; !!colorSupport.gradients;
};
const hasBackgroundColorSupport = blockType =&gt; {
  const colorSupport = (0,external_wp_blocks_namespaceObject.getBlockSupport)(blockType, COLOR_SUPPORT_KEY);
  return colorSupport &amp;&amp; colorSupport.background !== false;
};
const hasTextColorSupport = blockType =&gt; {
  const colorSupport = (0,external_wp_blocks_namespaceObject.getBlockSupport)(blockType, COLOR_SUPPORT_KEY);
  return colorSupport &amp;&amp; colorSupport.text !== false;
};

/**
 * Filters registered block settings, extending attributes to include
 * `backgroundColor` and `textColor` attribute.
 *
 * @param {Object} settings Original block settings.
 *
 * @return {Object} Filtered block settings.
 */
function color_addAttributes(settings) {
  if (!hasColorSupport(settings)) {
    return settings;
  }

  // Allow blocks to specify their own attribute definition with default values if needed.
  if (!settings.attributes.backgroundColor) {
    Object.assign(settings.attributes, {
      backgroundColor: {
        type: &#039;string&#039;
      }
    });
  }
  if (!settings.attributes.textColor) {
    Object.assign(settings.attributes, {
      textColor: {
        type: &#039;string&#039;
      }
    });
  }
  if (hasGradientSupport(settings) &amp;&amp; !settings.attributes.gradient) {
    Object.assign(settings.attributes, {
      gradient: {
        type: &#039;string&#039;
      }
    });
  }
  return settings;
}

/**
 * Override props assigned to save component to inject colors classnames.
 *
 * @param {Object}        props           Additional props applied to save element.
 * @param {Object|string} blockNameOrType Block type.
 * @param {Object}        attributes      Block attributes.
 *
 * @return {Object} Filtered props applied to save element.
 */
function color_addSaveProps(props, blockNameOrType, attributes) {
  if (!hasColorSupport(blockNameOrType) || shouldSkipSerialization(blockNameOrType, COLOR_SUPPORT_KEY)) {
    return props;
  }
  const hasGradient = hasGradientSupport(blockNameOrType);

  // I&#039;d have preferred to avoid the &quot;style&quot; attribute usage here
  const {
    backgroundColor,
    textColor,
    gradient,
    style
  } = attributes;
  const shouldSerialize = feature =&gt; !shouldSkipSerialization(blockNameOrType, COLOR_SUPPORT_KEY, feature);

  // Primary color classes must come before the `has-text-color`,
  // `has-background` and `has-link-color` classes to maintain backwards
  // compatibility and avoid block invalidations.
  const textClass = shouldSerialize(&#039;text&#039;) ? getColorClassName(&#039;color&#039;, textColor) : undefined;
  const gradientClass = shouldSerialize(&#039;gradients&#039;) ? __experimentalGetGradientClass(gradient) : undefined;
  const backgroundClass = shouldSerialize(&#039;background&#039;) ? getColorClassName(&#039;background-color&#039;, backgroundColor) : undefined;
  const serializeHasBackground = shouldSerialize(&#039;background&#039;) || shouldSerialize(&#039;gradients&#039;);
  const hasBackground = backgroundColor || style?.color?.background || hasGradient &amp;&amp; (gradient || style?.color?.gradient);
  const newClassName = dist_clsx(props.className, textClass, gradientClass, {
    // Don&#039;t apply the background class if there&#039;s a custom gradient.
    [backgroundClass]: (!hasGradient || !style?.color?.gradient) &amp;&amp; !!backgroundClass,
    &#039;has-text-color&#039;: shouldSerialize(&#039;text&#039;) &amp;&amp; (textColor || style?.color?.text),
    &#039;has-background&#039;: serializeHasBackground &amp;&amp; hasBackground,
    &#039;has-link-color&#039;: shouldSerialize(&#039;link&#039;) &amp;&amp; style?.elements?.link?.color
  });
  props.className = newClassName ? newClassName : undefined;
  return props;
}
function color_styleToAttributes(style) {
  const textColorValue = style?.color?.text;
  const textColorSlug = textColorValue?.startsWith(&#039;var:preset|color|&#039;) ? textColorValue.substring(&#039;var:preset|color|&#039;.length) : undefined;
  const backgroundColorValue = style?.color?.background;
  const backgroundColorSlug = backgroundColorValue?.startsWith(&#039;var:preset|color|&#039;) ? backgroundColorValue.substring(&#039;var:preset|color|&#039;.length) : undefined;
  const gradientValue = style?.color?.gradient;
  const gradientSlug = gradientValue?.startsWith(&#039;var:preset|gradient|&#039;) ? gradientValue.substring(&#039;var:preset|gradient|&#039;.length) : undefined;
  const updatedStyle = {
    ...style
  };
  updatedStyle.color = {
    ...updatedStyle.color,
    text: textColorSlug ? undefined : textColorValue,
    background: backgroundColorSlug ? undefined : backgroundColorValue,
    gradient: gradientSlug ? undefined : gradientValue
  };
  return {
    style: utils_cleanEmptyObject(updatedStyle),
    textColor: textColorSlug,
    backgroundColor: backgroundColorSlug,
    gradient: gradientSlug
  };
}
function color_attributesToStyle(attributes) {
  return {
    ...attributes.style,
    color: {
      ...attributes.style?.color,
      text: attributes.textColor ? &#039;var:preset|color|&#039; + attributes.textColor : attributes.style?.color?.text,
      background: attributes.backgroundColor ? &#039;var:preset|color|&#039; + attributes.backgroundColor : attributes.style?.color?.background,
      gradient: attributes.gradient ? &#039;var:preset|gradient|&#039; + attributes.gradient : attributes.style?.color?.gradient
    }
  };
}
function ColorInspectorControl({
  children,
  resetAllFilter
}) {
  const attributesResetAllFilter = (0,external_wp_element_namespaceObject.useCallback)(attributes =&gt; {
    const existingStyle = color_attributesToStyle(attributes);
    const updatedStyle = resetAllFilter(existingStyle);
    return {
      ...attributes,
      ...color_styleToAttributes(updatedStyle)
    };
  }, [resetAllFilter]);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls, {
    group: &quot;color&quot;,
    resetAllFilter: attributesResetAllFilter,
    children: children
  });
}
function ColorEdit({
  clientId,
  name,
  setAttributes,
  settings
}) {
  const isEnabled = useHasColorPanel(settings);
  function selector(select) {
    const {
      style,
      textColor,
      backgroundColor,
      gradient
    } = select(store).getBlockAttributes(clientId) || {};
    return {
      style,
      textColor,
      backgroundColor,
      gradient
    };
  }
  const {
    style,
    textColor,
    backgroundColor,
    gradient
  } = (0,external_wp_data_namespaceObject.useSelect)(selector, [clientId]);
  const value = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; {
    return color_attributesToStyle({
      style,
      textColor,
      backgroundColor,
      gradient
    });
  }, [style, textColor, backgroundColor, gradient]);
  const onChange = newStyle =&gt; {
    setAttributes(color_styleToAttributes(newStyle));
  };
  if (!isEnabled) {
    return null;
  }
  const defaultControls = (0,external_wp_blocks_namespaceObject.getBlockSupport)(name, [COLOR_SUPPORT_KEY, &#039;__experimentalDefaultControls&#039;]);
  const enableContrastChecking = external_wp_element_namespaceObject.Platform.OS === &#039;web&#039; &amp;&amp; !value?.color?.gradient &amp;&amp; (settings?.color?.text || settings?.color?.link) &amp;&amp;
  // Contrast checking is enabled by default.
  // Deactivating it requires `enableContrastChecker` to have
  // an explicit value of `false`.
  false !== (0,external_wp_blocks_namespaceObject.getBlockSupport)(name, [COLOR_SUPPORT_KEY, &#039;enableContrastChecker&#039;]);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ColorPanel, {
    as: ColorInspectorControl,
    panelId: clientId,
    settings: settings,
    value: value,
    onChange: onChange,
    defaultControls: defaultControls,
    enableContrastChecker: false !== (0,external_wp_blocks_namespaceObject.getBlockSupport)(name, [COLOR_SUPPORT_KEY, &#039;enableContrastChecker&#039;]),
    children: enableContrastChecking &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockColorContrastChecker, {
      clientId: clientId
    })
  });
}
function color_useBlockProps({
  name,
  backgroundColor,
  textColor,
  gradient,
  style
}) {
  const [userPalette, themePalette, defaultPalette] = use_settings_useSettings(&#039;color.palette.custom&#039;, &#039;color.palette.theme&#039;, &#039;color.palette.default&#039;);
  const colors = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; [...(userPalette || []), ...(themePalette || []), ...(defaultPalette || [])], [userPalette, themePalette, defaultPalette]);
  if (!hasColorSupport(name) || shouldSkipSerialization(name, COLOR_SUPPORT_KEY)) {
    return {};
  }
  const extraStyles = {};
  if (textColor &amp;&amp; !shouldSkipSerialization(name, COLOR_SUPPORT_KEY, &#039;text&#039;)) {
    extraStyles.color = getColorObjectByAttributeValues(colors, textColor)?.color;
  }
  if (backgroundColor &amp;&amp; !shouldSkipSerialization(name, COLOR_SUPPORT_KEY, &#039;background&#039;)) {
    extraStyles.backgroundColor = getColorObjectByAttributeValues(colors, backgroundColor)?.color;
  }
  const saveProps = color_addSaveProps({
    style: extraStyles
  }, name, {
    textColor,
    backgroundColor,
    gradient,
    style
  });
  const hasBackgroundValue = backgroundColor || style?.color?.background || gradient || style?.color?.gradient;
  return {
    ...saveProps,
    className: dist_clsx(saveProps.className,
    // Add background image classes in the editor, if not already handled by background color values.
    !hasBackgroundValue &amp;&amp; getBackgroundImageClasses(style))
  };
}
/* harmony default export */ const color = ({
  useBlockProps: color_useBlockProps,
  addSaveProps: color_addSaveProps,
  attributeKeys: [&#039;backgroundColor&#039;, &#039;textColor&#039;, &#039;gradient&#039;, &#039;style&#039;],
  hasSupport: hasColorSupport
});
const MIGRATION_PATHS = {
  linkColor: [[&#039;style&#039;, &#039;elements&#039;, &#039;link&#039;, &#039;color&#039;, &#039;text&#039;]],
  textColor: [[&#039;textColor&#039;], [&#039;style&#039;, &#039;color&#039;, &#039;text&#039;]],
  backgroundColor: [[&#039;backgroundColor&#039;], [&#039;style&#039;, &#039;color&#039;, &#039;background&#039;]],
  gradient: [[&#039;gradient&#039;], [&#039;style&#039;, &#039;color&#039;, &#039;gradient&#039;]]
};
function color_addTransforms(result, source, index, results) {
  const destinationBlockType = result.name;
  const activeSupports = {
    linkColor: hasLinkColorSupport(destinationBlockType),
    textColor: hasTextColorSupport(destinationBlockType),
    backgroundColor: hasBackgroundColorSupport(destinationBlockType),
    gradient: hasGradientSupport(destinationBlockType)
  };
  return transformStyles(activeSupports, MIGRATION_PATHS, result, source, index, results);
}
(0,external_wp_hooks_namespaceObject.addFilter)(&#039;blocks.registerBlockType&#039;, &#039;core/color/addAttribute&#039;, color_addAttributes);
(0,external_wp_hooks_namespaceObject.addFilter)(&#039;blocks.switchToBlockType.transformedBlock&#039;, &#039;core/color/addTransforms&#039;, color_addTransforms);

;// ./node_modules/@wordpress/block-editor/build-module/components/font-family/index.js
/**
 * External dependencies
 */


/**
 * WordPress dependencies
 */




/**
 * Internal dependencies
 */


function FontFamilyControl({
  /** Start opting into the larger default height that will become the default size in a future version. */
  __next40pxDefaultSize = false,
  /** Start opting into the new margin-free styles that will become the default in a future version. */
  __nextHasNoMarginBottom = false,
  value = &#039;&#039;,
  onChange,
  fontFamilies,
  className,
  ...props
}) {
  var _options$find;
  const [blockLevelFontFamilies] = use_settings_useSettings(&#039;typography.fontFamilies&#039;);
  if (!fontFamilies) {
    fontFamilies = blockLevelFontFamilies;
  }
  if (!fontFamilies || fontFamilies.length === 0) {
    return null;
  }
  const options = [{
    key: &#039;&#039;,
    name: (0,external_wp_i18n_namespaceObject.__)(&#039;Default&#039;)
  }, ...fontFamilies.map(({
    fontFamily,
    name
  }) =&gt; ({
    key: fontFamily,
    name: name || fontFamily,
    style: {
      fontFamily
    }
  }))];
  if (!__nextHasNoMarginBottom) {
    external_wp_deprecated_default()(&#039;Bottom margin styles for wp.blockEditor.FontFamilyControl&#039;, {
      since: &#039;6.7&#039;,
      version: &#039;7.0&#039;,
      hint: &#039;Set the `__nextHasNoMarginBottom` prop to true to start opting into the new styles, which will become the default in a future version&#039;
    });
  }
  if (!__next40pxDefaultSize &amp;&amp; (props.size === undefined || props.size === &#039;default&#039;)) {
    external_wp_deprecated_default()(`36px default size for wp.blockEditor.__experimentalFontFamilyControl`, {
      since: &#039;6.8&#039;,
      version: &#039;7.1&#039;,
      hint: &#039;Set the `__next40pxDefaultSize` prop to true to start opting into the new default size, which will become the default in a future version.&#039;
    });
  }
  const selectedValue = (_options$find = options.find(option =&gt; option.key === value)) !== null &amp;&amp; _options$find !== void 0 ? _options$find : &#039;&#039;;
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.CustomSelectControl, {
    __next40pxDefaultSize: __next40pxDefaultSize,
    __shouldNotWarnDeprecated36pxSize: true,
    label: (0,external_wp_i18n_namespaceObject.__)(&#039;Font&#039;),
    value: selectedValue,
    onChange: ({
      selectedItem
    }) =&gt; onChange(selectedItem.key),
    options: options,
    className: dist_clsx(&#039;block-editor-font-family-control&#039;, className, {
      &#039;is-next-has-no-margin-bottom&#039;: __nextHasNoMarginBottom
    }),
    ...props
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/font-appearance-control/index.js
/**
 * WordPress dependencies
 */





/**
 * Internal dependencies
 */


/**
 * Adjusts font appearance field label in case either font styles or weights
 * are disabled.
 *
 * @param {boolean} hasFontStyles  Whether font styles are enabled and present.
 * @param {boolean} hasFontWeights Whether font weights are enabled and present.
 * @return {string} A label representing what font appearance is being edited.
 */

const getFontAppearanceLabel = (hasFontStyles, hasFontWeights) =&gt; {
  if (!hasFontStyles) {
    return (0,external_wp_i18n_namespaceObject.__)(&#039;Font weight&#039;);
  }
  if (!hasFontWeights) {
    return (0,external_wp_i18n_namespaceObject.__)(&#039;Font style&#039;);
  }
  return (0,external_wp_i18n_namespaceObject.__)(&#039;Appearance&#039;);
};

/**
 * Control to display font style and weight options of the active font.
 *
 * @param {Object} props Component props.
 *
 * @return {Element} Font appearance control.
 */
function FontAppearanceControl(props) {
  const {
    /** Start opting into the larger default height that will become the default size in a future version. */
    __next40pxDefaultSize = false,
    onChange,
    hasFontStyles = true,
    hasFontWeights = true,
    fontFamilyFaces,
    value: {
      fontStyle,
      fontWeight
    },
    ...otherProps
  } = props;
  const hasStylesOrWeights = hasFontStyles || hasFontWeights;
  const label = getFontAppearanceLabel(hasFontStyles, hasFontWeights);
  const defaultOption = {
    key: &#039;default&#039;,
    name: (0,external_wp_i18n_namespaceObject.__)(&#039;Default&#039;),
    style: {
      fontStyle: undefined,
      fontWeight: undefined
    }
  };
  const {
    fontStyles,
    fontWeights,
    combinedStyleAndWeightOptions
  } = getFontStylesAndWeights(fontFamilyFaces);

  // Generates select options for combined font styles and weights.
  const combineOptions = () =&gt; {
    const combinedOptions = [defaultOption];
    if (combinedStyleAndWeightOptions) {
      combinedOptions.push(...combinedStyleAndWeightOptions);
    }
    return combinedOptions;
  };

  // Generates select options for font styles only.
  const styleOptions = () =&gt; {
    const combinedOptions = [defaultOption];
    fontStyles.forEach(({
      name,
      value
    }) =&gt; {
      combinedOptions.push({
        key: value,
        name,
        style: {
          fontStyle: value,
          fontWeight: undefined
        }
      });
    });
    return combinedOptions;
  };

  // Generates select options for font weights only.
  const weightOptions = () =&gt; {
    const combinedOptions = [defaultOption];
    fontWeights.forEach(({
      name,
      value
    }) =&gt; {
      combinedOptions.push({
        key: value,
        name,
        style: {
          fontStyle: undefined,
          fontWeight: value
        }
      });
    });
    return combinedOptions;
  };

  // Map font styles and weights to select options.
  const selectOptions = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; {
    // Display combined available font style and weight options.
    if (hasFontStyles &amp;&amp; hasFontWeights) {
      return combineOptions();
    }

    // Display only font style options or font weight options.
    return hasFontStyles ? styleOptions() : weightOptions();
  }, [props.options, fontStyles, fontWeights, combinedStyleAndWeightOptions]);

  // Find current selection by comparing font style &amp; weight against options,
  // and fall back to the Default option if there is no matching option.
  const currentSelection = selectOptions.find(option =&gt; option.style.fontStyle === fontStyle &amp;&amp; option.style.fontWeight === fontWeight) || selectOptions[0];

  // Adjusts screen reader description based on styles or weights.
  const getDescribedBy = () =&gt; {
    if (!currentSelection) {
      return (0,external_wp_i18n_namespaceObject.__)(&#039;No selected font appearance&#039;);
    }
    if (!hasFontStyles) {
      return (0,external_wp_i18n_namespaceObject.sprintf)(
      // translators: %s: Currently selected font weight.
      (0,external_wp_i18n_namespaceObject.__)(&#039;Currently selected font weight: %s&#039;), currentSelection.name);
    }
    if (!hasFontWeights) {
      return (0,external_wp_i18n_namespaceObject.sprintf)(
      // translators: %s: Currently selected font style.
      (0,external_wp_i18n_namespaceObject.__)(&#039;Currently selected font style: %s&#039;), currentSelection.name);
    }
    return (0,external_wp_i18n_namespaceObject.sprintf)(
    // translators: %s: Currently selected font appearance.
    (0,external_wp_i18n_namespaceObject.__)(&#039;Currently selected font appearance: %s&#039;), currentSelection.name);
  };
  if (!__next40pxDefaultSize &amp;&amp; (otherProps.size === undefined || otherProps.size === &#039;default&#039;)) {
    external_wp_deprecated_default()(`36px default size for wp.blockEditor.__experimentalFontAppearanceControl`, {
      since: &#039;6.8&#039;,
      version: &#039;7.1&#039;,
      hint: &#039;Set the `__next40pxDefaultSize` prop to true to start opting into the new default size, which will become the default in a future version.&#039;
    });
  }
  return hasStylesOrWeights &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.CustomSelectControl, {
    ...otherProps,
    className: &quot;components-font-appearance-control&quot;,
    __next40pxDefaultSize: __next40pxDefaultSize,
    __shouldNotWarnDeprecated36pxSize: true,
    label: label,
    describedBy: getDescribedBy(),
    options: selectOptions,
    value: currentSelection,
    onChange: ({
      selectedItem
    }) =&gt; onChange(selectedItem.style)
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/line-height-control/utils.js
const BASE_DEFAULT_VALUE = 1.5;
const STEP = 0.01;
/**
 * A spin factor of 10 allows the spin controls to increment/decrement by 0.1.
 * e.g. A line-height value of 1.55 will increment to 1.65.
 */
const SPIN_FACTOR = 10;
/**
 * There are varying value types within LineHeightControl:
 *
 * {undefined} Initial value. No changes from the user.
 * {string} Input value. Value consumed/outputted by the input. Empty would be &#039;&#039;.
 * {number} Block attribute type. Input value needs to be converted for attribute setting.
 *
 * Note: If the value is undefined, the input requires it to be an empty string (&#039;&#039;)
 * in order to be considered &quot;controlled&quot; by props (rather than internal state).
 */
const RESET_VALUE = &#039;&#039;;

/**
 * Determines if the lineHeight attribute has been properly defined.
 *
 * @param {any} lineHeight The value to check.
 *
 * @return {boolean} Whether the lineHeight attribute is valid.
 */
function isLineHeightDefined(lineHeight) {
  return lineHeight !== undefined &amp;&amp; lineHeight !== RESET_VALUE;
}

;// ./node_modules/@wordpress/block-editor/build-module/components/line-height-control/index.js
/**
 * WordPress dependencies
 */




/**
 * Internal dependencies
 */


const line_height_control_LineHeightControl = ({
  /** Start opting into the larger default height that will become the default size in a future version. */
  __next40pxDefaultSize = false,
  value: lineHeight,
  onChange,
  __unstableInputWidth = &#039;60px&#039;,
  ...otherProps
}) =&gt; {
  const isDefined = isLineHeightDefined(lineHeight);
  const adjustNextValue = (nextValue, wasTypedOrPasted) =&gt; {
    // Set the next value without modification if lineHeight has been defined.
    if (isDefined) {
      return nextValue;
    }

    /**
     * The following logic handles the initial spin up/down action
     * (from an undefined value state) so that the next values are better suited for
     * line-height rendering. For example, the first spin up should immediately
     * go to 1.6, rather than the normally expected 0.1.
     *
     * Spin up/down actions can be triggered by keydowns of the up/down arrow keys,
     * dragging the input or by clicking the spin buttons.
     */
    const spin = STEP * SPIN_FACTOR;
    switch (`${nextValue}`) {
      case `${spin}`:
        // Increment by spin value.
        return BASE_DEFAULT_VALUE + spin;
      case &#039;0&#039;:
        {
          // This means the user explicitly input &#039;0&#039;, rather than using the
          // spin down action from an undefined value state.
          if (wasTypedOrPasted) {
            return nextValue;
          }
          // Decrement by spin value.
          return BASE_DEFAULT_VALUE - spin;
        }
      case &#039;&#039;:
        return BASE_DEFAULT_VALUE;
      default:
        return nextValue;
    }
  };
  const stateReducer = (state, action) =&gt; {
    // Be careful when changing this — cross-browser behavior of the
    // `inputType` field in `input` events are inconsistent.
    // For example, Firefox emits an input event with inputType=&quot;insertReplacementText&quot;
    // on spin button clicks, while other browsers do not even emit an input event.
    const wasTypedOrPasted = [&#039;insertText&#039;, &#039;insertFromPaste&#039;].includes(action.payload.event.nativeEvent?.inputType);
    const value = adjustNextValue(state.value, wasTypedOrPasted);
    return {
      ...state,
      value
    };
  };
  const value = isDefined ? lineHeight : RESET_VALUE;
  const handleOnChange = (nextValue, {
    event
  }) =&gt; {
    if (nextValue === &#039;&#039;) {
      onChange();
      return;
    }
    if (event.type === &#039;click&#039;) {
      onChange(adjustNextValue(`${nextValue}`, false));
      return;
    }
    onChange(`${nextValue}`);
  };
  if (!__next40pxDefaultSize &amp;&amp; (otherProps.size === undefined || otherProps.size === &#039;default&#039;)) {
    external_wp_deprecated_default()(`36px default size for wp.blockEditor.LineHeightControl`, {
      since: &#039;6.8&#039;,
      version: &#039;7.1&#039;,
      hint: &#039;Set the `__next40pxDefaultSize` prop to true to start opting into the new default size, which will become the default in a future version.&#039;
    });
  }
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
    className: &quot;block-editor-line-height-control&quot;,
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalNumberControl, {
      ...otherProps,
      __shouldNotWarnDeprecated36pxSize: true,
      __next40pxDefaultSize: __next40pxDefaultSize,
      __unstableInputWidth: __unstableInputWidth,
      __unstableStateReducer: stateReducer,
      onChange: handleOnChange,
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Line height&#039;),
      placeholder: BASE_DEFAULT_VALUE,
      step: STEP,
      spinFactor: SPIN_FACTOR,
      value: value,
      min: 0,
      spinControls: &quot;custom&quot;
    })
  });
};

/**
 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/line-height-control/README.md
 */
/* harmony default export */ const line_height_control = (line_height_control_LineHeightControl);

;// ./node_modules/@wordpress/block-editor/build-module/components/letter-spacing-control/index.js
/**
 * WordPress dependencies
 */




/**
 * Internal dependencies
 */


/**
 * Control for letter-spacing.
 *
 * @param {Object}                  props                       Component props.
 * @param {boolean}                 props.__next40pxDefaultSize Start opting into the larger default height that will become the default size in a future version.
 * @param {string}                  props.value                 Currently selected letter-spacing.
 * @param {Function}                props.onChange              Handles change in letter-spacing selection.
 * @param {string|number|undefined} props.__unstableInputWidth  Input width to pass through to inner UnitControl. Should be a valid CSS value.
 *
 * @return {Element} Letter-spacing control.
 */

function LetterSpacingControl({
  __next40pxDefaultSize = false,
  value,
  onChange,
  __unstableInputWidth = &#039;60px&#039;,
  ...otherProps
}) {
  const [availableUnits] = use_settings_useSettings(&#039;spacing.units&#039;);
  const units = (0,external_wp_components_namespaceObject.__experimentalUseCustomUnits)({
    availableUnits: availableUnits || [&#039;px&#039;, &#039;em&#039;, &#039;rem&#039;],
    defaultValues: {
      px: 2,
      em: 0.2,
      rem: 0.2
    }
  });
  if (!__next40pxDefaultSize &amp;&amp; (otherProps.size === undefined || otherProps.size === &#039;default&#039;)) {
    external_wp_deprecated_default()(`36px default size for wp.blockEditor.__experimentalLetterSpacingControl`, {
      since: &#039;6.8&#039;,
      version: &#039;7.1&#039;,
      hint: &#039;Set the `__next40pxDefaultSize` prop to true to start opting into the new default size, which will become the default in a future version.&#039;
    });
  }
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalUnitControl, {
    __next40pxDefaultSize: __next40pxDefaultSize,
    __shouldNotWarnDeprecated36pxSize: true,
    ...otherProps,
    label: (0,external_wp_i18n_namespaceObject.__)(&#039;Letter spacing&#039;),
    value: value,
    __unstableInputWidth: __unstableInputWidth,
    units: units,
    onChange: onChange
  });
}

;// ./node_modules/@wordpress/icons/build-module/library/align-left.js
/**
 * WordPress dependencies
 */


const alignLeft = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;M13 5.5H4V4h9v1.5Zm7 7H4V11h16v1.5Zm-7 7H4V18h9v1.5Z&quot;
  })
});
/* harmony default export */ const align_left = (alignLeft);

;// ./node_modules/@wordpress/icons/build-module/library/align-center.js
/**
 * WordPress dependencies
 */


const alignCenter = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;M7.5 5.5h9V4h-9v1.5Zm-3.5 7h16V11H4v1.5Zm3.5 7h9V18h-9v1.5Z&quot;
  })
});
/* harmony default export */ const align_center = (alignCenter);

;// ./node_modules/@wordpress/icons/build-module/library/align-right.js
/**
 * WordPress dependencies
 */


const alignRight = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;M11.111 5.5H20V4h-8.889v1.5ZM4 12.5h16V11H4v1.5Zm7.111 7H20V18h-8.889v1.5Z&quot;
  })
});
/* harmony default export */ const align_right = (alignRight);

;// ./node_modules/@wordpress/icons/build-module/library/align-justify.js
/**
 * WordPress dependencies
 */


const alignJustify = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;M4 12.8h16v-1.5H4v1.5zm0 7h12.4v-1.5H4v1.5zM4 4.3v1.5h16V4.3H4z&quot;
  })
});
/* harmony default export */ const align_justify = (alignJustify);

;// ./node_modules/@wordpress/block-editor/build-module/components/text-alignment-control/index.js
/**
 * External dependencies
 */


/**
 * WordPress dependencies
 */





const TEXT_ALIGNMENT_OPTIONS = [{
  label: (0,external_wp_i18n_namespaceObject.__)(&#039;Align text left&#039;),
  value: &#039;left&#039;,
  icon: align_left
}, {
  label: (0,external_wp_i18n_namespaceObject.__)(&#039;Align text center&#039;),
  value: &#039;center&#039;,
  icon: align_center
}, {
  label: (0,external_wp_i18n_namespaceObject.__)(&#039;Align text right&#039;),
  value: &#039;right&#039;,
  icon: align_right
}, {
  label: (0,external_wp_i18n_namespaceObject.__)(&#039;Justify text&#039;),
  value: &#039;justify&#039;,
  icon: align_justify
}];
const DEFAULT_OPTIONS = [&#039;left&#039;, &#039;center&#039;, &#039;right&#039;];

/**
 * Control to facilitate text alignment selections.
 *
 * @param {Object}   props           Component props.
 * @param {string}   props.className Class name to add to the control.
 * @param {string}   props.value     Currently selected text alignment.
 * @param {Function} props.onChange  Handles change in text alignment selection.
 * @param {string[]} props.options   Array of text alignment options to display.
 *
 * @return {Element} Text alignment control.
 */
function TextAlignmentControl({
  className,
  value,
  onChange,
  options = DEFAULT_OPTIONS
}) {
  const validOptions = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; TEXT_ALIGNMENT_OPTIONS.filter(option =&gt; options.includes(option.value)), [options]);
  if (!validOptions.length) {
    return null;
  }
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControl, {
    isDeselectable: true,
    __nextHasNoMarginBottom: true,
    __next40pxDefaultSize: true,
    label: (0,external_wp_i18n_namespaceObject.__)(&#039;Text alignment&#039;),
    className: dist_clsx(&#039;block-editor-text-alignment-control&#039;, className),
    value: value,
    onChange: newValue =&gt; {
      onChange(newValue === value ? undefined : newValue);
    },
    children: validOptions.map(option =&gt; {
      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControlOptionIcon, {
        value: option.value,
        icon: option.icon,
        label: option.label
      }, option.value);
    })
  });
}

;// ./node_modules/@wordpress/icons/build-module/library/format-uppercase.js
/**
 * WordPress dependencies
 */


const formatUppercase = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;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&quot;
  })
});
/* harmony default export */ const format_uppercase = (formatUppercase);

;// ./node_modules/@wordpress/icons/build-module/library/format-lowercase.js
/**
 * WordPress dependencies
 */


const formatLowercase = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;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&quot;
  })
});
/* harmony default export */ const format_lowercase = (formatLowercase);

;// ./node_modules/@wordpress/icons/build-module/library/format-capitalize.js
/**
 * WordPress dependencies
 */


const formatCapitalize = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;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&quot;
  })
});
/* harmony default export */ const format_capitalize = (formatCapitalize);

;// ./node_modules/@wordpress/block-editor/build-module/components/text-transform-control/index.js
/**
 * External dependencies
 */


/**
 * WordPress dependencies
 */




const TEXT_TRANSFORMS = [{
  label: (0,external_wp_i18n_namespaceObject.__)(&#039;None&#039;),
  value: &#039;none&#039;,
  icon: library_reset
}, {
  label: (0,external_wp_i18n_namespaceObject.__)(&#039;Uppercase&#039;),
  value: &#039;uppercase&#039;,
  icon: format_uppercase
}, {
  label: (0,external_wp_i18n_namespaceObject.__)(&#039;Lowercase&#039;),
  value: &#039;lowercase&#039;,
  icon: format_lowercase
}, {
  label: (0,external_wp_i18n_namespaceObject.__)(&#039;Capitalize&#039;),
  value: &#039;capitalize&#039;,
  icon: format_capitalize
}];

/**
 * Control to facilitate text transform selections.
 *
 * @param {Object}   props           Component props.
 * @param {string}   props.className Class name to add to the control.
 * @param {string}   props.value     Currently selected text transform.
 * @param {Function} props.onChange  Handles change in text transform selection.
 *
 * @return {Element} Text transform control.
 */
function TextTransformControl({
  className,
  value,
  onChange
}) {
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControl, {
    isDeselectable: true,
    __nextHasNoMarginBottom: true,
    __next40pxDefaultSize: true,
    label: (0,external_wp_i18n_namespaceObject.__)(&#039;Letter case&#039;),
    className: dist_clsx(&#039;block-editor-text-transform-control&#039;, className),
    value: value,
    onChange: newValue =&gt; {
      onChange(newValue === value ? undefined : newValue);
    },
    children: TEXT_TRANSFORMS.map(option =&gt; {
      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControlOptionIcon, {
        value: option.value,
        icon: option.icon,
        label: option.label
      }, option.value);
    })
  });
}

;// ./node_modules/@wordpress/icons/build-module/library/format-underline.js
/**
 * WordPress dependencies
 */


const formatUnderline = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;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&quot;
  })
});
/* harmony default export */ const format_underline = (formatUnderline);

;// ./node_modules/@wordpress/icons/build-module/library/format-strikethrough.js
/**
 * WordPress dependencies
 */


const formatStrikethrough = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;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&quot;
  })
});
/* harmony default export */ const format_strikethrough = (formatStrikethrough);

;// ./node_modules/@wordpress/block-editor/build-module/components/text-decoration-control/index.js
/**
 * External dependencies
 */


/**
 * WordPress dependencies
 */




const TEXT_DECORATIONS = [{
  label: (0,external_wp_i18n_namespaceObject.__)(&#039;None&#039;),
  value: &#039;none&#039;,
  icon: library_reset
}, {
  label: (0,external_wp_i18n_namespaceObject.__)(&#039;Underline&#039;),
  value: &#039;underline&#039;,
  icon: format_underline
}, {
  label: (0,external_wp_i18n_namespaceObject.__)(&#039;Strikethrough&#039;),
  value: &#039;line-through&#039;,
  icon: format_strikethrough
}];

/**
 * Control to facilitate text decoration selections.
 *
 * @param {Object}   props           Component props.
 * @param {string}   props.value     Currently selected text decoration.
 * @param {Function} props.onChange  Handles change in text decoration selection.
 * @param {string}   props.className Additional class name to apply.
 *
 * @return {Element} Text decoration control.
 */
function TextDecorationControl({
  value,
  onChange,
  className
}) {
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControl, {
    isDeselectable: true,
    __nextHasNoMarginBottom: true,
    __next40pxDefaultSize: true,
    label: (0,external_wp_i18n_namespaceObject.__)(&#039;Decoration&#039;),
    className: dist_clsx(&#039;block-editor-text-decoration-control&#039;, className),
    value: value,
    onChange: newValue =&gt; {
      onChange(newValue === value ? undefined : newValue);
    },
    children: TEXT_DECORATIONS.map(option =&gt; {
      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControlOptionIcon, {
        value: option.value,
        icon: option.icon,
        label: option.label
      }, option.value);
    })
  });
}

;// ./node_modules/@wordpress/icons/build-module/library/text-horizontal.js
/**
 * WordPress dependencies
 */


const textHorizontal = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;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&quot;
  })
});
/* harmony default export */ const text_horizontal = (textHorizontal);

;// ./node_modules/@wordpress/icons/build-module/library/text-vertical.js
/**
 * WordPress dependencies
 */


const textVertical = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;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&quot;
  })
});
/* harmony default export */ const text_vertical = (textVertical);

;// ./node_modules/@wordpress/block-editor/build-module/components/writing-mode-control/index.js
/**
 * External dependencies
 */


/**
 * WordPress dependencies
 */




const WRITING_MODES = [{
  label: (0,external_wp_i18n_namespaceObject.__)(&#039;Horizontal&#039;),
  value: &#039;horizontal-tb&#039;,
  icon: text_horizontal
}, {
  label: (0,external_wp_i18n_namespaceObject.__)(&#039;Vertical&#039;),
  value: (0,external_wp_i18n_namespaceObject.isRTL)() ? &#039;vertical-lr&#039; : &#039;vertical-rl&#039;,
  icon: text_vertical
}];

/**
 * Control to facilitate writing mode selections.
 *
 * @param {Object}   props           Component props.
 * @param {string}   props.className Class name to add to the control.
 * @param {string}   props.value     Currently selected writing mode.
 * @param {Function} props.onChange  Handles change in the writing mode selection.
 *
 * @return {Element} Writing Mode control.
 */
function WritingModeControl({
  className,
  value,
  onChange
}) {
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControl, {
    isDeselectable: true,
    __nextHasNoMarginBottom: true,
    __next40pxDefaultSize: true,
    label: (0,external_wp_i18n_namespaceObject.__)(&#039;Orientation&#039;),
    className: dist_clsx(&#039;block-editor-writing-mode-control&#039;, className),
    value: value,
    onChange: newValue =&gt; {
      onChange(newValue === value ? undefined : newValue);
    },
    children: WRITING_MODES.map(option =&gt; {
      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControlOptionIcon, {
        value: option.value,
        icon: option.icon,
        label: option.label
      }, option.value);
    })
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/global-styles/typography-panel.js
/**
 * WordPress dependencies
 */




/**
 * Internal dependencies
 */












const MIN_TEXT_COLUMNS = 1;
const MAX_TEXT_COLUMNS = 6;
function useHasTypographyPanel(settings) {
  const hasFontFamily = useHasFontFamilyControl(settings);
  const hasLineHeight = useHasLineHeightControl(settings);
  const hasFontAppearance = useHasAppearanceControl(settings);
  const hasLetterSpacing = useHasLetterSpacingControl(settings);
  const hasTextAlign = useHasTextAlignmentControl(settings);
  const hasTextTransform = useHasTextTransformControl(settings);
  const hasTextDecoration = useHasTextDecorationControl(settings);
  const hasWritingMode = useHasWritingModeControl(settings);
  const hasTextColumns = useHasTextColumnsControl(settings);
  const hasFontSize = useHasFontSizeControl(settings);
  return hasFontFamily || hasLineHeight || hasFontAppearance || hasLetterSpacing || hasTextAlign || hasTextTransform || hasFontSize || hasTextDecoration || hasWritingMode || hasTextColumns;
}
function useHasFontSizeControl(settings) {
  return settings?.typography?.defaultFontSizes !== false &amp;&amp; settings?.typography?.fontSizes?.default?.length || settings?.typography?.fontSizes?.theme?.length || settings?.typography?.fontSizes?.custom?.length || settings?.typography?.customFontSize;
}
function useHasFontFamilyControl(settings) {
  return [&#039;default&#039;, &#039;theme&#039;, &#039;custom&#039;].some(key =&gt; settings?.typography?.fontFamilies?.[key]?.length);
}
function useHasLineHeightControl(settings) {
  return settings?.typography?.lineHeight;
}
function useHasAppearanceControl(settings) {
  return settings?.typography?.fontStyle || settings?.typography?.fontWeight;
}
function useAppearanceControlLabel(settings) {
  if (!settings?.typography?.fontStyle) {
    return (0,external_wp_i18n_namespaceObject.__)(&#039;Font weight&#039;);
  }
  if (!settings?.typography?.fontWeight) {
    return (0,external_wp_i18n_namespaceObject.__)(&#039;Font style&#039;);
  }
  return (0,external_wp_i18n_namespaceObject.__)(&#039;Appearance&#039;);
}
function useHasLetterSpacingControl(settings) {
  return settings?.typography?.letterSpacing;
}
function useHasTextTransformControl(settings) {
  return settings?.typography?.textTransform;
}
function useHasTextAlignmentControl(settings) {
  return settings?.typography?.textAlign;
}
function useHasTextDecorationControl(settings) {
  return settings?.typography?.textDecoration;
}
function useHasWritingModeControl(settings) {
  return settings?.typography?.writingMode;
}
function useHasTextColumnsControl(settings) {
  return settings?.typography?.textColumns;
}

/**
 * Concatenate all the font sizes into a single list for the font size picker.
 *
 * @param {Object} settings The global styles settings.
 *
 * @return {Array} The merged font sizes.
 */
function getMergedFontSizes(settings) {
  var _fontSizes$custom, _fontSizes$theme, _fontSizes$default;
  const fontSizes = settings?.typography?.fontSizes;
  const defaultFontSizesEnabled = !!settings?.typography?.defaultFontSizes;
  return [...((_fontSizes$custom = fontSizes?.custom) !== null &amp;&amp; _fontSizes$custom !== void 0 ? _fontSizes$custom : []), ...((_fontSizes$theme = fontSizes?.theme) !== null &amp;&amp; _fontSizes$theme !== void 0 ? _fontSizes$theme : []), ...(defaultFontSizesEnabled ? (_fontSizes$default = fontSizes?.default) !== null &amp;&amp; _fontSizes$default !== void 0 ? _fontSizes$default : [] : [])];
}
function TypographyToolsPanel({
  resetAllFilter,
  onChange,
  value,
  panelId,
  children
}) {
  const dropdownMenuProps = useToolsPanelDropdownMenuProps();
  const resetAll = () =&gt; {
    const updatedValue = resetAllFilter(value);
    onChange(updatedValue);
  };
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanel, {
    label: (0,external_wp_i18n_namespaceObject.__)(&#039;Typography&#039;),
    resetAll: resetAll,
    panelId: panelId,
    dropdownMenuProps: dropdownMenuProps,
    children: children
  });
}
const typography_panel_DEFAULT_CONTROLS = {
  fontFamily: true,
  fontSize: true,
  fontAppearance: true,
  lineHeight: true,
  letterSpacing: true,
  textAlign: true,
  textTransform: true,
  textDecoration: true,
  writingMode: true,
  textColumns: true
};
function TypographyPanel({
  as: Wrapper = TypographyToolsPanel,
  value,
  onChange,
  inheritedValue = value,
  settings,
  panelId,
  defaultControls = typography_panel_DEFAULT_CONTROLS
}) {
  const decodeValue = rawValue =&gt; getValueFromVariable({
    settings
  }, &#039;&#039;, rawValue);

  // Font Family
  const hasFontFamilyEnabled = useHasFontFamilyControl(settings);
  const fontFamily = decodeValue(inheritedValue?.typography?.fontFamily);
  const {
    fontFamilies,
    fontFamilyFaces
  } = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; {
    return getMergedFontFamiliesAndFontFamilyFaces(settings, fontFamily);
  }, [settings, fontFamily]);
  const setFontFamily = newValue =&gt; {
    const slug = fontFamilies?.find(({
      fontFamily: f
    }) =&gt; f === newValue)?.slug;
    onChange(setImmutably(value, [&#039;typography&#039;, &#039;fontFamily&#039;], slug ? `var:preset|font-family|${slug}` : newValue || undefined));
  };
  const hasFontFamily = () =&gt; !!value?.typography?.fontFamily;
  const resetFontFamily = () =&gt; setFontFamily(undefined);

  // Font Size
  const hasFontSizeEnabled = useHasFontSizeControl(settings);
  const disableCustomFontSizes = !settings?.typography?.customFontSize;
  const mergedFontSizes = getMergedFontSizes(settings);
  const fontSize = decodeValue(inheritedValue?.typography?.fontSize);
  const setFontSize = (newValue, metadata) =&gt; {
    const actualValue = !!metadata?.slug ? `var:preset|font-size|${metadata?.slug}` : newValue;
    onChange(setImmutably(value, [&#039;typography&#039;, &#039;fontSize&#039;], actualValue || undefined));
  };
  const hasFontSize = () =&gt; !!value?.typography?.fontSize;
  const resetFontSize = () =&gt; setFontSize(undefined);

  // Appearance
  const hasAppearanceControl = useHasAppearanceControl(settings);
  const appearanceControlLabel = useAppearanceControlLabel(settings);
  const hasFontStyles = settings?.typography?.fontStyle;
  const hasFontWeights = settings?.typography?.fontWeight;
  const fontStyle = decodeValue(inheritedValue?.typography?.fontStyle);
  const fontWeight = decodeValue(inheritedValue?.typography?.fontWeight);
  const {
    nearestFontStyle,
    nearestFontWeight
  } = findNearestStyleAndWeight(fontFamilyFaces, fontStyle, fontWeight);
  const setFontAppearance = (0,external_wp_element_namespaceObject.useCallback)(({
    fontStyle: newFontStyle,
    fontWeight: newFontWeight
  }) =&gt; {
    // Only update the font style and weight if they have changed.
    if (newFontStyle !== fontStyle || newFontWeight !== fontWeight) {
      onChange({
        ...value,
        typography: {
          ...value?.typography,
          fontStyle: newFontStyle || undefined,
          fontWeight: newFontWeight || undefined
        }
      });
    }
  }, [fontStyle, fontWeight, onChange, value]);
  const hasFontAppearance = () =&gt; !!value?.typography?.fontStyle || !!value?.typography?.fontWeight;
  const resetFontAppearance = (0,external_wp_element_namespaceObject.useCallback)(() =&gt; {
    setFontAppearance({});
  }, [setFontAppearance]);

  // Check if previous font style and weight values are available in the new font family.
  (0,external_wp_element_namespaceObject.useEffect)(() =&gt; {
    if (nearestFontStyle &amp;&amp; nearestFontWeight) {
      setFontAppearance({
        fontStyle: nearestFontStyle,
        fontWeight: nearestFontWeight
      });
    } else {
      // Reset font appearance if there are no available styles or weights.
      resetFontAppearance();
    }
  }, [nearestFontStyle, nearestFontWeight, resetFontAppearance, setFontAppearance]);

  // Line Height
  const hasLineHeightEnabled = useHasLineHeightControl(settings);
  const lineHeight = decodeValue(inheritedValue?.typography?.lineHeight);
  const setLineHeight = newValue =&gt; {
    onChange(setImmutably(value, [&#039;typography&#039;, &#039;lineHeight&#039;], newValue || undefined));
  };
  const hasLineHeight = () =&gt; value?.typography?.lineHeight !== undefined;
  const resetLineHeight = () =&gt; setLineHeight(undefined);

  // Letter Spacing
  const hasLetterSpacingControl = useHasLetterSpacingControl(settings);
  const letterSpacing = decodeValue(inheritedValue?.typography?.letterSpacing);
  const setLetterSpacing = newValue =&gt; {
    onChange(setImmutably(value, [&#039;typography&#039;, &#039;letterSpacing&#039;], newValue || undefined));
  };
  const hasLetterSpacing = () =&gt; !!value?.typography?.letterSpacing;
  const resetLetterSpacing = () =&gt; setLetterSpacing(undefined);

  // Text Columns
  const hasTextColumnsControl = useHasTextColumnsControl(settings);
  const textColumns = decodeValue(inheritedValue?.typography?.textColumns);
  const setTextColumns = newValue =&gt; {
    onChange(setImmutably(value, [&#039;typography&#039;, &#039;textColumns&#039;], newValue || undefined));
  };
  const hasTextColumns = () =&gt; !!value?.typography?.textColumns;
  const resetTextColumns = () =&gt; setTextColumns(undefined);

  // Text Transform
  const hasTextTransformControl = useHasTextTransformControl(settings);
  const textTransform = decodeValue(inheritedValue?.typography?.textTransform);
  const setTextTransform = newValue =&gt; {
    onChange(setImmutably(value, [&#039;typography&#039;, &#039;textTransform&#039;], newValue || undefined));
  };
  const hasTextTransform = () =&gt; !!value?.typography?.textTransform;
  const resetTextTransform = () =&gt; setTextTransform(undefined);

  // Text Decoration
  const hasTextDecorationControl = useHasTextDecorationControl(settings);
  const textDecoration = decodeValue(inheritedValue?.typography?.textDecoration);
  const setTextDecoration = newValue =&gt; {
    onChange(setImmutably(value, [&#039;typography&#039;, &#039;textDecoration&#039;], newValue || undefined));
  };
  const hasTextDecoration = () =&gt; !!value?.typography?.textDecoration;
  const resetTextDecoration = () =&gt; setTextDecoration(undefined);

  // Text Orientation
  const hasWritingModeControl = useHasWritingModeControl(settings);
  const writingMode = decodeValue(inheritedValue?.typography?.writingMode);
  const setWritingMode = newValue =&gt; {
    onChange(setImmutably(value, [&#039;typography&#039;, &#039;writingMode&#039;], newValue || undefined));
  };
  const hasWritingMode = () =&gt; !!value?.typography?.writingMode;
  const resetWritingMode = () =&gt; setWritingMode(undefined);

  // Text Alignment
  const hasTextAlignmentControl = useHasTextAlignmentControl(settings);
  const textAlign = decodeValue(inheritedValue?.typography?.textAlign);
  const setTextAlign = newValue =&gt; {
    onChange(setImmutably(value, [&#039;typography&#039;, &#039;textAlign&#039;], newValue || undefined));
  };
  const hasTextAlign = () =&gt; !!value?.typography?.textAlign;
  const resetTextAlign = () =&gt; setTextAlign(undefined);
  const resetAllFilter = (0,external_wp_element_namespaceObject.useCallback)(previousValue =&gt; {
    return {
      ...previousValue,
      typography: {}
    };
  }, []);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(Wrapper, {
    resetAllFilter: resetAllFilter,
    value: value,
    onChange: onChange,
    panelId: panelId,
    children: [hasFontFamilyEnabled &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanelItem, {
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Font&#039;),
      hasValue: hasFontFamily,
      onDeselect: resetFontFamily,
      isShownByDefault: defaultControls.fontFamily,
      panelId: panelId,
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(FontFamilyControl, {
        fontFamilies: fontFamilies,
        value: fontFamily,
        onChange: setFontFamily,
        size: &quot;__unstable-large&quot;,
        __nextHasNoMarginBottom: true
      })
    }), hasFontSizeEnabled &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanelItem, {
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Size&#039;),
      hasValue: hasFontSize,
      onDeselect: resetFontSize,
      isShownByDefault: defaultControls.fontSize,
      panelId: panelId,
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FontSizePicker, {
        value: fontSize,
        onChange: setFontSize,
        fontSizes: mergedFontSizes,
        disableCustomFontSizes: disableCustomFontSizes,
        withReset: false,
        withSlider: true,
        size: &quot;__unstable-large&quot;
      })
    }), hasAppearanceControl &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanelItem, {
      className: &quot;single-column&quot;,
      label: appearanceControlLabel,
      hasValue: hasFontAppearance,
      onDeselect: resetFontAppearance,
      isShownByDefault: defaultControls.fontAppearance,
      panelId: panelId,
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(FontAppearanceControl, {
        value: {
          fontStyle,
          fontWeight
        },
        onChange: setFontAppearance,
        hasFontStyles: hasFontStyles,
        hasFontWeights: hasFontWeights,
        fontFamilyFaces: fontFamilyFaces,
        size: &quot;__unstable-large&quot;
      })
    }), hasLineHeightEnabled &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanelItem, {
      className: &quot;single-column&quot;,
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Line height&#039;),
      hasValue: hasLineHeight,
      onDeselect: resetLineHeight,
      isShownByDefault: defaultControls.lineHeight,
      panelId: panelId,
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(line_height_control, {
        __unstableInputWidth: &quot;auto&quot;,
        value: lineHeight,
        onChange: setLineHeight,
        size: &quot;__unstable-large&quot;
      })
    }), hasLetterSpacingControl &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanelItem, {
      className: &quot;single-column&quot;,
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Letter spacing&#039;),
      hasValue: hasLetterSpacing,
      onDeselect: resetLetterSpacing,
      isShownByDefault: defaultControls.letterSpacing,
      panelId: panelId,
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(LetterSpacingControl, {
        value: letterSpacing,
        onChange: setLetterSpacing,
        size: &quot;__unstable-large&quot;,
        __unstableInputWidth: &quot;auto&quot;
      })
    }), hasTextColumnsControl &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanelItem, {
      className: &quot;single-column&quot;,
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Columns&#039;),
      hasValue: hasTextColumns,
      onDeselect: resetTextColumns,
      isShownByDefault: defaultControls.textColumns,
      panelId: panelId,
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalNumberControl, {
        label: (0,external_wp_i18n_namespaceObject.__)(&#039;Columns&#039;),
        max: MAX_TEXT_COLUMNS,
        min: MIN_TEXT_COLUMNS,
        onChange: setTextColumns,
        size: &quot;__unstable-large&quot;,
        spinControls: &quot;custom&quot;,
        value: textColumns,
        initialPosition: 1
      })
    }), hasTextDecorationControl &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanelItem, {
      className: &quot;single-column&quot;,
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Decoration&#039;),
      hasValue: hasTextDecoration,
      onDeselect: resetTextDecoration,
      isShownByDefault: defaultControls.textDecoration,
      panelId: panelId,
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(TextDecorationControl, {
        value: textDecoration,
        onChange: setTextDecoration,
        size: &quot;__unstable-large&quot;,
        __unstableInputWidth: &quot;auto&quot;
      })
    }), hasWritingModeControl &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanelItem, {
      className: &quot;single-column&quot;,
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Orientation&#039;),
      hasValue: hasWritingMode,
      onDeselect: resetWritingMode,
      isShownByDefault: defaultControls.writingMode,
      panelId: panelId,
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(WritingModeControl, {
        value: writingMode,
        onChange: setWritingMode,
        size: &quot;__unstable-large&quot;,
        __nextHasNoMarginBottom: true
      })
    }), hasTextTransformControl &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanelItem, {
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Letter case&#039;),
      hasValue: hasTextTransform,
      onDeselect: resetTextTransform,
      isShownByDefault: defaultControls.textTransform,
      panelId: panelId,
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(TextTransformControl, {
        value: textTransform,
        onChange: setTextTransform,
        showNone: true,
        isBlock: true,
        size: &quot;__unstable-large&quot;,
        __nextHasNoMarginBottom: true
      })
    }), hasTextAlignmentControl &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanelItem, {
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Text alignment&#039;),
      hasValue: hasTextAlign,
      onDeselect: resetTextAlign,
      isShownByDefault: defaultControls.textAlign,
      panelId: panelId,
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(TextAlignmentControl, {
        value: textAlign,
        onChange: setTextAlign,
        size: &quot;__unstable-large&quot;,
        __nextHasNoMarginBottom: true
      })
    })]
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/hooks/line-height.js
/**
 * WordPress dependencies
 */


/**
 * Internal dependencies
 */




const LINE_HEIGHT_SUPPORT_KEY = &#039;typography.lineHeight&#039;;

/**
 * Inspector control panel containing the line height related configuration
 *
 * @param {Object} props
 *
 * @return {Element} Line height edit element.
 */
function LineHeightEdit(props) {
  const {
    attributes: {
      style
    },
    setAttributes
  } = props;
  const onChange = newLineHeightValue =&gt; {
    const newStyle = {
      ...style,
      typography: {
        ...style?.typography,
        lineHeight: newLineHeightValue
      }
    };
    setAttributes({
      style: cleanEmptyObject(newStyle)
    });
  };
  return /*#__PURE__*/_jsx(LineHeightControl, {
    __unstableInputWidth: &quot;100%&quot;,
    value: style?.typography?.lineHeight,
    onChange: onChange,
    size: &quot;__unstable-large&quot;
  });
}

/**
 * Custom hook that checks if line-height settings have been disabled.
 *
 * @param {string} name The name of the block.
 * @return {boolean} Whether setting is disabled.
 */
function useIsLineHeightDisabled({
  name: blockName
} = {}) {
  const [isEnabled] = useSettings(&#039;typography.lineHeight&#039;);
  return !isEnabled || !hasBlockSupport(blockName, LINE_HEIGHT_SUPPORT_KEY);
}

;// external [&quot;wp&quot;,&quot;tokenList&quot;]
const external_wp_tokenList_namespaceObject = window[&quot;wp&quot;][&quot;tokenList&quot;];
var external_wp_tokenList_default = /*#__PURE__*/__webpack_require__.n(external_wp_tokenList_namespaceObject);
;// ./node_modules/@wordpress/block-editor/build-module/hooks/font-family.js
/**
 * WordPress dependencies
 */





/**
 * Internal dependencies
 */



const FONT_FAMILY_SUPPORT_KEY = &#039;typography.__experimentalFontFamily&#039;;
const {
  kebabCase: font_family_kebabCase
} = unlock(external_wp_components_namespaceObject.privateApis);

/**
 * Filters registered block settings, extending attributes to include
 * the `fontFamily` attribute.
 *
 * @param {Object} settings Original block settings
 * @return {Object}         Filtered block settings
 */
function font_family_addAttributes(settings) {
  if (!(0,external_wp_blocks_namespaceObject.hasBlockSupport)(settings, FONT_FAMILY_SUPPORT_KEY)) {
    return settings;
  }

  // Allow blocks to specify a default value if needed.
  if (!settings.attributes.fontFamily) {
    Object.assign(settings.attributes, {
      fontFamily: {
        type: &#039;string&#039;
      }
    });
  }
  return settings;
}

/**
 * Override props assigned to save component to inject font family.
 *
 * @param {Object} props      Additional props applied to save element
 * @param {Object} blockType  Block type
 * @param {Object} attributes Block attributes
 * @return {Object}           Filtered props applied to save element
 */
function font_family_addSaveProps(props, blockType, attributes) {
  if (!(0,external_wp_blocks_namespaceObject.hasBlockSupport)(blockType, FONT_FAMILY_SUPPORT_KEY)) {
    return props;
  }
  if (shouldSkipSerialization(blockType, TYPOGRAPHY_SUPPORT_KEY, &#039;fontFamily&#039;)) {
    return props;
  }
  if (!attributes?.fontFamily) {
    return props;
  }

  // Use TokenList to dedupe classes.
  const classes = new (external_wp_tokenList_default())(props.className);
  classes.add(`has-${font_family_kebabCase(attributes?.fontFamily)}-font-family`);
  const newClassName = classes.value;
  props.className = newClassName ? newClassName : undefined;
  return props;
}
function font_family_useBlockProps({
  name,
  fontFamily
}) {
  return font_family_addSaveProps({}, name, {
    fontFamily
  });
}
/* harmony default export */ const font_family = ({
  useBlockProps: font_family_useBlockProps,
  addSaveProps: font_family_addSaveProps,
  attributeKeys: [&#039;fontFamily&#039;],
  hasSupport(name) {
    return (0,external_wp_blocks_namespaceObject.hasBlockSupport)(name, FONT_FAMILY_SUPPORT_KEY);
  }
});

/**
 * Resets the font family block support attribute. This can be used when
 * disabling the font family support controls for a block via a progressive
 * discovery panel.
 *
 * @param {Object} props               Block props.
 * @param {Object} props.setAttributes Function to set block&#039;s attributes.
 */
function resetFontFamily({
  setAttributes
}) {
  setAttributes({
    fontFamily: undefined
  });
}
(0,external_wp_hooks_namespaceObject.addFilter)(&#039;blocks.registerBlockType&#039;, &#039;core/fontFamily/addAttribute&#039;, font_family_addAttributes);

;// ./node_modules/@wordpress/block-editor/build-module/components/font-sizes/utils.js
/**
 * WordPress dependencies
 */


/**
 * Internal dependencies
 */

const {
  kebabCase: utils_kebabCase
} = unlock(external_wp_components_namespaceObject.privateApis);

/**
 *  Returns the font size object based on an array of named font sizes and the namedFontSize and customFontSize values.
 * 	If namedFontSize is undefined or not found in fontSizes an object with just the size value based on customFontSize is returned.
 *
 * @param {Array}   fontSizes               Array of font size objects containing at least the &quot;name&quot; and &quot;size&quot; values as properties.
 * @param {?string} fontSizeAttribute       Content of the font size attribute (slug).
 * @param {?number} customFontSizeAttribute Contents of the custom font size attribute (value).
 *
 * @return {?Object} If fontSizeAttribute is set and an equal slug is found in fontSizes it returns the font size object for that slug.
 * 					 Otherwise, an object with just the size value based on customFontSize is returned.
 */
const utils_getFontSize = (fontSizes, fontSizeAttribute, customFontSizeAttribute) =&gt; {
  if (fontSizeAttribute) {
    const fontSizeObject = fontSizes?.find(({
      slug
    }) =&gt; slug === fontSizeAttribute);
    if (fontSizeObject) {
      return fontSizeObject;
    }
  }
  return {
    size: customFontSizeAttribute
  };
};

/**
 * Returns the corresponding font size object for a given value.
 *
 * @param {Array}  fontSizes Array of font size objects.
 * @param {number} value     Font size value.
 *
 * @return {Object} Font size object.
 */
function utils_getFontSizeObjectByValue(fontSizes, value) {
  const fontSizeObject = fontSizes?.find(({
    size
  }) =&gt; size === value);
  if (fontSizeObject) {
    return fontSizeObject;
  }
  return {
    size: value
  };
}

/**
 * Returns a class based on fontSizeName.
 *
 * @param {string} fontSizeSlug Slug of the fontSize.
 *
 * @return {string | undefined} String with the class corresponding to the fontSize passed.
 *                  The class is generated by appending &#039;has-&#039; followed by fontSizeSlug in kebabCase and ending with &#039;-font-size&#039;.
 */
function getFontSizeClass(fontSizeSlug) {
  if (!fontSizeSlug) {
    return;
  }
  return `has-${utils_kebabCase(fontSizeSlug)}-font-size`;
}

;// ./node_modules/@wordpress/block-editor/build-module/hooks/font-size.js
/**
 * WordPress dependencies
 */




/**
 * Internal dependencies
 */






const FONT_SIZE_SUPPORT_KEY = &#039;typography.fontSize&#039;;

/**
 * Filters registered block settings, extending attributes to include
 * `fontSize` and `fontWeight` attributes.
 *
 * @param {Object} settings Original block settings.
 *
 * @return {Object} Filtered block settings.
 */
function font_size_addAttributes(settings) {
  if (!(0,external_wp_blocks_namespaceObject.hasBlockSupport)(settings, FONT_SIZE_SUPPORT_KEY)) {
    return settings;
  }

  // Allow blocks to specify a default value if needed.
  if (!settings.attributes.fontSize) {
    Object.assign(settings.attributes, {
      fontSize: {
        type: &#039;string&#039;
      }
    });
  }
  return settings;
}

/**
 * Override props assigned to save component to inject font size.
 *
 * @param {Object} props           Additional props applied to save element.
 * @param {Object} blockNameOrType Block type.
 * @param {Object} attributes      Block attributes.
 *
 * @return {Object} Filtered props applied to save element.
 */
function font_size_addSaveProps(props, blockNameOrType, attributes) {
  if (!(0,external_wp_blocks_namespaceObject.hasBlockSupport)(blockNameOrType, FONT_SIZE_SUPPORT_KEY)) {
    return props;
  }
  if (shouldSkipSerialization(blockNameOrType, TYPOGRAPHY_SUPPORT_KEY, &#039;fontSize&#039;)) {
    return props;
  }

  // Use TokenList to dedupe classes.
  const classes = new (external_wp_tokenList_default())(props.className);
  classes.add(getFontSizeClass(attributes.fontSize));
  const newClassName = classes.value;
  props.className = newClassName ? newClassName : undefined;
  return props;
}

/**
 * Inspector control panel containing the font size related configuration
 *
 * @param {Object} props
 *
 * @return {Element} Font size edit element.
 */
function FontSizeEdit(props) {
  const {
    attributes: {
      fontSize,
      style
    },
    setAttributes
  } = props;
  const [fontSizes] = useSettings(&#039;typography.fontSizes&#039;);
  const onChange = value =&gt; {
    const fontSizeSlug = getFontSizeObjectByValue(fontSizes, value).slug;
    setAttributes({
      style: cleanEmptyObject({
        ...style,
        typography: {
          ...style?.typography,
          fontSize: fontSizeSlug ? undefined : value
        }
      }),
      fontSize: fontSizeSlug
    });
  };
  const fontSizeObject = getFontSize(fontSizes, fontSize, style?.typography?.fontSize);
  const fontSizeValue = fontSizeObject?.size || style?.typography?.fontSize || fontSize;
  return /*#__PURE__*/_jsx(FontSizePicker, {
    onChange: onChange,
    value: fontSizeValue,
    withReset: false,
    withSlider: true,
    size: &quot;__unstable-large&quot;
  });
}

/**
 * Custom hook that checks if font-size settings have been disabled.
 *
 * @param {string} name The name of the block.
 * @return {boolean} Whether setting is disabled.
 */
function useIsFontSizeDisabled({
  name: blockName
} = {}) {
  const [fontSizes] = useSettings(&#039;typography.fontSizes&#039;);
  const hasFontSizes = !!fontSizes?.length;
  return !hasBlockSupport(blockName, FONT_SIZE_SUPPORT_KEY) || !hasFontSizes;
}
function font_size_useBlockProps({
  name,
  fontSize,
  style
}) {
  const [fontSizes, fluidTypographySettings, layoutSettings] = use_settings_useSettings(&#039;typography.fontSizes&#039;, &#039;typography.fluid&#039;, &#039;layout&#039;);

  /*
   * Only add inline styles if the block supports font sizes,
   * doesn&#039;t skip serialization of font sizes,
   * and has either a custom font size or a preset font size.
   */
  if (!(0,external_wp_blocks_namespaceObject.hasBlockSupport)(name, FONT_SIZE_SUPPORT_KEY) || shouldSkipSerialization(name, TYPOGRAPHY_SUPPORT_KEY, &#039;fontSize&#039;) || !fontSize &amp;&amp; !style?.typography?.fontSize) {
    return;
  }
  let props;
  if (style?.typography?.fontSize) {
    props = {
      style: {
        fontSize: getTypographyFontSizeValue({
          size: style.typography.fontSize
        }, {
          typography: {
            fluid: fluidTypographySettings
          },
          layout: layoutSettings
        })
      }
    };
  }
  if (fontSize) {
    props = {
      style: {
        fontSize: utils_getFontSize(fontSizes, fontSize, style?.typography?.fontSize).size
      }
    };
  }
  if (!props) {
    return;
  }
  return font_size_addSaveProps(props, name, {
    fontSize
  });
}
/* harmony default export */ const font_size = ({
  useBlockProps: font_size_useBlockProps,
  addSaveProps: font_size_addSaveProps,
  attributeKeys: [&#039;fontSize&#039;, &#039;style&#039;],
  hasSupport(name) {
    return (0,external_wp_blocks_namespaceObject.hasBlockSupport)(name, FONT_SIZE_SUPPORT_KEY);
  }
});
const font_size_MIGRATION_PATHS = {
  fontSize: [[&#039;fontSize&#039;], [&#039;style&#039;, &#039;typography&#039;, &#039;fontSize&#039;]]
};
function font_size_addTransforms(result, source, index, results) {
  const destinationBlockType = result.name;
  const activeSupports = {
    fontSize: (0,external_wp_blocks_namespaceObject.hasBlockSupport)(destinationBlockType, FONT_SIZE_SUPPORT_KEY)
  };
  return transformStyles(activeSupports, font_size_MIGRATION_PATHS, result, source, index, results);
}
(0,external_wp_hooks_namespaceObject.addFilter)(&#039;blocks.registerBlockType&#039;, &#039;core/font/addAttribute&#039;, font_size_addAttributes);
(0,external_wp_hooks_namespaceObject.addFilter)(&#039;blocks.switchToBlockType.transformedBlock&#039;, &#039;core/font-size/addTransforms&#039;, font_size_addTransforms);

;// ./node_modules/@wordpress/block-editor/build-module/components/alignment-control/ui.js
/**
 * WordPress dependencies
 */




const DEFAULT_ALIGNMENT_CONTROLS = [{
  icon: align_left,
  title: (0,external_wp_i18n_namespaceObject.__)(&#039;Align text left&#039;),
  align: &#039;left&#039;
}, {
  icon: align_center,
  title: (0,external_wp_i18n_namespaceObject.__)(&#039;Align text center&#039;),
  align: &#039;center&#039;
}, {
  icon: align_right,
  title: (0,external_wp_i18n_namespaceObject.__)(&#039;Align text right&#039;),
  align: &#039;right&#039;
}];
const ui_POPOVER_PROPS = {
  placement: &#039;bottom-start&#039;
};
function AlignmentUI({
  value,
  onChange,
  alignmentControls = DEFAULT_ALIGNMENT_CONTROLS,
  label = (0,external_wp_i18n_namespaceObject.__)(&#039;Align text&#039;),
  description = (0,external_wp_i18n_namespaceObject.__)(&#039;Change text alignment&#039;),
  isCollapsed = true,
  isToolbar
}) {
  function applyOrUnset(align) {
    return () =&gt; onChange(value === align ? undefined : align);
  }
  const activeAlignment = alignmentControls.find(control =&gt; control.align === value);
  function setIcon() {
    if (activeAlignment) {
      return activeAlignment.icon;
    }
    return (0,external_wp_i18n_namespaceObject.isRTL)() ? align_right : align_left;
  }
  const UIComponent = isToolbar ? external_wp_components_namespaceObject.ToolbarGroup : external_wp_components_namespaceObject.ToolbarDropdownMenu;
  const extraProps = isToolbar ? {
    isCollapsed
  } : {
    toggleProps: {
      description
    },
    popoverProps: ui_POPOVER_PROPS
  };
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(UIComponent, {
    icon: setIcon(),
    label: label,
    controls: alignmentControls.map(control =&gt; {
      const {
        align
      } = control;
      const isActive = value === align;
      return {
        ...control,
        isActive,
        role: isCollapsed ? &#039;menuitemradio&#039; : undefined,
        onClick: applyOrUnset(align)
      };
    }),
    ...extraProps
  });
}
/* harmony default export */ const alignment_control_ui = (AlignmentUI);

;// ./node_modules/@wordpress/block-editor/build-module/components/alignment-control/index.js
/**
 * Internal dependencies
 */


const AlignmentControl = props =&gt; {
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(alignment_control_ui, {
    ...props,
    isToolbar: false
  });
};
const AlignmentToolbar = props =&gt; {
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(alignment_control_ui, {
    ...props,
    isToolbar: true
  });
};

/**
 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/alignment-control/README.md
 */


;// ./node_modules/@wordpress/block-editor/build-module/hooks/text-align.js
/**
 * External dependencies
 */


/**
 * WordPress dependencies
 */




/**
 * Internal dependencies
 */





const TEXT_ALIGN_SUPPORT_KEY = &#039;typography.textAlign&#039;;
const text_align_TEXT_ALIGNMENT_OPTIONS = [{
  icon: align_left,
  title: (0,external_wp_i18n_namespaceObject.__)(&#039;Align text left&#039;),
  align: &#039;left&#039;
}, {
  icon: align_center,
  title: (0,external_wp_i18n_namespaceObject.__)(&#039;Align text center&#039;),
  align: &#039;center&#039;
}, {
  icon: align_right,
  title: (0,external_wp_i18n_namespaceObject.__)(&#039;Align text right&#039;),
  align: &#039;right&#039;
}];
const VALID_TEXT_ALIGNMENTS = [&#039;left&#039;, &#039;center&#039;, &#039;right&#039;];
const NO_TEXT_ALIGNMENTS = [];

/**
 * Returns the valid text alignments.
 * Takes into consideration the text aligns supported by a block.
 * Exported just for testing purposes, not exported outside the module.
 *
 * @param {?boolean|string[]} blockTextAlign Text aligns supported by the block.
 *
 * @return {string[]} Valid text alignments.
 */
function getValidTextAlignments(blockTextAlign) {
  if (Array.isArray(blockTextAlign)) {
    return VALID_TEXT_ALIGNMENTS.filter(textAlign =&gt; blockTextAlign.includes(textAlign));
  }
  return blockTextAlign === true ? VALID_TEXT_ALIGNMENTS : NO_TEXT_ALIGNMENTS;
}
function BlockEditTextAlignmentToolbarControlsPure({
  style,
  name: blockName,
  setAttributes
}) {
  const settings = useBlockSettings(blockName);
  const hasTextAlignControl = settings?.typography?.textAlign;
  const blockEditingMode = useBlockEditingMode();
  if (!hasTextAlignControl || blockEditingMode !== &#039;default&#039;) {
    return null;
  }
  const validTextAlignments = getValidTextAlignments((0,external_wp_blocks_namespaceObject.getBlockSupport)(blockName, TEXT_ALIGN_SUPPORT_KEY));
  if (!validTextAlignments.length) {
    return null;
  }
  const textAlignmentControls = text_align_TEXT_ALIGNMENT_OPTIONS.filter(control =&gt; validTextAlignments.includes(control.align));
  const onChange = newTextAlignValue =&gt; {
    const newStyle = {
      ...style,
      typography: {
        ...style?.typography,
        textAlign: newTextAlignValue
      }
    };
    setAttributes({
      style: utils_cleanEmptyObject(newStyle)
    });
  };
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_controls, {
    group: &quot;block&quot;,
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(AlignmentControl, {
      value: style?.typography?.textAlign,
      onChange: onChange,
      alignmentControls: textAlignmentControls
    })
  });
}
/* harmony default export */ const text_align = ({
  edit: BlockEditTextAlignmentToolbarControlsPure,
  useBlockProps: text_align_useBlockProps,
  addSaveProps: addAssignedTextAlign,
  attributeKeys: [&#039;style&#039;],
  hasSupport(name) {
    return (0,external_wp_blocks_namespaceObject.hasBlockSupport)(name, TEXT_ALIGN_SUPPORT_KEY, false);
  }
});
function text_align_useBlockProps({
  name,
  style
}) {
  if (!style?.typography?.textAlign) {
    return null;
  }
  const validTextAlignments = getValidTextAlignments((0,external_wp_blocks_namespaceObject.getBlockSupport)(name, TEXT_ALIGN_SUPPORT_KEY));
  if (!validTextAlignments.length) {
    return null;
  }
  if (shouldSkipSerialization(name, TYPOGRAPHY_SUPPORT_KEY, &#039;textAlign&#039;)) {
    return null;
  }
  const textAlign = style.typography.textAlign;
  const className = dist_clsx({
    [`has-text-align-${textAlign}`]: textAlign
  });
  return {
    className
  };
}

/**
 * Override props assigned to save component to inject text alignment class
 * name if block supports it.
 *
 * @param {Object} props      Additional props applied to save element.
 * @param {Object} blockType  Block type.
 * @param {Object} attributes Block attributes.
 *
 * @return {Object} Filtered props applied to save element.
 */
function addAssignedTextAlign(props, blockType, attributes) {
  if (!attributes?.style?.typography?.textAlign) {
    return props;
  }
  const {
    textAlign
  } = attributes.style.typography;
  const blockTextAlign = (0,external_wp_blocks_namespaceObject.getBlockSupport)(blockType, TEXT_ALIGN_SUPPORT_KEY);
  const isTextAlignValid = getValidTextAlignments(blockTextAlign).includes(textAlign);
  if (isTextAlignValid &amp;&amp; !shouldSkipSerialization(blockType, TYPOGRAPHY_SUPPORT_KEY, &#039;textAlign&#039;)) {
    props.className = dist_clsx(`has-text-align-${textAlign}`, props.className);
  }
  return props;
}

;// ./node_modules/@wordpress/block-editor/build-module/hooks/typography.js
/**
 * WordPress dependencies
 */




/**
 * Internal dependencies
 */









function omit(object, keys) {
  return Object.fromEntries(Object.entries(object).filter(([key]) =&gt; !keys.includes(key)));
}
const LETTER_SPACING_SUPPORT_KEY = &#039;typography.__experimentalLetterSpacing&#039;;
const TEXT_TRANSFORM_SUPPORT_KEY = &#039;typography.__experimentalTextTransform&#039;;
const TEXT_DECORATION_SUPPORT_KEY = &#039;typography.__experimentalTextDecoration&#039;;
const TEXT_COLUMNS_SUPPORT_KEY = &#039;typography.textColumns&#039;;
const FONT_STYLE_SUPPORT_KEY = &#039;typography.__experimentalFontStyle&#039;;
const FONT_WEIGHT_SUPPORT_KEY = &#039;typography.__experimentalFontWeight&#039;;
const WRITING_MODE_SUPPORT_KEY = &#039;typography.__experimentalWritingMode&#039;;
const TYPOGRAPHY_SUPPORT_KEY = &#039;typography&#039;;
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];
function typography_styleToAttributes(style) {
  const updatedStyle = {
    ...omit(style, [&#039;fontFamily&#039;])
  };
  const fontSizeValue = style?.typography?.fontSize;
  const fontFamilyValue = style?.typography?.fontFamily;
  const fontSizeSlug = fontSizeValue?.startsWith(&#039;var:preset|font-size|&#039;) ? fontSizeValue.substring(&#039;var:preset|font-size|&#039;.length) : undefined;
  const fontFamilySlug = fontFamilyValue?.startsWith(&#039;var:preset|font-family|&#039;) ? fontFamilyValue.substring(&#039;var:preset|font-family|&#039;.length) : undefined;
  updatedStyle.typography = {
    ...omit(updatedStyle.typography, [&#039;fontFamily&#039;]),
    fontSize: fontSizeSlug ? undefined : fontSizeValue
  };
  return {
    style: utils_cleanEmptyObject(updatedStyle),
    fontFamily: fontFamilySlug,
    fontSize: fontSizeSlug
  };
}
function typography_attributesToStyle(attributes) {
  return {
    ...attributes.style,
    typography: {
      ...attributes.style?.typography,
      fontFamily: attributes.fontFamily ? &#039;var:preset|font-family|&#039; + attributes.fontFamily : undefined,
      fontSize: attributes.fontSize ? &#039;var:preset|font-size|&#039; + attributes.fontSize : attributes.style?.typography?.fontSize
    }
  };
}
function TypographyInspectorControl({
  children,
  resetAllFilter
}) {
  const attributesResetAllFilter = (0,external_wp_element_namespaceObject.useCallback)(attributes =&gt; {
    const existingStyle = typography_attributesToStyle(attributes);
    const updatedStyle = resetAllFilter(existingStyle);
    return {
      ...attributes,
      ...typography_styleToAttributes(updatedStyle)
    };
  }, [resetAllFilter]);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls, {
    group: &quot;typography&quot;,
    resetAllFilter: attributesResetAllFilter,
    children: children
  });
}
function typography_TypographyPanel({
  clientId,
  name,
  setAttributes,
  settings
}) {
  function selector(select) {
    const {
      style,
      fontFamily,
      fontSize
    } = select(store).getBlockAttributes(clientId) || {};
    return {
      style,
      fontFamily,
      fontSize
    };
  }
  const {
    style,
    fontFamily,
    fontSize
  } = (0,external_wp_data_namespaceObject.useSelect)(selector, [clientId]);
  const isEnabled = useHasTypographyPanel(settings);
  const value = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; typography_attributesToStyle({
    style,
    fontFamily,
    fontSize
  }), [style, fontSize, fontFamily]);
  const onChange = newStyle =&gt; {
    setAttributes(typography_styleToAttributes(newStyle));
  };
  if (!isEnabled) {
    return null;
  }
  const defaultControls = (0,external_wp_blocks_namespaceObject.getBlockSupport)(name, [TYPOGRAPHY_SUPPORT_KEY, &#039;__experimentalDefaultControls&#039;]);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(TypographyPanel, {
    as: TypographyInspectorControl,
    panelId: clientId,
    settings: settings,
    value: value,
    onChange: onChange,
    defaultControls: defaultControls
  });
}
const hasTypographySupport = blockName =&gt; {
  return TYPOGRAPHY_SUPPORT_KEYS.some(key =&gt; hasBlockSupport(blockName, key));
};

;// ./node_modules/@wordpress/block-editor/build-module/components/spacing-sizes-control/hooks/use-spacing-sizes.js
/**
 * WordPress dependencies
 */



/**
 * Internal dependencies
 */


const use_spacing_sizes_EMPTY_ARRAY = [];
const compare = new Intl.Collator(&#039;und&#039;, {
  numeric: true
}).compare;
function useSpacingSizes() {
  const [customSpacingSizes, themeSpacingSizes, defaultSpacingSizes, defaultSpacingSizesEnabled] = use_settings_useSettings(&#039;spacing.spacingSizes.custom&#039;, &#039;spacing.spacingSizes.theme&#039;, &#039;spacing.spacingSizes.default&#039;, &#039;spacing.defaultSpacingSizes&#039;);
  const customSizes = customSpacingSizes !== null &amp;&amp; customSpacingSizes !== void 0 ? customSpacingSizes : use_spacing_sizes_EMPTY_ARRAY;
  const themeSizes = themeSpacingSizes !== null &amp;&amp; themeSpacingSizes !== void 0 ? themeSpacingSizes : use_spacing_sizes_EMPTY_ARRAY;
  const defaultSizes = defaultSpacingSizes &amp;&amp; defaultSpacingSizesEnabled !== false ? defaultSpacingSizes : use_spacing_sizes_EMPTY_ARRAY;
  return (0,external_wp_element_namespaceObject.useMemo)(() =&gt; {
    const sizes = [{
      name: (0,external_wp_i18n_namespaceObject.__)(&#039;None&#039;),
      slug: &#039;0&#039;,
      size: 0
    }, ...customSizes, ...themeSizes, ...defaultSizes];

    // Using numeric slugs opts-in to sorting by slug.
    if (sizes.every(({
      slug
    }) =&gt; /^[0-9]/.test(slug))) {
      sizes.sort((a, b) =&gt; compare(a.slug, b.slug));
    }
    return sizes.length &gt; RANGE_CONTROL_MAX_SIZE ? [{
      name: (0,external_wp_i18n_namespaceObject.__)(&#039;Default&#039;),
      slug: &#039;default&#039;,
      size: undefined
    }, ...sizes] : sizes;
  }, [customSizes, themeSizes, defaultSizes]);
}

;// ./node_modules/@wordpress/icons/build-module/library/settings.js
/**
 * WordPress dependencies
 */


const settings_settings = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;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&quot;
  }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;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&quot;
  })]
});
/* harmony default export */ const library_settings = (settings_settings);

;// ./node_modules/@wordpress/block-editor/build-module/components/spacing-sizes-control/input-controls/spacing-input-control.js
/**
 * WordPress dependencies
 */







/**
 * Internal dependencies
 */




const CUSTOM_VALUE_SETTINGS = {
  px: {
    max: 300,
    steps: 1
  },
  &#039;%&#039;: {
    max: 100,
    steps: 1
  },
  vw: {
    max: 100,
    steps: 1
  },
  vh: {
    max: 100,
    steps: 1
  },
  em: {
    max: 10,
    steps: 0.1
  },
  rm: {
    max: 10,
    steps: 0.1
  },
  svw: {
    max: 100,
    steps: 1
  },
  lvw: {
    max: 100,
    steps: 1
  },
  dvw: {
    max: 100,
    steps: 1
  },
  svh: {
    max: 100,
    steps: 1
  },
  lvh: {
    max: 100,
    steps: 1
  },
  dvh: {
    max: 100,
    steps: 1
  },
  vi: {
    max: 100,
    steps: 1
  },
  svi: {
    max: 100,
    steps: 1
  },
  lvi: {
    max: 100,
    steps: 1
  },
  dvi: {
    max: 100,
    steps: 1
  },
  vb: {
    max: 100,
    steps: 1
  },
  svb: {
    max: 100,
    steps: 1
  },
  lvb: {
    max: 100,
    steps: 1
  },
  dvb: {
    max: 100,
    steps: 1
  },
  vmin: {
    max: 100,
    steps: 1
  },
  svmin: {
    max: 100,
    steps: 1
  },
  lvmin: {
    max: 100,
    steps: 1
  },
  dvmin: {
    max: 100,
    steps: 1
  },
  vmax: {
    max: 100,
    steps: 1
  },
  svmax: {
    max: 100,
    steps: 1
  },
  lvmax: {
    max: 100,
    steps: 1
  },
  dvmax: {
    max: 100,
    steps: 1
  }
};
function SpacingInputControl({
  icon,
  isMixed = false,
  minimumCustomValue,
  onChange,
  onMouseOut,
  onMouseOver,
  showSideInLabel = true,
  side,
  spacingSizes,
  type,
  value
}) {
  var _CUSTOM_VALUE_SETTING, _CUSTOM_VALUE_SETTING2;
  // Treat value as a preset value if the passed in value matches the value of one of the spacingSizes.
  value = getPresetValueFromCustomValue(value, spacingSizes);
  let selectListSizes = spacingSizes;
  const showRangeControl = spacingSizes.length &lt;= RANGE_CONTROL_MAX_SIZE;
  const disableCustomSpacingSizes = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const editorSettings = select(store).getSettings();
    return editorSettings?.disableCustomSpacingSizes;
  });
  const [showCustomValueControl, setShowCustomValueControl] = (0,external_wp_element_namespaceObject.useState)(!disableCustomSpacingSizes &amp;&amp; value !== undefined &amp;&amp; !isValueSpacingPreset(value));
  const [minValue, setMinValue] = (0,external_wp_element_namespaceObject.useState)(minimumCustomValue);
  const previousValue = (0,external_wp_compose_namespaceObject.usePrevious)(value);
  if (!!value &amp;&amp; previousValue !== value &amp;&amp; !isValueSpacingPreset(value) &amp;&amp; showCustomValueControl !== true) {
    setShowCustomValueControl(true);
  }
  const [availableUnits] = use_settings_useSettings(&#039;spacing.units&#039;);
  const units = (0,external_wp_components_namespaceObject.__experimentalUseCustomUnits)({
    availableUnits: availableUnits || [&#039;px&#039;, &#039;em&#039;, &#039;rem&#039;]
  });
  let currentValue = null;
  const showCustomValueInSelectList = !showRangeControl &amp;&amp; !showCustomValueControl &amp;&amp; value !== undefined &amp;&amp; (!isValueSpacingPreset(value) || isValueSpacingPreset(value) &amp;&amp; isMixed);
  if (showCustomValueInSelectList) {
    selectListSizes = [...spacingSizes, {
      name: !isMixed ?
      // translators: %s: A custom measurement, e.g. a number followed by a unit like 12px.
      (0,external_wp_i18n_namespaceObject.sprintf)((0,external_wp_i18n_namespaceObject.__)(&#039;Custom (%s)&#039;), value) : (0,external_wp_i18n_namespaceObject.__)(&#039;Mixed&#039;),
      slug: &#039;custom&#039;,
      size: value
    }];
    currentValue = selectListSizes.length - 1;
  } else if (!isMixed) {
    currentValue = !showCustomValueControl ? getSliderValueFromPreset(value, spacingSizes) : getCustomValueFromPreset(value, spacingSizes);
  }
  const selectedUnit = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; (0,external_wp_components_namespaceObject.__experimentalParseQuantityAndUnitFromRawValue)(currentValue), [currentValue])[1] || units[0]?.value;
  const setInitialValue = () =&gt; {
    if (value === undefined) {
      onChange(&#039;0&#039;);
    }
  };
  const customTooltipContent = newValue =&gt; value === undefined ? undefined : spacingSizes[newValue]?.name;
  const customRangeValue = parseFloat(currentValue, 10);
  const getNewCustomValue = newSize =&gt; {
    const isNumeric = !isNaN(parseFloat(newSize));
    const nextValue = isNumeric ? newSize : undefined;
    return nextValue;
  };
  const getNewPresetValue = (newSize, controlType) =&gt; {
    const size = parseInt(newSize, 10);
    if (controlType === &#039;selectList&#039;) {
      if (size === 0) {
        return undefined;
      }
      if (size === 1) {
        return &#039;0&#039;;
      }
    } else if (size === 0) {
      return &#039;0&#039;;
    }
    return `var:preset|spacing|${spacingSizes[newSize]?.slug}`;
  };
  const handleCustomValueSliderChange = next =&gt; {
    onChange([next, selectedUnit].join(&#039;&#039;));
  };
  const allPlaceholder = isMixed ? (0,external_wp_i18n_namespaceObject.__)(&#039;Mixed&#039;) : null;
  const options = selectListSizes.map((size, index) =&gt; ({
    key: index,
    name: size.name
  }));
  const marks = spacingSizes.slice(1, spacingSizes.length - 1).map((_newValue, index) =&gt; ({
    value: index + 1,
    label: undefined
  }));
  const sideLabel = ALL_SIDES.includes(side) &amp;&amp; showSideInLabel ? LABELS[side] : &#039;&#039;;
  const typeLabel = showSideInLabel ? type?.toLowerCase() : type;
  const ariaLabel = (0,external_wp_i18n_namespaceObject.sprintf)(
  // translators: 1: The side of the block being modified (top, bottom, left etc.). 2. Type of spacing being modified (padding, margin, etc).
  (0,external_wp_i18n_namespaceObject._x)(&#039;%1$s %2$s&#039;, &#039;spacing&#039;), sideLabel, typeLabel).trim();
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalHStack, {
    className: &quot;spacing-sizes-control__wrapper&quot;,
    children: [icon &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Icon, {
      className: &quot;spacing-sizes-control__icon&quot;,
      icon: icon,
      size: 24
    }), showCustomValueControl &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalUnitControl, {
        onMouseOver: onMouseOver,
        onMouseOut: onMouseOut,
        onFocus: onMouseOver,
        onBlur: onMouseOut,
        onChange: newSize =&gt; onChange(getNewCustomValue(newSize)),
        value: currentValue,
        units: units,
        min: minValue,
        placeholder: allPlaceholder,
        disableUnits: isMixed,
        label: ariaLabel,
        hideLabelFromVision: true,
        className: &quot;spacing-sizes-control__custom-value-input&quot;,
        size: &quot;__unstable-large&quot;,
        onDragStart: () =&gt; {
          if (value?.charAt(0) === &#039;-&#039;) {
            setMinValue(0);
          }
        },
        onDrag: () =&gt; {
          if (value?.charAt(0) === &#039;-&#039;) {
            setMinValue(0);
          }
        },
        onDragEnd: () =&gt; {
          setMinValue(minimumCustomValue);
        }
      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.RangeControl, {
        __next40pxDefaultSize: true,
        onMouseOver: onMouseOver,
        onMouseOut: onMouseOut,
        onFocus: onMouseOver,
        onBlur: onMouseOut,
        value: customRangeValue,
        min: 0,
        max: (_CUSTOM_VALUE_SETTING = CUSTOM_VALUE_SETTINGS[selectedUnit]?.max) !== null &amp;&amp; _CUSTOM_VALUE_SETTING !== void 0 ? _CUSTOM_VALUE_SETTING : 10,
        step: (_CUSTOM_VALUE_SETTING2 = CUSTOM_VALUE_SETTINGS[selectedUnit]?.steps) !== null &amp;&amp; _CUSTOM_VALUE_SETTING2 !== void 0 ? _CUSTOM_VALUE_SETTING2 : 0.1,
        withInputField: false,
        onChange: handleCustomValueSliderChange,
        className: &quot;spacing-sizes-control__custom-value-range&quot;,
        __nextHasNoMarginBottom: true,
        label: ariaLabel,
        hideLabelFromVision: true
      })]
    }), showRangeControl &amp;&amp; !showCustomValueControl &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.RangeControl, {
      __next40pxDefaultSize: true,
      onMouseOver: onMouseOver,
      onMouseOut: onMouseOut,
      className: &quot;spacing-sizes-control__range-control&quot;,
      value: currentValue,
      onChange: newSize =&gt; onChange(getNewPresetValue(newSize)),
      onMouseDown: event =&gt; {
        // If mouse down is near start of range set initial value to 0, which
        // prevents the user have to drag right then left to get 0 setting.
        if (event?.nativeEvent?.offsetX &lt; 35) {
          setInitialValue();
        }
      },
      withInputField: false,
      &quot;aria-valuenow&quot;: currentValue,
      &quot;aria-valuetext&quot;: spacingSizes[currentValue]?.name,
      renderTooltipContent: customTooltipContent,
      min: 0,
      max: spacingSizes.length - 1,
      marks: marks,
      label: ariaLabel,
      hideLabelFromVision: true,
      __nextHasNoMarginBottom: true,
      onFocus: onMouseOver,
      onBlur: onMouseOut
    }), !showRangeControl &amp;&amp; !showCustomValueControl &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.CustomSelectControl, {
      className: &quot;spacing-sizes-control__custom-select-control&quot;,
      value:
      // passing empty string as a fallback to continue using the
      // component in controlled mode
      options.find(option =&gt; option.key === currentValue) || &#039;&#039;,
      onChange: selection =&gt; {
        onChange(getNewPresetValue(selection.selectedItem.key, &#039;selectList&#039;));
      },
      options: options,
      label: ariaLabel,
      hideLabelFromVision: true,
      size: &quot;__unstable-large&quot;,
      onMouseOver: onMouseOver,
      onMouseOut: onMouseOut,
      onFocus: onMouseOver,
      onBlur: onMouseOut
    }), !disableCustomSpacingSizes &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
      label: showCustomValueControl ? (0,external_wp_i18n_namespaceObject.__)(&#039;Use size preset&#039;) : (0,external_wp_i18n_namespaceObject.__)(&#039;Set custom size&#039;),
      icon: library_settings,
      onClick: () =&gt; {
        setShowCustomValueControl(!showCustomValueControl);
      },
      isPressed: showCustomValueControl,
      size: &quot;small&quot;,
      className: &quot;spacing-sizes-control__custom-toggle&quot;,
      iconSize: 24
    })]
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/spacing-sizes-control/input-controls/axial.js
/**
 * Internal dependencies
 */



const groupedSides = [&#039;vertical&#039;, &#039;horizontal&#039;];
function AxialInputControls({
  minimumCustomValue,
  onChange,
  onMouseOut,
  onMouseOver,
  sides,
  spacingSizes,
  type,
  values
}) {
  const createHandleOnChange = side =&gt; next =&gt; {
    if (!onChange) {
      return;
    }

    // Encode the existing value into the preset value if the passed in value matches the value of one of the spacingSizes.
    const nextValues = {
      ...Object.keys(values).reduce((acc, key) =&gt; {
        acc[key] = getPresetValueFromCustomValue(values[key], spacingSizes);
        return acc;
      }, {})
    };
    if (side === &#039;vertical&#039;) {
      nextValues.top = next;
      nextValues.bottom = next;
    }
    if (side === &#039;horizontal&#039;) {
      nextValues.left = next;
      nextValues.right = next;
    }
    onChange(nextValues);
  };

  // Filter sides if custom configuration provided, maintaining default order.
  const filteredSides = sides?.length ? groupedSides.filter(side =&gt; hasAxisSupport(sides, side)) : groupedSides;
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_ReactJSXRuntime_namespaceObject.Fragment, {
    children: filteredSides.map(side =&gt; {
      const axisValue = side === &#039;vertical&#039; ? values.top : values.left;
      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(SpacingInputControl, {
        icon: ICONS[side],
        label: LABELS[side],
        minimumCustomValue: minimumCustomValue,
        onChange: createHandleOnChange(side),
        onMouseOut: onMouseOut,
        onMouseOver: onMouseOver,
        side: side,
        spacingSizes: spacingSizes,
        type: type,
        value: axisValue,
        withInputField: false
      }, `spacing-sizes-control-${side}`);
    })
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/spacing-sizes-control/input-controls/separated.js
/**
 * Internal dependencies
 */



function SeparatedInputControls({
  minimumCustomValue,
  onChange,
  onMouseOut,
  onMouseOver,
  sides,
  spacingSizes,
  type,
  values
}) {
  // Filter sides if custom configuration provided, maintaining default order.
  const filteredSides = sides?.length ? ALL_SIDES.filter(side =&gt; sides.includes(side)) : ALL_SIDES;
  const createHandleOnChange = side =&gt; next =&gt; {
    // Encode the existing value into the preset value if the passed in value matches the value of one of the spacingSizes.
    const nextValues = {
      ...Object.keys(values).reduce((acc, key) =&gt; {
        acc[key] = getPresetValueFromCustomValue(values[key], spacingSizes);
        return acc;
      }, {})
    };
    nextValues[side] = next;
    onChange(nextValues);
  };
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_ReactJSXRuntime_namespaceObject.Fragment, {
    children: filteredSides.map(side =&gt; {
      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(SpacingInputControl, {
        icon: ICONS[side],
        label: LABELS[side],
        minimumCustomValue: minimumCustomValue,
        onChange: createHandleOnChange(side),
        onMouseOut: onMouseOut,
        onMouseOver: onMouseOver,
        side: side,
        spacingSizes: spacingSizes,
        type: type,
        value: values[side],
        withInputField: false
      }, `spacing-sizes-control-${side}`);
    })
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/spacing-sizes-control/input-controls/single.js
/**
 * Internal dependencies
 */



function SingleInputControl({
  minimumCustomValue,
  onChange,
  onMouseOut,
  onMouseOver,
  showSideInLabel,
  side,
  spacingSizes,
  type,
  values
}) {
  const createHandleOnChange = currentSide =&gt; next =&gt; {
    // Encode the existing value into the preset value if the passed in value matches the value of one of the spacingSizes.
    const nextValues = {
      ...Object.keys(values).reduce((acc, key) =&gt; {
        acc[key] = getPresetValueFromCustomValue(values[key], spacingSizes);
        return acc;
      }, {})
    };
    nextValues[currentSide] = next;
    onChange(nextValues);
  };
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(SpacingInputControl, {
    label: LABELS[side],
    minimumCustomValue: minimumCustomValue,
    onChange: createHandleOnChange(side),
    onMouseOut: onMouseOut,
    onMouseOver: onMouseOver,
    showSideInLabel: showSideInLabel,
    side: side,
    spacingSizes: spacingSizes,
    type: type,
    value: values[side],
    withInputField: false
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/spacing-sizes-control/linked-button.js
/**
 * WordPress dependencies
 */




function linked_button_LinkedButton({
  isLinked,
  ...props
}) {
  const label = isLinked ? (0,external_wp_i18n_namespaceObject.__)(&#039;Unlink sides&#039;) : (0,external_wp_i18n_namespaceObject.__)(&#039;Link sides&#039;);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
    ...props,
    size: &quot;small&quot;,
    icon: isLinked ? library_link : link_off,
    iconSize: 24,
    label: label
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/spacing-sizes-control/index.js
/**
 * WordPress dependencies
 */




/**
 * Internal dependencies
 */







/**
 * A flexible control for managing spacing values in the block editor. Supports single, axial,
 * and separated input controls for different spacing configurations with automatic view selection
 * based on current values and available sides.
 *
 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/spacing-sizes-control/README.md
 *
 * @example
 * ```jsx
 * import { __experimentalSpacingSizesControl as SpacingSizesControl } from &#039;@wordpress/block-editor&#039;;
 * import { useState } from &#039;@wordpress/element&#039;;
 *
 * function Example() {
 *   const [ sides, setSides ] = useState( {
 *     top: &#039;0px&#039;,
 *     right: &#039;0px&#039;,
 *     bottom: &#039;0px&#039;,
 *     left: &#039;0px&#039;,
 *   } );
 *
 *   return (
 *     &lt;SpacingSizesControl
 *       values={ sides }
 *       onChange={ setSides }
 *       label=&quot;Sides&quot;
 *     /&gt;
 *   );
 * }
 * ```
 *
 * @param {Object}   props                    Component props.
 * @param {Object}   props.inputProps         Additional props for input controls.
 * @param {string}   props.label              Label for the control.
 * @param {number}   props.minimumCustomValue Minimum value for custom input.
 * @param {Function} props.onChange           Called when spacing values change.
 * @param {Function} props.onMouseOut         Called when mouse leaves the control.
 * @param {Function} props.onMouseOver        Called when mouse enters the control.
 * @param {boolean}  props.showSideInLabel    Show side in control label.
 * @param {Array}    props.sides              Available sides for control.
 * @param {boolean}  props.useSelect          Use select control for predefined values.
 * @param {Object}   props.values             Current spacing values.
 * @return {Element}                         Spacing sizes control component.
 */

function SpacingSizesControl({
  inputProps,
  label: labelProp,
  minimumCustomValue = 0,
  onChange,
  onMouseOut,
  onMouseOver,
  showSideInLabel = true,
  sides = ALL_SIDES,
  useSelect,
  values
}) {
  const spacingSizes = useSpacingSizes();
  const inputValues = values || DEFAULT_VALUES;
  const hasOneSide = sides?.length === 1;
  const hasOnlyAxialSides = sides?.includes(&#039;horizontal&#039;) &amp;&amp; sides?.includes(&#039;vertical&#039;) &amp;&amp; sides?.length === 2;
  const [view, setView] = (0,external_wp_element_namespaceObject.useState)(getInitialView(inputValues, sides));
  const toggleLinked = () =&gt; {
    setView(view === VIEWS.axial ? VIEWS.custom : VIEWS.axial);
  };
  const handleOnChange = nextValue =&gt; {
    const newValues = {
      ...values,
      ...nextValue
    };
    onChange(newValues);
  };
  const inputControlProps = {
    ...inputProps,
    minimumCustomValue,
    onChange: handleOnChange,
    onMouseOut,
    onMouseOver,
    sides,
    spacingSizes,
    type: labelProp,
    useSelect,
    values: inputValues
  };
  const renderControls = () =&gt; {
    if (view === VIEWS.axial) {
      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(AxialInputControls, {
        ...inputControlProps
      });
    }
    if (view === VIEWS.custom) {
      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(SeparatedInputControls, {
        ...inputControlProps
      });
    }
    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(SingleInputControl, {
      side: view,
      ...inputControlProps,
      showSideInLabel: showSideInLabel
    });
  };
  const sideLabel = ALL_SIDES.includes(view) &amp;&amp; showSideInLabel ? LABELS[view] : &#039;&#039;;
  const label = (0,external_wp_i18n_namespaceObject.sprintf)(
  // translators: 1: The side of the block being modified (top, bottom, left etc.). 2. Type of spacing being modified (padding, margin, etc).
  (0,external_wp_i18n_namespaceObject._x)(&#039;%1$s %2$s&#039;, &#039;spacing&#039;), labelProp, sideLabel).trim();
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;fieldset&quot;, {
    className: &quot;spacing-sizes-control&quot;,
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalHStack, {
      className: &quot;spacing-sizes-control__header&quot;,
      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.BaseControl.VisualLabel, {
        as: &quot;legend&quot;,
        className: &quot;spacing-sizes-control__label&quot;,
        children: label
      }), !hasOneSide &amp;&amp; !hasOnlyAxialSides &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(linked_button_LinkedButton, {
        label: labelProp,
        onClick: toggleLinked,
        isLinked: view === VIEWS.axial
      })]
    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalVStack, {
      spacing: 0.5,
      children: renderControls()
    })]
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/height-control/index.js
/**
 * WordPress dependencies
 */




/**
 * Internal dependencies
 */


const RANGE_CONTROL_CUSTOM_SETTINGS = {
  px: {
    max: 1000,
    step: 1
  },
  &#039;%&#039;: {
    max: 100,
    step: 1
  },
  vw: {
    max: 100,
    step: 1
  },
  vh: {
    max: 100,
    step: 1
  },
  em: {
    max: 50,
    step: 0.1
  },
  rem: {
    max: 50,
    step: 0.1
  },
  svw: {
    max: 100,
    step: 1
  },
  lvw: {
    max: 100,
    step: 1
  },
  dvw: {
    max: 100,
    step: 1
  },
  svh: {
    max: 100,
    step: 1
  },
  lvh: {
    max: 100,
    step: 1
  },
  dvh: {
    max: 100,
    step: 1
  },
  vi: {
    max: 100,
    step: 1
  },
  svi: {
    max: 100,
    step: 1
  },
  lvi: {
    max: 100,
    step: 1
  },
  dvi: {
    max: 100,
    step: 1
  },
  vb: {
    max: 100,
    step: 1
  },
  svb: {
    max: 100,
    step: 1
  },
  lvb: {
    max: 100,
    step: 1
  },
  dvb: {
    max: 100,
    step: 1
  },
  vmin: {
    max: 100,
    step: 1
  },
  svmin: {
    max: 100,
    step: 1
  },
  lvmin: {
    max: 100,
    step: 1
  },
  dvmin: {
    max: 100,
    step: 1
  },
  vmax: {
    max: 100,
    step: 1
  },
  svmax: {
    max: 100,
    step: 1
  },
  lvmax: {
    max: 100,
    step: 1
  },
  dvmax: {
    max: 100,
    step: 1
  }
};

/**
 * HeightControl renders a linked unit control and range control for adjusting the height of a block.
 *
 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/height-control/README.md
 *
 * @param {Object}                     props
 * @param {?string}                    props.label    A label for the control.
 * @param {( value: string ) =&gt; void } props.onChange Called when the height changes.
 * @param {string}                     props.value    The current height value.
 *
 * @return {Component} The component to be rendered.
 */
function HeightControl({
  label = (0,external_wp_i18n_namespaceObject.__)(&#039;Height&#039;),
  onChange,
  value
}) {
  var _RANGE_CONTROL_CUSTOM, _RANGE_CONTROL_CUSTOM2;
  const customRangeValue = parseFloat(value);
  const [availableUnits] = use_settings_useSettings(&#039;spacing.units&#039;);
  const units = (0,external_wp_components_namespaceObject.__experimentalUseCustomUnits)({
    availableUnits: availableUnits || [&#039;%&#039;, &#039;px&#039;, &#039;em&#039;, &#039;rem&#039;, &#039;vh&#039;, &#039;vw&#039;]
  });
  const selectedUnit = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; (0,external_wp_components_namespaceObject.__experimentalParseQuantityAndUnitFromRawValue)(value), [value])[1] || units[0]?.value || &#039;px&#039;;
  const handleSliderChange = next =&gt; {
    onChange([next, selectedUnit].join(&#039;&#039;));
  };
  const handleUnitChange = newUnit =&gt; {
    // Attempt to smooth over differences between currentUnit and newUnit.
    // This should slightly improve the experience of switching between unit types.
    const [currentValue, currentUnit] = (0,external_wp_components_namespaceObject.__experimentalParseQuantityAndUnitFromRawValue)(value);
    if ([&#039;em&#039;, &#039;rem&#039;].includes(newUnit) &amp;&amp; currentUnit === &#039;px&#039;) {
      // Convert pixel value to an approximate of the new unit, assuming a root size of 16px.
      onChange((currentValue / 16).toFixed(2) + newUnit);
    } else if ([&#039;em&#039;, &#039;rem&#039;].includes(currentUnit) &amp;&amp; newUnit === &#039;px&#039;) {
      // Convert to pixel value assuming a root size of 16px.
      onChange(Math.round(currentValue * 16) + newUnit);
    } else if ([&#039;%&#039;, &#039;vw&#039;, &#039;svw&#039;, &#039;lvw&#039;, &#039;dvw&#039;, &#039;vh&#039;, &#039;svh&#039;, &#039;lvh&#039;, &#039;dvh&#039;, &#039;vi&#039;, &#039;svi&#039;, &#039;lvi&#039;, &#039;dvi&#039;, &#039;vb&#039;, &#039;svb&#039;, &#039;lvb&#039;, &#039;dvb&#039;, &#039;vmin&#039;, &#039;svmin&#039;, &#039;lvmin&#039;, &#039;dvmin&#039;, &#039;vmax&#039;, &#039;svmax&#039;, &#039;lvmax&#039;, &#039;dvmax&#039;].includes(newUnit) &amp;&amp; currentValue &gt; 100) {
      // When converting to `%` or viewport-relative units, cap the new value at 100.
      onChange(100 + newUnit);
    }
  };
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;fieldset&quot;, {
    className: &quot;block-editor-height-control&quot;,
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.BaseControl.VisualLabel, {
      as: &quot;legend&quot;,
      children: label
    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.Flex, {
      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FlexItem, {
        isBlock: true,
        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalUnitControl, {
          value: value,
          units: units,
          onChange: onChange,
          onUnitChange: handleUnitChange,
          min: 0,
          size: &quot;__unstable-large&quot;,
          label: label,
          hideLabelFromVision: true
        })
      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FlexItem, {
        isBlock: true,
        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalSpacer, {
          marginX: 2,
          marginBottom: 0,
          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.RangeControl, {
            __next40pxDefaultSize: true,
            value: customRangeValue,
            min: 0,
            max: (_RANGE_CONTROL_CUSTOM = RANGE_CONTROL_CUSTOM_SETTINGS[selectedUnit]?.max) !== null &amp;&amp; _RANGE_CONTROL_CUSTOM !== void 0 ? _RANGE_CONTROL_CUSTOM : 100,
            step: (_RANGE_CONTROL_CUSTOM2 = RANGE_CONTROL_CUSTOM_SETTINGS[selectedUnit]?.step) !== null &amp;&amp; _RANGE_CONTROL_CUSTOM2 !== void 0 ? _RANGE_CONTROL_CUSTOM2 : 0.1,
            withInputField: false,
            onChange: handleSliderChange,
            __nextHasNoMarginBottom: true,
            label: label,
            hideLabelFromVision: true
          })
        })
      })]
    })]
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/grid/use-get-number-of-blocks-before-cell.js
/**
 * WordPress dependencies
 */


/**
 * Internal dependencies
 */

function useGetNumberOfBlocksBeforeCell(gridClientId, numColumns) {
  const {
    getBlockOrder,
    getBlockAttributes
  } = (0,external_wp_data_namespaceObject.useSelect)(store);
  const getNumberOfBlocksBeforeCell = (column, row) =&gt; {
    const targetIndex = (row - 1) * numColumns + column - 1;
    let count = 0;
    for (const clientId of getBlockOrder(gridClientId)) {
      var _getBlockAttributes$s;
      const {
        columnStart,
        rowStart
      } = (_getBlockAttributes$s = getBlockAttributes(clientId).style?.layout) !== null &amp;&amp; _getBlockAttributes$s !== void 0 ? _getBlockAttributes$s : {};
      const cellIndex = (rowStart - 1) * numColumns + columnStart - 1;
      if (cellIndex &lt; targetIndex) {
        count++;
      }
    }
    return count;
  };
  return getNumberOfBlocksBeforeCell;
}

;// ./node_modules/@wordpress/block-editor/build-module/components/child-layout-control/index.js
/**
 * WordPress dependencies
 */





/**
 * Internal dependencies
 */




function helpText(selfStretch, parentLayout) {
  const {
    orientation = &#039;horizontal&#039;
  } = parentLayout;
  if (selfStretch === &#039;fill&#039;) {
    return (0,external_wp_i18n_namespaceObject.__)(&#039;Stretch to fill available space.&#039;);
  }
  if (selfStretch === &#039;fixed&#039; &amp;&amp; orientation === &#039;horizontal&#039;) {
    return (0,external_wp_i18n_namespaceObject.__)(&#039;Specify a fixed width.&#039;);
  } else if (selfStretch === &#039;fixed&#039;) {
    return (0,external_wp_i18n_namespaceObject.__)(&#039;Specify a fixed height.&#039;);
  }
  return (0,external_wp_i18n_namespaceObject.__)(&#039;Fit contents.&#039;);
}

/**
 * Form to edit the child layout value.
 *
 * @param {Object}   props                  Props.
 * @param {Object}   props.value            The child layout value.
 * @param {Function} props.onChange         Function to update the child layout value.
 * @param {Object}   props.parentLayout     The parent layout value.
 *
 * @param {boolean}  props.isShownByDefault
 * @param {string}   props.panelId
 * @return {Element} child layout edit element.
 */
function ChildLayoutControl({
  value: childLayout = {},
  onChange,
  parentLayout,
  isShownByDefault,
  panelId
}) {
  const {
    type: parentType,
    default: {
      type: defaultParentType = &#039;default&#039;
    } = {}
  } = parentLayout !== null &amp;&amp; parentLayout !== void 0 ? parentLayout : {};
  const parentLayoutType = parentType || defaultParentType;
  if (parentLayoutType === &#039;flex&#039;) {
    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(FlexControls, {
      childLayout: childLayout,
      onChange: onChange,
      parentLayout: parentLayout,
      isShownByDefault: isShownByDefault,
      panelId: panelId
    });
  } else if (parentLayoutType === &#039;grid&#039;) {
    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(GridControls, {
      childLayout: childLayout,
      onChange: onChange,
      parentLayout: parentLayout,
      isShownByDefault: isShownByDefault,
      panelId: panelId
    });
  }
  return null;
}
function FlexControls({
  childLayout,
  onChange,
  parentLayout,
  isShownByDefault,
  panelId
}) {
  const {
    selfStretch,
    flexSize
  } = childLayout;
  const {
    orientation = &#039;horizontal&#039;
  } = parentLayout !== null &amp;&amp; parentLayout !== void 0 ? parentLayout : {};
  const hasFlexValue = () =&gt; !!selfStretch;
  const flexResetLabel = orientation === &#039;horizontal&#039; ? (0,external_wp_i18n_namespaceObject.__)(&#039;Width&#039;) : (0,external_wp_i18n_namespaceObject.__)(&#039;Height&#039;);
  const [availableUnits] = use_settings_useSettings(&#039;spacing.units&#039;);
  const units = (0,external_wp_components_namespaceObject.__experimentalUseCustomUnits)({
    availableUnits: availableUnits || [&#039;%&#039;, &#039;px&#039;, &#039;em&#039;, &#039;rem&#039;, &#039;vh&#039;, &#039;vw&#039;]
  });
  const resetFlex = () =&gt; {
    onChange({
      selfStretch: undefined,
      flexSize: undefined
    });
  };
  (0,external_wp_element_namespaceObject.useEffect)(() =&gt; {
    if (selfStretch === &#039;fixed&#039; &amp;&amp; !flexSize) {
      onChange({
        ...childLayout,
        selfStretch: &#039;fit&#039;
      });
    }
  }, []);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalVStack, {
    as: external_wp_components_namespaceObject.__experimentalToolsPanelItem,
    spacing: 2,
    hasValue: hasFlexValue,
    label: flexResetLabel,
    onDeselect: resetFlex,
    isShownByDefault: isShownByDefault,
    panelId: panelId,
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalToggleGroupControl, {
      __nextHasNoMarginBottom: true,
      size: &quot;__unstable-large&quot;,
      label: childLayoutOrientation(parentLayout),
      value: selfStretch || &#039;fit&#039;,
      help: helpText(selfStretch, parentLayout),
      onChange: value =&gt; {
        const newFlexSize = value !== &#039;fixed&#039; ? null : flexSize;
        onChange({
          selfStretch: value,
          flexSize: newFlexSize
        });
      },
      isBlock: true,
      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControlOption, {
        value: &quot;fit&quot;,
        label: (0,external_wp_i18n_namespaceObject._x)(&#039;Fit&#039;, &#039;Intrinsic block width in flex layout&#039;)
      }, &quot;fit&quot;), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControlOption, {
        value: &quot;fill&quot;,
        label: (0,external_wp_i18n_namespaceObject._x)(&#039;Grow&#039;, &#039;Block with expanding width in flex layout&#039;)
      }, &quot;fill&quot;), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControlOption, {
        value: &quot;fixed&quot;,
        label: (0,external_wp_i18n_namespaceObject._x)(&#039;Fixed&#039;, &#039;Block with fixed width in flex layout&#039;)
      }, &quot;fixed&quot;)]
    }), selfStretch === &#039;fixed&#039; &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalUnitControl, {
      size: &quot;__unstable-large&quot;,
      units: units,
      onChange: value =&gt; {
        onChange({
          selfStretch,
          flexSize: value
        });
      },
      value: flexSize,
      label: flexResetLabel,
      hideLabelFromVision: true
    })]
  });
}
function childLayoutOrientation(parentLayout) {
  const {
    orientation = &#039;horizontal&#039;
  } = parentLayout;
  return orientation === &#039;horizontal&#039; ? (0,external_wp_i18n_namespaceObject.__)(&#039;Width&#039;) : (0,external_wp_i18n_namespaceObject.__)(&#039;Height&#039;);
}
function GridControls({
  childLayout,
  onChange,
  parentLayout,
  isShownByDefault,
  panelId
}) {
  const {
    columnStart,
    rowStart,
    columnSpan,
    rowSpan
  } = childLayout;
  const {
    columnCount = 3,
    rowCount
  } = parentLayout !== null &amp;&amp; parentLayout !== void 0 ? parentLayout : {};
  const rootClientId = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; select(store).getBlockRootClientId(panelId));
  const {
    moveBlocksToPosition,
    __unstableMarkNextChangeAsNotPersistent
  } = (0,external_wp_data_namespaceObject.useDispatch)(store);
  const getNumberOfBlocksBeforeCell = useGetNumberOfBlocksBeforeCell(rootClientId, columnCount);
  const hasStartValue = () =&gt; !!columnStart || !!rowStart;
  const hasSpanValue = () =&gt; !!columnSpan || !!rowSpan;
  const resetGridStarts = () =&gt; {
    onChange({
      columnStart: undefined,
      rowStart: undefined
    });
  };
  const resetGridSpans = () =&gt; {
    onChange({
      columnSpan: undefined,
      rowSpan: undefined
    });
  };
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalHStack, {
      as: external_wp_components_namespaceObject.__experimentalToolsPanelItem,
      hasValue: hasSpanValue,
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Grid span&#039;),
      onDeselect: resetGridSpans,
      isShownByDefault: isShownByDefault,
      panelId: panelId,
      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalInputControl, {
        size: &quot;__unstable-large&quot;,
        label: (0,external_wp_i18n_namespaceObject.__)(&#039;Column span&#039;),
        type: &quot;number&quot;,
        onChange: value =&gt; {
          // Don&#039;t allow unsetting.
          const newColumnSpan = value === &#039;&#039; ? 1 : parseInt(value, 10);
          onChange({
            columnStart,
            rowStart,
            rowSpan,
            columnSpan: newColumnSpan
          });
        },
        value: columnSpan !== null &amp;&amp; columnSpan !== void 0 ? columnSpan : 1,
        min: 1
      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalInputControl, {
        size: &quot;__unstable-large&quot;,
        label: (0,external_wp_i18n_namespaceObject.__)(&#039;Row span&#039;),
        type: &quot;number&quot;,
        onChange: value =&gt; {
          // Don&#039;t allow unsetting.
          const newRowSpan = value === &#039;&#039; ? 1 : parseInt(value, 10);
          onChange({
            columnStart,
            rowStart,
            columnSpan,
            rowSpan: newRowSpan
          });
        },
        value: rowSpan !== null &amp;&amp; rowSpan !== void 0 ? rowSpan : 1,
        min: 1
      })]
    }), window.__experimentalEnableGridInteractivity &amp;&amp; columnCount &amp;&amp;
    /*#__PURE__*/
    // Use Flex with an explicit width on the FlexItem instead of HStack to
    // work around an issue in webkit where inputs with a max attribute are
    // sized incorrectly.
    (0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.Flex, {
      as: external_wp_components_namespaceObject.__experimentalToolsPanelItem,
      hasValue: hasStartValue,
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Grid placement&#039;),
      onDeselect: resetGridStarts,
      isShownByDefault: false,
      panelId: panelId,
      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FlexItem, {
        style: {
          width: &#039;50%&#039;
        },
        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalInputControl, {
          size: &quot;__unstable-large&quot;,
          label: (0,external_wp_i18n_namespaceObject.__)(&#039;Column&#039;),
          type: &quot;number&quot;,
          onChange: value =&gt; {
            // Don&#039;t allow unsetting.
            const newColumnStart = value === &#039;&#039; ? 1 : parseInt(value, 10);
            onChange({
              columnStart: newColumnStart,
              rowStart,
              columnSpan,
              rowSpan
            });
            __unstableMarkNextChangeAsNotPersistent();
            moveBlocksToPosition([panelId], rootClientId, rootClientId, getNumberOfBlocksBeforeCell(newColumnStart, rowStart));
          },
          value: columnStart !== null &amp;&amp; columnStart !== void 0 ? columnStart : 1,
          min: 1,
          max: columnCount ? columnCount - (columnSpan !== null &amp;&amp; columnSpan !== void 0 ? columnSpan : 1) + 1 : undefined
        })
      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FlexItem, {
        style: {
          width: &#039;50%&#039;
        },
        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalInputControl, {
          size: &quot;__unstable-large&quot;,
          label: (0,external_wp_i18n_namespaceObject.__)(&#039;Row&#039;),
          type: &quot;number&quot;,
          onChange: value =&gt; {
            // Don&#039;t allow unsetting.
            const newRowStart = value === &#039;&#039; ? 1 : parseInt(value, 10);
            onChange({
              columnStart,
              rowStart: newRowStart,
              columnSpan,
              rowSpan
            });
            __unstableMarkNextChangeAsNotPersistent();
            moveBlocksToPosition([panelId], rootClientId, rootClientId, getNumberOfBlocksBeforeCell(columnStart, newRowStart));
          },
          value: rowStart !== null &amp;&amp; rowStart !== void 0 ? rowStart : 1,
          min: 1,
          max: rowCount ? rowCount - (rowSpan !== null &amp;&amp; rowSpan !== void 0 ? rowSpan : 1) + 1 : undefined
        })
      })]
    })]
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/dimensions-tool/aspect-ratio-tool.js
/**
 * WordPress dependencies
 */


/**
 * Internal dependencies
 */


/**
 * @typedef {import(&#039;@wordpress/components/build-types/select-control/types&#039;).SelectControlProps} SelectControlProps
 */

/**
 * @callback AspectRatioToolPropsOnChange
 * @param {string} [value] New aspect ratio value.
 * @return {void} No return.
 */

/**
 * @typedef {Object} AspectRatioToolProps
 * @property {string}                       [panelId]          ID of the panel this tool is associated with.
 * @property {string}                       [value]            Current aspect ratio value.
 * @property {AspectRatioToolPropsOnChange} [onChange]         Callback to update the aspect ratio value.
 * @property {SelectControlProps[]}         [options]          Aspect ratio options.
 * @property {string}                       [defaultValue]     Default aspect ratio value.
 * @property {boolean}                      [isShownByDefault] Whether the tool is shown by default.
 */

function AspectRatioTool({
  panelId,
  value,
  onChange = () =&gt; {},
  options,
  defaultValue = &#039;auto&#039;,
  hasValue,
  isShownByDefault = true
}) {
  // Match the CSS default so if the value is used directly in CSS it will look correct in the control.
  const displayValue = value !== null &amp;&amp; value !== void 0 ? value : &#039;auto&#039;;
  const [defaultRatios, themeRatios, showDefaultRatios] = use_settings_useSettings(&#039;dimensions.aspectRatios.default&#039;, &#039;dimensions.aspectRatios.theme&#039;, &#039;dimensions.defaultAspectRatios&#039;);
  const themeOptions = themeRatios?.map(({
    name,
    ratio
  }) =&gt; ({
    label: name,
    value: ratio
  }));
  const defaultOptions = defaultRatios?.map(({
    name,
    ratio
  }) =&gt; ({
    label: name,
    value: ratio
  }));
  const aspectRatioOptions = [{
    label: (0,external_wp_i18n_namespaceObject._x)(&#039;Original&#039;, &#039;Aspect ratio option for dimensions control&#039;),
    value: &#039;auto&#039;
  }, ...(showDefaultRatios ? defaultOptions : []), ...(themeOptions ? themeOptions : []), {
    label: (0,external_wp_i18n_namespaceObject._x)(&#039;Custom&#039;, &#039;Aspect ratio option for dimensions control&#039;),
    value: &#039;custom&#039;,
    disabled: true,
    hidden: true
  }];
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanelItem, {
    hasValue: hasValue ? hasValue : () =&gt; displayValue !== defaultValue,
    label: (0,external_wp_i18n_namespaceObject.__)(&#039;Aspect ratio&#039;),
    onDeselect: () =&gt; onChange(undefined),
    isShownByDefault: isShownByDefault,
    panelId: panelId,
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.SelectControl, {
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Aspect ratio&#039;),
      value: displayValue,
      options: options !== null &amp;&amp; options !== void 0 ? options : aspectRatioOptions,
      onChange: onChange,
      size: &quot;__unstable-large&quot;,
      __nextHasNoMarginBottom: true
    })
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/global-styles/dimensions-panel.js
/**
 * External dependencies
 */


/**
 * WordPress dependencies
 */





/**
 * Internal dependencies
 */








const AXIAL_SIDES = [&#039;horizontal&#039;, &#039;vertical&#039;];
function useHasDimensionsPanel(settings) {
  const hasContentSize = useHasContentSize(settings);
  const hasWideSize = useHasWideSize(settings);
  const hasPadding = useHasPadding(settings);
  const hasMargin = useHasMargin(settings);
  const hasGap = useHasGap(settings);
  const hasMinHeight = useHasMinHeight(settings);
  const hasAspectRatio = useHasAspectRatio(settings);
  const hasChildLayout = useHasChildLayout(settings);
  return external_wp_element_namespaceObject.Platform.OS === &#039;web&#039; &amp;&amp; (hasContentSize || hasWideSize || hasPadding || hasMargin || hasGap || hasMinHeight || hasAspectRatio || hasChildLayout);
}
function useHasContentSize(settings) {
  return settings?.layout?.contentSize;
}
function useHasWideSize(settings) {
  return settings?.layout?.wideSize;
}
function useHasPadding(settings) {
  return settings?.spacing?.padding;
}
function useHasMargin(settings) {
  return settings?.spacing?.margin;
}
function useHasGap(settings) {
  return settings?.spacing?.blockGap;
}
function useHasMinHeight(settings) {
  return settings?.dimensions?.minHeight;
}
function useHasAspectRatio(settings) {
  return settings?.dimensions?.aspectRatio;
}
function useHasChildLayout(settings) {
  var _settings$parentLayou;
  const {
    type: parentLayoutType = &#039;default&#039;,
    default: {
      type: defaultParentLayoutType = &#039;default&#039;
    } = {},
    allowSizingOnChildren = false
  } = (_settings$parentLayou = settings?.parentLayout) !== null &amp;&amp; _settings$parentLayou !== void 0 ? _settings$parentLayou : {};
  const support = (defaultParentLayoutType === &#039;flex&#039; || parentLayoutType === &#039;flex&#039; || defaultParentLayoutType === &#039;grid&#039; || parentLayoutType === &#039;grid&#039;) &amp;&amp; allowSizingOnChildren;
  return !!settings?.layout &amp;&amp; support;
}
function useHasSpacingPresets(settings) {
  const {
    defaultSpacingSizes,
    spacingSizes
  } = settings?.spacing || {};
  return defaultSpacingSizes !== false &amp;&amp; spacingSizes?.default?.length &gt; 0 || spacingSizes?.theme?.length &gt; 0 || spacingSizes?.custom?.length &gt; 0;
}
function filterValuesBySides(values, sides) {
  // If no custom side configuration, all sides are opted into by default.
  // Without any values, we have nothing to filter either.
  if (!sides || !values) {
    return values;
  }

  // Only include sides opted into within filtered values.
  const filteredValues = {};
  sides.forEach(side =&gt; {
    if (side === &#039;vertical&#039;) {
      filteredValues.top = values.top;
      filteredValues.bottom = values.bottom;
    }
    if (side === &#039;horizontal&#039;) {
      filteredValues.left = values.left;
      filteredValues.right = values.right;
    }
    filteredValues[side] = values?.[side];
  });
  return filteredValues;
}
function splitStyleValue(value) {
  // Check for shorthand value (a string value).
  if (value &amp;&amp; typeof value === &#039;string&#039;) {
    // Convert to value for individual sides for BoxControl.
    return {
      top: value,
      right: value,
      bottom: value,
      left: value
    };
  }
  return value;
}
function splitGapValue(value, isAxialGap) {
  if (!value) {
    return value;
  }

  // Check for shorthand value (a string value).
  if (typeof value === &#039;string&#039;) {
    /*
     * Map the string value to appropriate sides for the spacing control depending
     * on whether the current block has axial gap support or not.
     *
     * Note: The axial value pairs must match for the spacing control to display
     * the appropriate horizontal/vertical sliders.
     */
    return isAxialGap ? {
      top: value,
      right: value,
      bottom: value,
      left: value
    } : {
      top: value
    };
  }
  return {
    ...value,
    right: value?.left,
    bottom: value?.top
  };
}
function DimensionsToolsPanel({
  resetAllFilter,
  onChange,
  value,
  panelId,
  children
}) {
  const dropdownMenuProps = useToolsPanelDropdownMenuProps();
  const resetAll = () =&gt; {
    const updatedValue = resetAllFilter(value);
    onChange(updatedValue);
  };
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanel, {
    label: (0,external_wp_i18n_namespaceObject.__)(&#039;Dimensions&#039;),
    resetAll: resetAll,
    panelId: panelId,
    dropdownMenuProps: dropdownMenuProps,
    children: children
  });
}
const dimensions_panel_DEFAULT_CONTROLS = {
  contentSize: true,
  wideSize: true,
  padding: true,
  margin: true,
  blockGap: true,
  minHeight: true,
  aspectRatio: true,
  childLayout: true
};
function DimensionsPanel({
  as: Wrapper = DimensionsToolsPanel,
  value,
  onChange,
  inheritedValue = value,
  settings,
  panelId,
  defaultControls = dimensions_panel_DEFAULT_CONTROLS,
  onVisualize = () =&gt; {},
  // Special case because the layout controls are not part of the dimensions panel
  // in global styles but not in block inspector.
  includeLayoutControls = false
}) {
  var _defaultControls$cont, _defaultControls$wide, _defaultControls$padd, _defaultControls$marg, _defaultControls$bloc, _defaultControls$chil, _defaultControls$minH, _defaultControls$aspe;
  const {
    dimensions,
    spacing
  } = settings;
  const decodeValue = rawValue =&gt; {
    if (rawValue &amp;&amp; typeof rawValue === &#039;object&#039;) {
      return Object.keys(rawValue).reduce((acc, key) =&gt; {
        acc[key] = getValueFromVariable({
          settings: {
            dimensions,
            spacing
          }
        }, &#039;&#039;, rawValue[key]);
        return acc;
      }, {});
    }
    return getValueFromVariable({
      settings: {
        dimensions,
        spacing
      }
    }, &#039;&#039;, rawValue);
  };
  const showSpacingPresetsControl = useHasSpacingPresets(settings);
  const units = (0,external_wp_components_namespaceObject.__experimentalUseCustomUnits)({
    availableUnits: settings?.spacing?.units || [&#039;%&#039;, &#039;px&#039;, &#039;em&#039;, &#039;rem&#039;, &#039;vw&#039;]
  });

  //Minimum Margin Value
  const minimumMargin = -Infinity;
  const [minMarginValue, setMinMarginValue] = (0,external_wp_element_namespaceObject.useState)(minimumMargin);

  // Content Width
  const showContentSizeControl = useHasContentSize(settings) &amp;&amp; includeLayoutControls;
  const contentSizeValue = decodeValue(inheritedValue?.layout?.contentSize);
  const setContentSizeValue = newValue =&gt; {
    onChange(setImmutably(value, [&#039;layout&#039;, &#039;contentSize&#039;], newValue || undefined));
  };
  const hasUserSetContentSizeValue = () =&gt; !!value?.layout?.contentSize;
  const resetContentSizeValue = () =&gt; setContentSizeValue(undefined);

  // Wide Width
  const showWideSizeControl = useHasWideSize(settings) &amp;&amp; includeLayoutControls;
  const wideSizeValue = decodeValue(inheritedValue?.layout?.wideSize);
  const setWideSizeValue = newValue =&gt; {
    onChange(setImmutably(value, [&#039;layout&#039;, &#039;wideSize&#039;], newValue || undefined));
  };
  const hasUserSetWideSizeValue = () =&gt; !!value?.layout?.wideSize;
  const resetWideSizeValue = () =&gt; setWideSizeValue(undefined);

  // Padding
  const showPaddingControl = useHasPadding(settings);
  const rawPadding = decodeValue(inheritedValue?.spacing?.padding);
  const paddingValues = splitStyleValue(rawPadding);
  const paddingSides = Array.isArray(settings?.spacing?.padding) ? settings?.spacing?.padding : settings?.spacing?.padding?.sides;
  const isAxialPadding = paddingSides &amp;&amp; paddingSides.some(side =&gt; AXIAL_SIDES.includes(side));
  const setPaddingValues = newPaddingValues =&gt; {
    const padding = filterValuesBySides(newPaddingValues, paddingSides);
    onChange(setImmutably(value, [&#039;spacing&#039;, &#039;padding&#039;], padding));
  };
  const hasPaddingValue = () =&gt; !!value?.spacing?.padding &amp;&amp; Object.keys(value?.spacing?.padding).length;
  const resetPaddingValue = () =&gt; setPaddingValues(undefined);
  const onMouseOverPadding = () =&gt; onVisualize(&#039;padding&#039;);

  // Margin
  const showMarginControl = useHasMargin(settings);
  const rawMargin = decodeValue(inheritedValue?.spacing?.margin);
  const marginValues = splitStyleValue(rawMargin);
  const marginSides = Array.isArray(settings?.spacing?.margin) ? settings?.spacing?.margin : settings?.spacing?.margin?.sides;
  const isAxialMargin = marginSides &amp;&amp; marginSides.some(side =&gt; AXIAL_SIDES.includes(side));
  const setMarginValues = newMarginValues =&gt; {
    const margin = filterValuesBySides(newMarginValues, marginSides);
    onChange(setImmutably(value, [&#039;spacing&#039;, &#039;margin&#039;], margin));
  };
  const hasMarginValue = () =&gt; !!value?.spacing?.margin &amp;&amp; Object.keys(value?.spacing?.margin).length;
  const resetMarginValue = () =&gt; setMarginValues(undefined);
  const onMouseOverMargin = () =&gt; onVisualize(&#039;margin&#039;);

  // Block Gap
  const showGapControl = useHasGap(settings);
  const gapSides = Array.isArray(settings?.spacing?.blockGap) ? settings?.spacing?.blockGap : settings?.spacing?.blockGap?.sides;
  const isAxialGap = gapSides &amp;&amp; gapSides.some(side =&gt; AXIAL_SIDES.includes(side));
  const gapValue = decodeValue(inheritedValue?.spacing?.blockGap);
  const gapValues = splitGapValue(gapValue, isAxialGap);
  const setGapValue = newGapValue =&gt; {
    onChange(setImmutably(value, [&#039;spacing&#039;, &#039;blockGap&#039;], newGapValue));
  };
  const setGapValues = nextBoxGapValue =&gt; {
    if (!nextBoxGapValue) {
      setGapValue(null);
    }
    // If axial gap is not enabled, treat the &#039;top&#039; value as the shorthand gap value.
    if (!isAxialGap &amp;&amp; nextBoxGapValue?.hasOwnProperty(&#039;top&#039;)) {
      setGapValue(nextBoxGapValue.top);
    } else {
      setGapValue({
        top: nextBoxGapValue?.top,
        left: nextBoxGapValue?.left
      });
    }
  };
  const resetGapValue = () =&gt; setGapValue(undefined);
  const hasGapValue = () =&gt; !!value?.spacing?.blockGap;

  // Min Height
  const showMinHeightControl = useHasMinHeight(settings);
  const minHeightValue = decodeValue(inheritedValue?.dimensions?.minHeight);
  const setMinHeightValue = newValue =&gt; {
    const tempValue = setImmutably(value, [&#039;dimensions&#039;, &#039;minHeight&#039;], newValue);
    // Apply min-height, while removing any applied aspect ratio.
    onChange(setImmutably(tempValue, [&#039;dimensions&#039;, &#039;aspectRatio&#039;], undefined));
  };
  const resetMinHeightValue = () =&gt; {
    setMinHeightValue(undefined);
  };
  const hasMinHeightValue = () =&gt; !!value?.dimensions?.minHeight;

  // Aspect Ratio
  const showAspectRatioControl = useHasAspectRatio(settings);
  const aspectRatioValue = decodeValue(inheritedValue?.dimensions?.aspectRatio);
  const setAspectRatioValue = newValue =&gt; {
    const tempValue = setImmutably(value, [&#039;dimensions&#039;, &#039;aspectRatio&#039;], newValue);
    // Apply aspect-ratio, while removing any applied min-height.
    onChange(setImmutably(tempValue, [&#039;dimensions&#039;, &#039;minHeight&#039;], undefined));
  };
  const hasAspectRatioValue = () =&gt; !!value?.dimensions?.aspectRatio;

  // Child Layout
  const showChildLayoutControl = useHasChildLayout(settings);
  const childLayout = inheritedValue?.layout;
  const setChildLayout = newChildLayout =&gt; {
    onChange({
      ...value,
      layout: {
        ...newChildLayout
      }
    });
  };
  const resetAllFilter = (0,external_wp_element_namespaceObject.useCallback)(previousValue =&gt; {
    return {
      ...previousValue,
      layout: utils_cleanEmptyObject({
        ...previousValue?.layout,
        contentSize: undefined,
        wideSize: undefined,
        selfStretch: undefined,
        flexSize: undefined,
        columnStart: undefined,
        rowStart: undefined,
        columnSpan: undefined,
        rowSpan: undefined
      }),
      spacing: {
        ...previousValue?.spacing,
        padding: undefined,
        margin: undefined,
        blockGap: undefined
      },
      dimensions: {
        ...previousValue?.dimensions,
        minHeight: undefined,
        aspectRatio: undefined
      }
    };
  }, []);
  const onMouseLeaveControls = () =&gt; onVisualize(false);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(Wrapper, {
    resetAllFilter: resetAllFilter,
    value: value,
    onChange: onChange,
    panelId: panelId,
    children: [(showContentSizeControl || showWideSizeControl) &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;span&quot;, {
      className: &quot;span-columns&quot;,
      children: (0,external_wp_i18n_namespaceObject.__)(&#039;Set the width of the main content area.&#039;)
    }), showContentSizeControl &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanelItem, {
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Content width&#039;),
      hasValue: hasUserSetContentSizeValue,
      onDeselect: resetContentSizeValue,
      isShownByDefault: (_defaultControls$cont = defaultControls.contentSize) !== null &amp;&amp; _defaultControls$cont !== void 0 ? _defaultControls$cont : dimensions_panel_DEFAULT_CONTROLS.contentSize,
      panelId: panelId,
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalUnitControl, {
        __next40pxDefaultSize: true,
        label: (0,external_wp_i18n_namespaceObject.__)(&#039;Content width&#039;),
        labelPosition: &quot;top&quot;,
        value: contentSizeValue || &#039;&#039;,
        onChange: nextContentSize =&gt; {
          setContentSizeValue(nextContentSize);
        },
        units: units,
        prefix: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalInputControlPrefixWrapper, {
          variant: &quot;icon&quot;,
          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(build_module_icon, {
            icon: align_none
          })
        })
      })
    }), showWideSizeControl &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanelItem, {
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Wide width&#039;),
      hasValue: hasUserSetWideSizeValue,
      onDeselect: resetWideSizeValue,
      isShownByDefault: (_defaultControls$wide = defaultControls.wideSize) !== null &amp;&amp; _defaultControls$wide !== void 0 ? _defaultControls$wide : dimensions_panel_DEFAULT_CONTROLS.wideSize,
      panelId: panelId,
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalUnitControl, {
        __next40pxDefaultSize: true,
        label: (0,external_wp_i18n_namespaceObject.__)(&#039;Wide width&#039;),
        labelPosition: &quot;top&quot;,
        value: wideSizeValue || &#039;&#039;,
        onChange: nextWideSize =&gt; {
          setWideSizeValue(nextWideSize);
        },
        units: units,
        prefix: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalInputControlPrefixWrapper, {
          variant: &quot;icon&quot;,
          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(build_module_icon, {
            icon: stretch_wide
          })
        })
      })
    }), showPaddingControl &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalToolsPanelItem, {
      hasValue: hasPaddingValue,
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Padding&#039;),
      onDeselect: resetPaddingValue,
      isShownByDefault: (_defaultControls$padd = defaultControls.padding) !== null &amp;&amp; _defaultControls$padd !== void 0 ? _defaultControls$padd : dimensions_panel_DEFAULT_CONTROLS.padding,
      className: dist_clsx({
        &#039;tools-panel-item-spacing&#039;: showSpacingPresetsControl
      }),
      panelId: panelId,
      children: [!showSpacingPresetsControl &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.BoxControl, {
        __next40pxDefaultSize: true,
        values: paddingValues,
        onChange: setPaddingValues,
        label: (0,external_wp_i18n_namespaceObject.__)(&#039;Padding&#039;),
        sides: paddingSides,
        units: units,
        allowReset: false,
        splitOnAxis: isAxialPadding,
        inputProps: {
          onMouseOver: onMouseOverPadding,
          onMouseOut: onMouseLeaveControls
        }
      }), showSpacingPresetsControl &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(SpacingSizesControl, {
        values: paddingValues,
        onChange: setPaddingValues,
        label: (0,external_wp_i18n_namespaceObject.__)(&#039;Padding&#039;),
        sides: paddingSides,
        units: units,
        allowReset: false,
        onMouseOver: onMouseOverPadding,
        onMouseOut: onMouseLeaveControls
      })]
    }), showMarginControl &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalToolsPanelItem, {
      hasValue: hasMarginValue,
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Margin&#039;),
      onDeselect: resetMarginValue,
      isShownByDefault: (_defaultControls$marg = defaultControls.margin) !== null &amp;&amp; _defaultControls$marg !== void 0 ? _defaultControls$marg : dimensions_panel_DEFAULT_CONTROLS.margin,
      className: dist_clsx({
        &#039;tools-panel-item-spacing&#039;: showSpacingPresetsControl
      }),
      panelId: panelId,
      children: [!showSpacingPresetsControl &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.BoxControl, {
        __next40pxDefaultSize: true,
        values: marginValues,
        onChange: setMarginValues,
        inputProps: {
          min: minMarginValue,
          onDragStart: () =&gt; {
            // Reset to 0 in case the value was negative.
            setMinMarginValue(0);
          },
          onDragEnd: () =&gt; {
            setMinMarginValue(minimumMargin);
          },
          onMouseOver: onMouseOverMargin,
          onMouseOut: onMouseLeaveControls
        },
        label: (0,external_wp_i18n_namespaceObject.__)(&#039;Margin&#039;),
        sides: marginSides,
        units: units,
        allowReset: false,
        splitOnAxis: isAxialMargin
      }), showSpacingPresetsControl &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(SpacingSizesControl, {
        values: marginValues,
        onChange: setMarginValues,
        minimumCustomValue: -Infinity,
        label: (0,external_wp_i18n_namespaceObject.__)(&#039;Margin&#039;),
        sides: marginSides,
        units: units,
        allowReset: false,
        onMouseOver: onMouseOverMargin,
        onMouseOut: onMouseLeaveControls
      })]
    }), showGapControl &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalToolsPanelItem, {
      hasValue: hasGapValue,
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Block spacing&#039;),
      onDeselect: resetGapValue,
      isShownByDefault: (_defaultControls$bloc = defaultControls.blockGap) !== null &amp;&amp; _defaultControls$bloc !== void 0 ? _defaultControls$bloc : dimensions_panel_DEFAULT_CONTROLS.blockGap,
      className: dist_clsx({
        &#039;tools-panel-item-spacing&#039;: showSpacingPresetsControl,
        &#039;single-column&#039;:
        // If UnitControl is used, should be single-column.
        !showSpacingPresetsControl &amp;&amp; !isAxialGap
      }),
      panelId: panelId,
      children: [!showSpacingPresetsControl &amp;&amp; (isAxialGap ? /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.BoxControl, {
        __next40pxDefaultSize: true,
        label: (0,external_wp_i18n_namespaceObject.__)(&#039;Block spacing&#039;),
        min: 0,
        onChange: setGapValues,
        units: units,
        sides: gapSides,
        values: gapValues,
        allowReset: false,
        splitOnAxis: isAxialGap
      }) : /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalUnitControl, {
        __next40pxDefaultSize: true,
        label: (0,external_wp_i18n_namespaceObject.__)(&#039;Block spacing&#039;),
        min: 0,
        onChange: setGapValue,
        units: units,
        value: gapValue
      })), showSpacingPresetsControl &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(SpacingSizesControl, {
        label: (0,external_wp_i18n_namespaceObject.__)(&#039;Block spacing&#039;),
        min: 0,
        onChange: setGapValues,
        showSideInLabel: false,
        sides: isAxialGap ? gapSides : [&#039;top&#039;] // Use &#039;top&#039; as the shorthand property in non-axial configurations.
        ,
        values: gapValues,
        allowReset: false
      })]
    }), showChildLayoutControl &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ChildLayoutControl, {
      value: childLayout,
      onChange: setChildLayout,
      parentLayout: settings?.parentLayout,
      panelId: panelId,
      isShownByDefault: (_defaultControls$chil = defaultControls.childLayout) !== null &amp;&amp; _defaultControls$chil !== void 0 ? _defaultControls$chil : dimensions_panel_DEFAULT_CONTROLS.childLayout
    }), showMinHeightControl &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanelItem, {
      hasValue: hasMinHeightValue,
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Minimum height&#039;),
      onDeselect: resetMinHeightValue,
      isShownByDefault: (_defaultControls$minH = defaultControls.minHeight) !== null &amp;&amp; _defaultControls$minH !== void 0 ? _defaultControls$minH : dimensions_panel_DEFAULT_CONTROLS.minHeight,
      panelId: panelId,
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(HeightControl, {
        label: (0,external_wp_i18n_namespaceObject.__)(&#039;Minimum height&#039;),
        value: minHeightValue,
        onChange: setMinHeightValue
      })
    }), showAspectRatioControl &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(AspectRatioTool, {
      hasValue: hasAspectRatioValue,
      value: aspectRatioValue,
      onChange: setAspectRatioValue,
      panelId: panelId,
      isShownByDefault: (_defaultControls$aspe = defaultControls.aspectRatio) !== null &amp;&amp; _defaultControls$aspe !== void 0 ? _defaultControls$aspe : dimensions_panel_DEFAULT_CONTROLS.aspectRatio
    })]
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/block-popover/use-popover-scroll.js
/**
 * WordPress dependencies
 */


const scrollContainerCache = new WeakMap();

/**
 * Allow scrolling &quot;through&quot; popovers over the canvas. This is only called for
 * as long as the pointer is over a popover. Do not use React events because it
 * will bubble through portals.
 *
 * @param {Object} contentRef
 */
function usePopoverScroll(contentRef) {
  const effect = (0,external_wp_compose_namespaceObject.useRefEffect)(node =&gt; {
    function onWheel(event) {
      const {
        deltaX,
        deltaY
      } = event;
      const contentEl = contentRef.current;
      let scrollContainer = scrollContainerCache.get(contentEl);
      if (!scrollContainer) {
        scrollContainer = (0,external_wp_dom_namespaceObject.getScrollContainer)(contentEl);
        scrollContainerCache.set(contentEl, scrollContainer);
      }
      scrollContainer.scrollBy(deltaX, deltaY);
    }
    // Tell the browser that we do not call event.preventDefault
    // See https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener#improving_scrolling_performance_with_passive_listeners
    const options = {
      passive: true
    };
    node.addEventListener(&#039;wheel&#039;, onWheel, options);
    return () =&gt; {
      node.removeEventListener(&#039;wheel&#039;, onWheel, options);
    };
  }, [contentRef]);
  return contentRef ? effect : null;
}
/* harmony default export */ const use_popover_scroll = (usePopoverScroll);

;// ./node_modules/@wordpress/block-editor/build-module/utils/dom.js
const BLOCK_SELECTOR = &#039;.block-editor-block-list__block&#039;;
const APPENDER_SELECTOR = &#039;.block-list-appender&#039;;
const BLOCK_APPENDER_CLASS = &#039;.block-editor-button-block-appender&#039;;

/**
 * Returns true if two elements are contained within the same block.
 *
 * @param {Element} a First element.
 * @param {Element} b Second element.
 *
 * @return {boolean} Whether elements are in the same block.
 */
function isInSameBlock(a, b) {
  return a.closest(BLOCK_SELECTOR) === b.closest(BLOCK_SELECTOR);
}

/**
 * Returns true if an element is considered part of the block and not its inner
 * blocks or appender.
 *
 * @param {Element} blockElement Block container element.
 * @param {Element} element      Element.
 *
 * @return {boolean} Whether an element is considered part of the block and not
 *                   its inner blocks or appender.
 */
function isInsideRootBlock(blockElement, element) {
  const parentBlock = element.closest([BLOCK_SELECTOR, APPENDER_SELECTOR, BLOCK_APPENDER_CLASS].join(&#039;,&#039;));
  return parentBlock === blockElement;
}

/**
 * Finds the block client ID given any DOM node inside the block.
 *
 * @param {Node?} node DOM node.
 *
 * @return {string|undefined} Client ID or undefined if the node is not part of
 *                            a block.
 */
function getBlockClientId(node) {
  while (node &amp;&amp; node.nodeType !== node.ELEMENT_NODE) {
    node = node.parentNode;
  }
  if (!node) {
    return;
  }
  const elementNode = /** @type {Element} */node;
  const blockNode = elementNode.closest(BLOCK_SELECTOR);
  if (!blockNode) {
    return;
  }
  return blockNode.id.slice(&#039;block-&#039;.length);
}

/**
 * Calculates the union of two rectangles.
 *
 * @param {DOMRect} rect1 First rectangle.
 * @param {DOMRect} rect2 Second rectangle.
 * @return {DOMRect} Union of the two rectangles.
 */
function rectUnion(rect1, rect2) {
  const left = Math.min(rect1.left, rect2.left);
  const right = Math.max(rect1.right, rect2.right);
  const bottom = Math.max(rect1.bottom, rect2.bottom);
  const top = Math.min(rect1.top, rect2.top);
  return new window.DOMRectReadOnly(left, top, right - left, bottom - top);
}

/**
 * Returns whether an element is visible.
 *
 * @param {Element} element Element.
 * @return {boolean} Whether the element is visible.
 */
function isElementVisible(element) {
  const viewport = element.ownerDocument.defaultView;
  if (!viewport) {
    return false;
  }

  // Check for &lt;VisuallyHidden&gt; component.
  if (element.classList.contains(&#039;components-visually-hidden&#039;)) {
    return false;
  }
  const bounds = element.getBoundingClientRect();
  if (bounds.width === 0 || bounds.height === 0) {
    return false;
  }

  // Older browsers, e.g. Safari &lt; 17.4 may not support the `checkVisibility` method.
  if (element.checkVisibility) {
    return element.checkVisibility?.({
      opacityProperty: true,
      contentVisibilityAuto: true,
      visibilityProperty: true
    });
  }
  const style = viewport.getComputedStyle(element);
  if (style.display === &#039;none&#039; || style.visibility === &#039;hidden&#039; || style.opacity === &#039;0&#039;) {
    return false;
  }
  return true;
}

/**
 * Checks if the element is scrollable.
 *
 * @param {Element} element Element.
 * @return {boolean} True if the element is scrollable.
 */
function isScrollable(element) {
  const style = window.getComputedStyle(element);
  return style.overflowX === &#039;auto&#039; || style.overflowX === &#039;scroll&#039; || style.overflowY === &#039;auto&#039; || style.overflowY === &#039;scroll&#039;;
}
const WITH_OVERFLOW_ELEMENT_BLOCKS = [&#039;core/navigation&#039;];
/**
 * Returns the bounding rectangle of an element, with special handling for blocks
 * that have visible overflowing children (defined in WITH_OVERFLOW_ELEMENT_BLOCKS).
 *
 * For blocks like Navigation that can have overflowing elements (e.g. submenus),
 * this function calculates the combined bounds of both the parent and its visible
 * children. The returned rect may extend beyond the viewport.
 * The returned rect represents the full extent of the element and its visible
 * children, which may extend beyond the viewport.
 *
 * @param {Element} element Element.
 * @return {DOMRect} Bounding client rect of the element and its visible children.
 */
function getElementBounds(element) {
  const viewport = element.ownerDocument.defaultView;
  if (!viewport) {
    return new window.DOMRectReadOnly();
  }
  let bounds = element.getBoundingClientRect();
  const dataType = element.getAttribute(&#039;data-type&#039;);

  /*
   * For blocks with overflowing elements (like Navigation), include the bounds
   * of visible children that extend beyond the parent container.
   */
  if (dataType &amp;&amp; WITH_OVERFLOW_ELEMENT_BLOCKS.includes(dataType)) {
    const stack = [element];
    let currentElement;
    while (currentElement = stack.pop()) {
      // Children won’t affect bounds unless the element is not scrollable.
      if (!isScrollable(currentElement)) {
        for (const child of currentElement.children) {
          if (isElementVisible(child)) {
            const childBounds = child.getBoundingClientRect();
            bounds = rectUnion(bounds, childBounds);
            stack.push(child);
          }
        }
      }
    }
  }

  /*
   * Take into account the outer horizontal limits of the container in which
   * an element is supposed to be &quot;visible&quot;. For example, if an element is
   * positioned -10px to the left of the window x value (0), this function
   * discounts the negative overhang because it&#039;s not visible and therefore
   * not to be counted in the visibility calculations. Top and bottom values
   * are not accounted for to accommodate vertical scroll.
   */
  const left = Math.max(bounds.left, 0);
  const right = Math.min(bounds.right, viewport.innerWidth);
  bounds = new window.DOMRectReadOnly(left, bounds.top, right - left, bounds.height);
  return bounds;
}

;// ./node_modules/@wordpress/block-editor/build-module/components/block-popover/index.js
/**
 * External dependencies
 */


/**
 * WordPress dependencies
 */




/**
 * Internal dependencies
 */




const MAX_POPOVER_RECOMPUTE_COUNTER = Number.MAX_SAFE_INTEGER;
function BlockPopover({
  clientId,
  bottomClientId,
  children,
  __unstablePopoverSlot,
  __unstableContentRef,
  shift = true,
  ...props
}, ref) {
  const selectedElement = useBlockElement(clientId);
  const lastSelectedElement = useBlockElement(bottomClientId !== null &amp;&amp; bottomClientId !== void 0 ? bottomClientId : clientId);
  const mergedRefs = (0,external_wp_compose_namespaceObject.useMergeRefs)([ref, use_popover_scroll(__unstableContentRef)]);
  const [popoverDimensionsRecomputeCounter, forceRecomputePopoverDimensions] = (0,external_wp_element_namespaceObject.useReducer)(
  // Module is there to make sure that the counter doesn&#039;t overflow.
  s =&gt; (s + 1) % MAX_POPOVER_RECOMPUTE_COUNTER, 0);

  // When blocks are moved up/down, they are animated to their new position by
  // updating the `transform` property manually (i.e. without using CSS
  // transitions or animations). The animation, which can also scroll the block
  // editor, can sometimes cause the position of the Popover to get out of sync.
  // A MutationObserver is therefore used to make sure that changes to the
  // selectedElement&#039;s attribute (i.e. `transform`) can be tracked and used to
  // trigger the Popover to rerender.
  (0,external_wp_element_namespaceObject.useLayoutEffect)(() =&gt; {
    if (!selectedElement) {
      return;
    }
    const observer = new window.MutationObserver(forceRecomputePopoverDimensions);
    observer.observe(selectedElement, {
      attributes: true
    });
    return () =&gt; {
      observer.disconnect();
    };
  }, [selectedElement]);
  const popoverAnchor = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; {
    if (
    // popoverDimensionsRecomputeCounter is by definition always equal or greater
    // than 0. This check is only there to satisfy the correctness of the
    // exhaustive-deps rule for the `useMemo` hook.
    popoverDimensionsRecomputeCounter &lt; 0 || !selectedElement || bottomClientId &amp;&amp; !lastSelectedElement) {
      return undefined;
    }
    return {
      getBoundingClientRect() {
        return lastSelectedElement ? rectUnion(getElementBounds(selectedElement), getElementBounds(lastSelectedElement)) : getElementBounds(selectedElement);
      },
      contextElement: selectedElement
    };
  }, [popoverDimensionsRecomputeCounter, selectedElement, bottomClientId, lastSelectedElement]);
  if (!selectedElement || bottomClientId &amp;&amp; !lastSelectedElement) {
    return null;
  }
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Popover, {
    ref: mergedRefs,
    animate: false,
    focusOnMount: false,
    anchor: popoverAnchor
    // Render in the old slot if needed for backward compatibility,
    // otherwise render in place (not in the default popover slot).
    ,
    __unstableSlotName: __unstablePopoverSlot,
    inline: !__unstablePopoverSlot,
    placement: &quot;top-start&quot;,
    resize: false,
    flip: false,
    shift: shift,
    ...props,
    className: dist_clsx(&#039;block-editor-block-popover&#039;, props.className),
    variant: &quot;unstyled&quot;,
    children: children
  });
}
const PrivateBlockPopover = (0,external_wp_element_namespaceObject.forwardRef)(BlockPopover);
const PublicBlockPopover = ({
  clientId,
  bottomClientId,
  children,
  ...props
}, ref) =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PrivateBlockPopover, {
  ...props,
  bottomClientId: bottomClientId,
  clientId: clientId,
  __unstableContentRef: undefined,
  __unstablePopoverSlot: undefined,
  ref: ref,
  children: children
});

/**
 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/block-popover/README.md
 */
/* harmony default export */ const block_popover = ((0,external_wp_element_namespaceObject.forwardRef)(PublicBlockPopover));

;// ./node_modules/@wordpress/block-editor/build-module/components/block-popover/cover.js
/**
 * WordPress dependencies
 */


/**
 * Internal dependencies
 */



function BlockPopoverCover({
  clientId,
  bottomClientId,
  children,
  shift = false,
  additionalStyles,
  ...props
}, ref) {
  var _bottomClientId;
  (_bottomClientId = bottomClientId) !== null &amp;&amp; _bottomClientId !== void 0 ? _bottomClientId : bottomClientId = clientId;
  const selectedElement = useBlockElement(clientId);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PrivateBlockPopover, {
    ref: ref,
    clientId: clientId,
    bottomClientId: bottomClientId,
    shift: shift,
    ...props,
    children: selectedElement &amp;&amp; clientId === bottomClientId ? /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(CoverContainer, {
      selectedElement: selectedElement,
      additionalStyles: additionalStyles,
      children: children
    }) : children
  });
}
function CoverContainer({
  selectedElement,
  additionalStyles = {},
  children
}) {
  const [width, setWidth] = (0,external_wp_element_namespaceObject.useState)(selectedElement.offsetWidth);
  const [height, setHeight] = (0,external_wp_element_namespaceObject.useState)(selectedElement.offsetHeight);
  (0,external_wp_element_namespaceObject.useEffect)(() =&gt; {
    const observer = new window.ResizeObserver(() =&gt; {
      setWidth(selectedElement.offsetWidth);
      setHeight(selectedElement.offsetHeight);
    });
    observer.observe(selectedElement, {
      box: &#039;border-box&#039;
    });
    return () =&gt; observer.disconnect();
  }, [selectedElement]);
  const style = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; {
    return {
      position: &#039;absolute&#039;,
      width,
      height,
      ...additionalStyles
    };
  }, [width, height, additionalStyles]);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
    style: style,
    children: children
  });
}
/* harmony default export */ const cover = ((0,external_wp_element_namespaceObject.forwardRef)(BlockPopoverCover));

;// ./node_modules/@wordpress/block-editor/build-module/hooks/spacing-visualizer.js
/**
 * WordPress dependencies
 */



/**
 * Internal dependencies
 */



function SpacingVisualizer({
  clientId,
  value,
  computeStyle,
  forceShow
}) {
  const blockElement = useBlockElement(clientId);
  const [style, updateStyle] = (0,external_wp_element_namespaceObject.useReducer)(() =&gt; computeStyle(blockElement));
  (0,external_wp_element_namespaceObject.useLayoutEffect)(() =&gt; {
    if (!blockElement) {
      return;
    }
    // It&#039;s not sufficient to read the computed spacing value when value.spacing changes as
    // useEffect may run before the browser recomputes CSS. We therefore combine
    // useLayoutEffect and two rAF calls to ensure that we read the spacing after the current
    // paint but before the next paint.
    // See https://github.com/WordPress/gutenberg/pull/59227.
    window.requestAnimationFrame(() =&gt; window.requestAnimationFrame(updateStyle));
  }, [blockElement, value]);
  const previousValueRef = (0,external_wp_element_namespaceObject.useRef)(value);
  const [isActive, setIsActive] = (0,external_wp_element_namespaceObject.useState)(false);
  (0,external_wp_element_namespaceObject.useEffect)(() =&gt; {
    if (external_wp_isShallowEqual_default()(value, previousValueRef.current) || forceShow) {
      return;
    }
    setIsActive(true);
    previousValueRef.current = value;
    const timeout = setTimeout(() =&gt; {
      setIsActive(false);
    }, 400);
    return () =&gt; {
      setIsActive(false);
      clearTimeout(timeout);
    };
  }, [value, forceShow]);
  if (!isActive &amp;&amp; !forceShow) {
    return null;
  }
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(cover, {
    clientId: clientId,
    __unstablePopoverSlot: &quot;block-toolbar&quot;,
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
      className: &quot;block-editor__spacing-visualizer&quot;,
      style: style
    })
  });
}
function getComputedCSS(element, property) {
  return element.ownerDocument.defaultView.getComputedStyle(element).getPropertyValue(property);
}
function MarginVisualizer({
  clientId,
  value,
  forceShow
}) {
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(SpacingVisualizer, {
    clientId: clientId,
    value: value?.spacing?.margin,
    computeStyle: blockElement =&gt; {
      const top = getComputedCSS(blockElement, &#039;margin-top&#039;);
      const right = getComputedCSS(blockElement, &#039;margin-right&#039;);
      const bottom = getComputedCSS(blockElement, &#039;margin-bottom&#039;);
      const left = getComputedCSS(blockElement, &#039;margin-left&#039;);
      return {
        borderTopWidth: top,
        borderRightWidth: right,
        borderBottomWidth: bottom,
        borderLeftWidth: left,
        top: top ? `-${top}` : 0,
        right: right ? `-${right}` : 0,
        bottom: bottom ? `-${bottom}` : 0,
        left: left ? `-${left}` : 0
      };
    },
    forceShow: forceShow
  });
}
function PaddingVisualizer({
  clientId,
  value,
  forceShow
}) {
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(SpacingVisualizer, {
    clientId: clientId,
    value: value?.spacing?.padding,
    computeStyle: blockElement =&gt; ({
      borderTopWidth: getComputedCSS(blockElement, &#039;padding-top&#039;),
      borderRightWidth: getComputedCSS(blockElement, &#039;padding-right&#039;),
      borderBottomWidth: getComputedCSS(blockElement, &#039;padding-bottom&#039;),
      borderLeftWidth: getComputedCSS(blockElement, &#039;padding-left&#039;)
    }),
    forceShow: forceShow
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/hooks/dimensions.js
/**
 * External dependencies
 */


/**
 * WordPress dependencies
 */





/**
 * Internal dependencies
 */







const DIMENSIONS_SUPPORT_KEY = &#039;dimensions&#039;;
const SPACING_SUPPORT_KEY = &#039;spacing&#039;;
const dimensions_ALL_SIDES = (/* unused pure expression or super */ null &amp;&amp; ([&#039;top&#039;, &#039;right&#039;, &#039;bottom&#039;, &#039;left&#039;]));
const dimensions_AXIAL_SIDES = (/* unused pure expression or super */ null &amp;&amp; ([&#039;vertical&#039;, &#039;horizontal&#039;]));
function useVisualizer() {
  const [property, setProperty] = (0,external_wp_element_namespaceObject.useState)(false);
  const {
    hideBlockInterface,
    showBlockInterface
  } = unlock((0,external_wp_data_namespaceObject.useDispatch)(store));
  (0,external_wp_element_namespaceObject.useEffect)(() =&gt; {
    if (!property) {
      showBlockInterface();
    } else {
      hideBlockInterface();
    }
  }, [property, showBlockInterface, hideBlockInterface]);
  return [property, setProperty];
}
function DimensionsInspectorControl({
  children,
  resetAllFilter
}) {
  const attributesResetAllFilter = (0,external_wp_element_namespaceObject.useCallback)(attributes =&gt; {
    const existingStyle = attributes.style;
    const updatedStyle = resetAllFilter(existingStyle);
    return {
      ...attributes,
      style: updatedStyle
    };
  }, [resetAllFilter]);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls, {
    group: &quot;dimensions&quot;,
    resetAllFilter: attributesResetAllFilter,
    children: children
  });
}
function dimensions_DimensionsPanel({
  clientId,
  name,
  setAttributes,
  settings
}) {
  const isEnabled = useHasDimensionsPanel(settings);
  const value = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; select(store).getBlockAttributes(clientId)?.style, [clientId]);
  const [visualizedProperty, setVisualizedProperty] = useVisualizer();
  const onChange = newStyle =&gt; {
    setAttributes({
      style: utils_cleanEmptyObject(newStyle)
    });
  };
  if (!isEnabled) {
    return null;
  }
  const defaultDimensionsControls = (0,external_wp_blocks_namespaceObject.getBlockSupport)(name, [DIMENSIONS_SUPPORT_KEY, &#039;__experimentalDefaultControls&#039;]);
  const defaultSpacingControls = (0,external_wp_blocks_namespaceObject.getBlockSupport)(name, [SPACING_SUPPORT_KEY, &#039;__experimentalDefaultControls&#039;]);
  const defaultControls = {
    ...defaultDimensionsControls,
    ...defaultSpacingControls
  };
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(DimensionsPanel, {
      as: DimensionsInspectorControl,
      panelId: clientId,
      settings: settings,
      value: value,
      onChange: onChange,
      defaultControls: defaultControls,
      onVisualize: setVisualizedProperty
    }), !!settings?.spacing?.padding &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PaddingVisualizer, {
      forceShow: visualizedProperty === &#039;padding&#039;,
      clientId: clientId,
      value: value
    }), !!settings?.spacing?.margin &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(MarginVisualizer, {
      forceShow: visualizedProperty === &#039;margin&#039;,
      clientId: clientId,
      value: value
    })]
  });
}

/**
 * Determine whether there is block support for dimensions.
 *
 * @param {string} blockName Block name.
 * @param {string} feature   Background image feature to check for.
 *
 * @return {boolean} Whether there is support.
 */
function hasDimensionsSupport(blockName, feature = &#039;any&#039;) {
  if (external_wp_element_namespaceObject.Platform.OS !== &#039;web&#039;) {
    return false;
  }
  const support = (0,external_wp_blocks_namespaceObject.getBlockSupport)(blockName, DIMENSIONS_SUPPORT_KEY);
  if (support === true) {
    return true;
  }
  if (feature === &#039;any&#039;) {
    return !!(support?.aspectRatio || !!support?.minHeight);
  }
  return !!support?.[feature];
}
/* harmony default export */ const dimensions = ({
  useBlockProps: dimensions_useBlockProps,
  attributeKeys: [&#039;minHeight&#039;, &#039;style&#039;],
  hasSupport(name) {
    return hasDimensionsSupport(name, &#039;aspectRatio&#039;);
  }
});
function dimensions_useBlockProps({
  name,
  minHeight,
  style
}) {
  if (!hasDimensionsSupport(name, &#039;aspectRatio&#039;) || shouldSkipSerialization(name, DIMENSIONS_SUPPORT_KEY, &#039;aspectRatio&#039;)) {
    return {};
  }
  const className = dist_clsx({
    &#039;has-aspect-ratio&#039;: !!style?.dimensions?.aspectRatio
  });

  // Allow dimensions-based inline style overrides to override any global styles rules that
  // might be set for the block, and therefore affect the display of the aspect ratio.
  const inlineStyleOverrides = {};

  // Apply rules to unset incompatible styles.
  // Note that a set `aspectRatio` will win out if both an aspect ratio and a minHeight are set.
  // This is because the aspect ratio is a newer block support, so (in theory) any aspect ratio
  // that is set should be intentional and should override any existing minHeight. The Cover block
  // and dimensions controls have logic that will manually clear the aspect ratio if a minHeight
  // is set.
  if (style?.dimensions?.aspectRatio) {
    // To ensure the aspect ratio does not get overridden by `minHeight` unset any existing rule.
    inlineStyleOverrides.minHeight = &#039;unset&#039;;
  } else if (minHeight || style?.dimensions?.minHeight) {
    // To ensure the minHeight does not get overridden by `aspectRatio` unset any existing rule.
    inlineStyleOverrides.aspectRatio = &#039;unset&#039;;
  }
  return {
    className,
    style: inlineStyleOverrides
  };
}

/**
 * @deprecated
 */
function useCustomSides() {
  external_wp_deprecated_default()(&#039;wp.blockEditor.__experimentalUseCustomSides&#039;, {
    since: &#039;6.3&#039;,
    version: &#039;6.4&#039;
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/hooks/style.js
/**
 * WordPress dependencies
 */






/**
 * Internal dependencies
 */









const styleSupportKeys = [...TYPOGRAPHY_SUPPORT_KEYS, BORDER_SUPPORT_KEY, COLOR_SUPPORT_KEY, DIMENSIONS_SUPPORT_KEY, BACKGROUND_SUPPORT_KEY, SPACING_SUPPORT_KEY, SHADOW_SUPPORT_KEY];
const hasStyleSupport = nameOrType =&gt; styleSupportKeys.some(key =&gt; (0,external_wp_blocks_namespaceObject.hasBlockSupport)(nameOrType, key));

/**
 * Returns the inline styles to add depending on the style object
 *
 * @param {Object} styles Styles configuration.
 *
 * @return {Object} Flattened CSS variables declaration.
 */
function getInlineStyles(styles = {}) {
  const output = {};
  // The goal is to move everything to server side generated engine styles
  // This is temporary as we absorb more and more styles into the engine.
  (0,external_wp_styleEngine_namespaceObject.getCSSRules)(styles).forEach(rule =&gt; {
    output[rule.key] = rule.value;
  });
  return output;
}

/**
 * Filters registered block settings, extending attributes to include `style` attribute.
 *
 * @param {Object} settings Original block settings.
 *
 * @return {Object} Filtered block settings.
 */
function style_addAttribute(settings) {
  if (!hasStyleSupport(settings)) {
    return settings;
  }

  // Allow blocks to specify their own attribute definition with default values if needed.
  if (!settings.attributes.style) {
    Object.assign(settings.attributes, {
      style: {
        type: &#039;object&#039;
      }
    });
  }
  return settings;
}

/**
 * A dictionary of paths to flag skipping block support serialization as the key,
 * with values providing the style paths to be omitted from serialization.
 *
 * @constant
 * @type {Record&lt;string, string[]&gt;}
 */
const skipSerializationPathsEdit = {
  [`${BORDER_SUPPORT_KEY}.__experimentalSkipSerialization`]: [&#039;border&#039;],
  [`${COLOR_SUPPORT_KEY}.__experimentalSkipSerialization`]: [COLOR_SUPPORT_KEY],
  [`${TYPOGRAPHY_SUPPORT_KEY}.__experimentalSkipSerialization`]: [TYPOGRAPHY_SUPPORT_KEY],
  [`${DIMENSIONS_SUPPORT_KEY}.__experimentalSkipSerialization`]: [DIMENSIONS_SUPPORT_KEY],
  [`${SPACING_SUPPORT_KEY}.__experimentalSkipSerialization`]: [SPACING_SUPPORT_KEY],
  [`${SHADOW_SUPPORT_KEY}.__experimentalSkipSerialization`]: [SHADOW_SUPPORT_KEY]
};

/**
 * A dictionary of paths to flag skipping block support serialization as the key,
 * with values providing the style paths to be omitted from serialization.
 *
 * Extends the Edit skip paths to enable skipping additional paths in just
 * the Save component. This allows a block support to be serialized within the
 * editor, while using an alternate approach, such as server-side rendering, when
 * the support is saved.
 *
 * @constant
 * @type {Record&lt;string, string[]&gt;}
 */
const skipSerializationPathsSave = {
  ...skipSerializationPathsEdit,
  [`${DIMENSIONS_SUPPORT_KEY}.aspectRatio`]: [`${DIMENSIONS_SUPPORT_KEY}.aspectRatio`],
  // Skip serialization of aspect ratio in save mode.
  [`${BACKGROUND_SUPPORT_KEY}`]: [BACKGROUND_SUPPORT_KEY] // Skip serialization of background support in save mode.
};
const skipSerializationPathsSaveChecks = {
  [`${DIMENSIONS_SUPPORT_KEY}.aspectRatio`]: true,
  [`${BACKGROUND_SUPPORT_KEY}`]: true
};

/**
 * A dictionary used to normalize feature names between support flags, style
 * object properties and __experimentSkipSerialization configuration arrays.
 *
 * This allows not having to provide a migration for a support flag and possible
 * backwards compatibility bridges, while still achieving consistency between
 * the support flag and the skip serialization array.
 *
 * @constant
 * @type {Record&lt;string, string&gt;}
 */
const renamedFeatures = {
  gradients: &#039;gradient&#039;
};

/**
 * A utility function used to remove one or more paths from a style object.
 * Works in a way similar to Lodash&#039;s `omit()`. See unit tests and examples below.
 *
 * It supports a single string path:
 *
 * ```
 * omitStyle( { color: &#039;red&#039; }, &#039;color&#039; ); // {}
 * ```
 *
 * or an array of paths:
 *
 * ```
 * omitStyle( { color: &#039;red&#039;, background: &#039;#fff&#039; }, [ &#039;color&#039;, &#039;background&#039; ] ); // {}
 * ```
 *
 * It also allows you to specify paths at multiple levels in a string.
 *
 * ```
 * omitStyle( { typography: { textDecoration: &#039;underline&#039; } }, &#039;typography.textDecoration&#039; ); // {}
 * ```
 *
 * You can remove multiple paths at the same time:
 *
 * ```
 * omitStyle(
 * 		{
 * 			typography: {
 * 				textDecoration: &#039;underline&#039;,
 * 				textTransform: &#039;uppercase&#039;,
 * 			}
 *		},
 *		[
 * 			&#039;typography.textDecoration&#039;,
 * 			&#039;typography.textTransform&#039;,
 *		]
 * );
 * // {}
 * ```
 *
 * You can also specify nested paths as arrays:
 *
 * ```
 * omitStyle(
 * 		{
 * 			typography: {
 * 				textDecoration: &#039;underline&#039;,
 * 				textTransform: &#039;uppercase&#039;,
 * 			}
 *		},
 *		[
 * 			[ &#039;typography&#039;, &#039;textDecoration&#039; ],
 * 			[ &#039;typography&#039;, &#039;textTransform&#039; ],
 *		]
 * );
 * // {}
 * ```
 *
 * With regards to nesting of styles, infinite depth is supported:
 *
 * ```
 * omitStyle(
 * 		{
 * 			border: {
 * 				radius: {
 * 					topLeft: &#039;10px&#039;,
 * 					topRight: &#039;0.5rem&#039;,
 * 				}
 * 			}
 *		},
 *		[
 * 			[ &#039;border&#039;, &#039;radius&#039;, &#039;topRight&#039; ],
 *		]
 * );
 * // { border: { radius: { topLeft: &#039;10px&#039; } } }
 * ```
 *
 * The third argument, `preserveReference`, defines how to treat the input style object.
 * It is mostly necessary to properly handle mutation when recursively handling the style object.
 * Defaulting to `false`, this will always create a new object, avoiding to mutate `style`.
 * However, when recursing, we change that value to `true` in order to work with a single copy
 * of the original style object.
 *
 * @see https://lodash.com/docs/4.17.15#omit
 *
 * @param {Object}       style             Styles object.
 * @param {Array|string} paths             Paths to remove.
 * @param {boolean}      preserveReference True to mutate the `style` object, false otherwise.
 * @return {Object}      Styles object with the specified paths removed.
 */
function omitStyle(style, paths, preserveReference = false) {
  if (!style) {
    return style;
  }
  let newStyle = style;
  if (!preserveReference) {
    newStyle = JSON.parse(JSON.stringify(style));
  }
  if (!Array.isArray(paths)) {
    paths = [paths];
  }
  paths.forEach(path =&gt; {
    if (!Array.isArray(path)) {
      path = path.split(&#039;.&#039;);
    }
    if (path.length &gt; 1) {
      const [firstSubpath, ...restPath] = path;
      omitStyle(newStyle[firstSubpath], [restPath], true);
    } else if (path.length === 1) {
      delete newStyle[path[0]];
    }
  });
  return newStyle;
}

/**
 * Override props assigned to save component to inject the CSS variables definition.
 *
 * @param {Object}                    props           Additional props applied to save element.
 * @param {Object|string}             blockNameOrType Block type.
 * @param {Object}                    attributes      Block attributes.
 * @param {?Record&lt;string, string[]&gt;} skipPaths       An object of keys and paths to skip serialization.
 *
 * @return {Object} Filtered props applied to save element.
 */
function style_addSaveProps(props, blockNameOrType, attributes, skipPaths = skipSerializationPathsSave) {
  if (!hasStyleSupport(blockNameOrType)) {
    return props;
  }
  let {
    style
  } = attributes;
  Object.entries(skipPaths).forEach(([indicator, path]) =&gt; {
    const skipSerialization = skipSerializationPathsSaveChecks[indicator] || (0,external_wp_blocks_namespaceObject.getBlockSupport)(blockNameOrType, indicator);
    if (skipSerialization === true) {
      style = omitStyle(style, path);
    }
    if (Array.isArray(skipSerialization)) {
      skipSerialization.forEach(featureName =&gt; {
        const feature = renamedFeatures[featureName] || featureName;
        style = omitStyle(style, [[...path, feature]]);
      });
    }
  });
  props.style = {
    ...getInlineStyles(style),
    ...props.style
  };
  return props;
}
function BlockStyleControls({
  clientId,
  name,
  setAttributes,
  __unstableParentLayout
}) {
  const settings = useBlockSettings(name, __unstableParentLayout);
  const blockEditingMode = useBlockEditingMode();
  const passedProps = {
    clientId,
    name,
    setAttributes,
    settings: {
      ...settings,
      typography: {
        ...settings.typography,
        // The text alignment UI for individual blocks is rendered in
        // the block toolbar, so disable it here.
        textAlign: false
      }
    }
  };
  if (blockEditingMode !== &#039;default&#039;) {
    return null;
  }
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ColorEdit, {
      ...passedProps
    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(background_BackgroundImagePanel, {
      ...passedProps
    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(typography_TypographyPanel, {
      ...passedProps
    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(border_BorderPanel, {
      ...passedProps
    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(dimensions_DimensionsPanel, {
      ...passedProps
    })]
  });
}
/* harmony default export */ const style = ({
  edit: BlockStyleControls,
  hasSupport: hasStyleSupport,
  addSaveProps: style_addSaveProps,
  attributeKeys: [&#039;style&#039;],
  useBlockProps: style_useBlockProps
});

// Defines which element types are supported, including their hover styles or
// any other elements that have been included under a single element type
// e.g. heading and h1-h6.
const elementTypes = [{
  elementType: &#039;button&#039;
}, {
  elementType: &#039;link&#039;,
  pseudo: [&#039;:hover&#039;]
}, {
  elementType: &#039;heading&#039;,
  elements: [&#039;h1&#039;, &#039;h2&#039;, &#039;h3&#039;, &#039;h4&#039;, &#039;h5&#039;, &#039;h6&#039;]
}];

// Used for generating the instance ID
const STYLE_BLOCK_PROPS_REFERENCE = {};
function style_useBlockProps({
  name,
  style
}) {
  const blockElementsContainerIdentifier = (0,external_wp_compose_namespaceObject.useInstanceId)(STYLE_BLOCK_PROPS_REFERENCE, &#039;wp-elements&#039;);
  const baseElementSelector = `.${blockElementsContainerIdentifier}`;
  const blockElementStyles = style?.elements;
  const styles = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; {
    if (!blockElementStyles) {
      return;
    }
    const elementCSSRules = [];
    elementTypes.forEach(({
      elementType,
      pseudo,
      elements
    }) =&gt; {
      const skipSerialization = shouldSkipSerialization(name, COLOR_SUPPORT_KEY, elementType);
      if (skipSerialization) {
        return;
      }
      const elementStyles = blockElementStyles?.[elementType];

      // Process primary element type styles.
      if (elementStyles) {
        const selector = scopeSelector(baseElementSelector, external_wp_blocks_namespaceObject.__EXPERIMENTAL_ELEMENTS[elementType]);
        elementCSSRules.push((0,external_wp_styleEngine_namespaceObject.compileCSS)(elementStyles, {
          selector
        }));

        // Process any interactive states for the element type.
        if (pseudo) {
          pseudo.forEach(pseudoSelector =&gt; {
            if (elementStyles[pseudoSelector]) {
              elementCSSRules.push((0,external_wp_styleEngine_namespaceObject.compileCSS)(elementStyles[pseudoSelector], {
                selector: scopeSelector(baseElementSelector, `${external_wp_blocks_namespaceObject.__EXPERIMENTAL_ELEMENTS[elementType]}${pseudoSelector}`)
              }));
            }
          });
        }
      }

      // Process related elements e.g. h1-h6 for headings
      if (elements) {
        elements.forEach(element =&gt; {
          if (blockElementStyles[element]) {
            elementCSSRules.push((0,external_wp_styleEngine_namespaceObject.compileCSS)(blockElementStyles[element], {
              selector: scopeSelector(baseElementSelector, external_wp_blocks_namespaceObject.__EXPERIMENTAL_ELEMENTS[element])
            }));
          }
        });
      }
    });
    return elementCSSRules.length &gt; 0 ? elementCSSRules.join(&#039;&#039;) : undefined;
  }, [baseElementSelector, blockElementStyles, name]);
  useStyleOverride({
    css: styles
  });
  return style_addSaveProps({
    className: blockElementsContainerIdentifier
  }, name, {
    style
  }, skipSerializationPathsEdit);
}
(0,external_wp_hooks_namespaceObject.addFilter)(&#039;blocks.registerBlockType&#039;, &#039;core/style/addAttribute&#039;, style_addAttribute);

;// ./node_modules/@wordpress/block-editor/build-module/hooks/settings.js
/**
 * WordPress dependencies
 */


const hasSettingsSupport = blockType =&gt; (0,external_wp_blocks_namespaceObject.hasBlockSupport)(blockType, &#039;__experimentalSettings&#039;, false);
function settings_addAttribute(settings) {
  if (!hasSettingsSupport(settings)) {
    return settings;
  }

  // Allow blocks to specify their own attribute definition with default values if needed.
  if (!settings?.attributes?.settings) {
    settings.attributes = {
      ...settings.attributes,
      settings: {
        type: &#039;object&#039;
      }
    };
  }
  return settings;
}
(0,external_wp_hooks_namespaceObject.addFilter)(&#039;blocks.registerBlockType&#039;, &#039;core/settings/addAttribute&#039;, settings_addAttribute);

;// ./node_modules/@wordpress/icons/build-module/library/filter.js
/**
 * WordPress dependencies
 */


const filter = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;M12 4 4 19h16L12 4zm0 3.2 5.5 10.3H12V7.2z&quot;
  })
});
/* harmony default export */ const library_filter = (filter);

;// ./node_modules/@wordpress/block-editor/build-module/components/duotone-control/index.js
/**
 * WordPress dependencies
 */






function DuotoneControl({
  id: idProp,
  colorPalette,
  duotonePalette,
  disableCustomColors,
  disableCustomDuotone,
  value,
  onChange
}) {
  let toolbarIcon;
  if (value === &#039;unset&#039;) {
    toolbarIcon = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ColorIndicator, {
      className: &quot;block-editor-duotone-control__unset-indicator&quot;
    });
  } else if (value) {
    toolbarIcon = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.DuotoneSwatch, {
      values: value
    });
  } else {
    toolbarIcon = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(build_module_icon, {
      icon: library_filter
    });
  }
  const actionLabel = (0,external_wp_i18n_namespaceObject.__)(&#039;Apply duotone filter&#039;);
  const id = (0,external_wp_compose_namespaceObject.useInstanceId)(DuotoneControl, &#039;duotone-control&#039;, idProp);
  const descriptionId = `${id}__description`;
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Dropdown, {
    popoverProps: {
      className: &#039;block-editor-duotone-control__popover&#039;,
      headerTitle: (0,external_wp_i18n_namespaceObject.__)(&#039;Duotone&#039;)
    },
    renderToggle: ({
      isOpen,
      onToggle
    }) =&gt; {
      const openOnArrowDown = event =&gt; {
        if (!isOpen &amp;&amp; event.keyCode === external_wp_keycodes_namespaceObject.DOWN) {
          event.preventDefault();
          onToggle();
        }
      };
      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarButton, {
        showTooltip: true,
        onClick: onToggle,
        &quot;aria-haspopup&quot;: &quot;true&quot;,
        &quot;aria-expanded&quot;: isOpen,
        onKeyDown: openOnArrowDown,
        label: actionLabel,
        icon: toolbarIcon
      });
    },
    renderContent: () =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.MenuGroup, {
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Duotone&#039;),
      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;p&quot;, {
        children: (0,external_wp_i18n_namespaceObject.__)(&#039;Create a two-tone color effect without losing your original image.&#039;)
      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.DuotonePicker, {
        &quot;aria-label&quot;: actionLabel,
        &quot;aria-describedby&quot;: descriptionId,
        colorPalette: colorPalette,
        duotonePalette: duotonePalette,
        disableCustomColors: disableCustomColors,
        disableCustomDuotone: disableCustomDuotone,
        value: value,
        onChange: onChange
      })]
    })
  });
}
/* harmony default export */ const duotone_control = (DuotoneControl);

;// ./node_modules/@wordpress/block-editor/build-module/components/duotone/utils.js
/**
 * External dependencies
 */


/**
 * Convert a list of colors to an object of R, G, and B values.
 *
 * @param {string[]} colors Array of RBG color strings.
 *
 * @return {Object} R, G, and B values.
 */
function getValuesFromColors(colors = []) {
  const values = {
    r: [],
    g: [],
    b: [],
    a: []
  };
  colors.forEach(color =&gt; {
    const rgbColor = w(color).toRgb();
    values.r.push(rgbColor.r / 255);
    values.g.push(rgbColor.g / 255);
    values.b.push(rgbColor.b / 255);
    values.a.push(rgbColor.a);
  });
  return values;
}

/**
 * Stylesheet for disabling a global styles duotone filter.
 *
 * @param {string} selector Selector to disable the filter for.
 *
 * @return {string} Filter none style.
 */
function getDuotoneUnsetStylesheet(selector) {
  return `${selector}{filter:none}`;
}

/**
 * SVG and stylesheet needed for rendering the duotone filter.
 *
 * @param {string} selector Selector to apply the filter to.
 * @param {string} id       Unique id for this duotone filter.
 *
 * @return {string} Duotone filter style.
 */
function getDuotoneStylesheet(selector, id) {
  return `${selector}{filter:url(#${id})}`;
}

/**
 * The SVG part of the duotone filter.
 *
 * @param {string}   id     Unique id for this duotone filter.
 * @param {string[]} colors Color strings from dark to light.
 *
 * @return {string} Duotone SVG.
 */
function getDuotoneFilter(id, colors) {
  const values = getValuesFromColors(colors);
  return `
&lt;svg
	xmlns:xlink=&quot;http://www.w3.org/1999/xlink&quot;
	viewBox=&quot;0 0 0 0&quot;
	width=&quot;0&quot;
	height=&quot;0&quot;
	focusable=&quot;false&quot;
	role=&quot;none&quot;
	aria-hidden=&quot;true&quot;
	style=&quot;visibility: hidden; position: absolute; left: -9999px; overflow: hidden;&quot;
&gt;
	&lt;defs&gt;
		&lt;filter id=&quot;${id}&quot;&gt;
			&lt;!--
				Use sRGB instead of linearRGB so transparency looks correct.
				Use perceptual brightness to convert to grayscale.
			--&gt;
			&lt;feColorMatrix color-interpolation-filters=&quot;sRGB&quot; type=&quot;matrix&quot; values=&quot; .299 .587 .114 0 0 .299 .587 .114 0 0 .299 .587 .114 0 0 .299 .587 .114 0 0 &quot;&gt;&lt;/feColorMatrix&gt;
			&lt;!-- Use sRGB instead of linearRGB to be consistent with how CSS gradients work. --&gt;
			&lt;feComponentTransfer color-interpolation-filters=&quot;sRGB&quot;&gt;
				&lt;feFuncR type=&quot;table&quot; tableValues=&quot;${values.r.join(&#039; &#039;)}&quot;&gt;&lt;/feFuncR&gt;
				&lt;feFuncG type=&quot;table&quot; tableValues=&quot;${values.g.join(&#039; &#039;)}&quot;&gt;&lt;/feFuncG&gt;
				&lt;feFuncB type=&quot;table&quot; tableValues=&quot;${values.b.join(&#039; &#039;)}&quot;&gt;&lt;/feFuncB&gt;
				&lt;feFuncA type=&quot;table&quot; tableValues=&quot;${values.a.join(&#039; &#039;)}&quot;&gt;&lt;/feFuncA&gt;
			&lt;/feComponentTransfer&gt;
			&lt;!-- Re-mask the image with the original transparency since the feColorMatrix above loses that information. --&gt;
			&lt;feComposite in2=&quot;SourceGraphic&quot; operator=&quot;in&quot;&gt;&lt;/feComposite&gt;
		&lt;/filter&gt;
	&lt;/defs&gt;
&lt;/svg&gt;`;
}

;// ./node_modules/@wordpress/block-editor/build-module/components/global-styles/get-block-css-selector.js
/**
 * Internal dependencies
 */



/**
 * Determine the CSS selector for the block type and target provided, returning
 * it if available.
 *
 * @param {import(&#039;@wordpress/blocks&#039;).Block} blockType        The block&#039;s type.
 * @param {string|string[]}                   target           The desired selector&#039;s target e.g. `root`, delimited string, or array path.
 * @param {Object}                            options          Options object.
 * @param {boolean}                           options.fallback Whether or not to fallback to broader selector.
 *
 * @return {?string} The CSS selector or `null` if no selector available.
 */
function getBlockCSSSelector(blockType, target = &#039;root&#039;, options = {}) {
  if (!target) {
    return null;
  }
  const {
    fallback = false
  } = options;
  const {
    name,
    selectors,
    supports
  } = blockType;
  const hasSelectors = selectors &amp;&amp; Object.keys(selectors).length &gt; 0;
  const path = Array.isArray(target) ? target.join(&#039;.&#039;) : target;

  // Root selector.

  // Calculated before returning as it can be used as a fallback for feature
  // selectors later on.
  let rootSelector = null;
  if (hasSelectors &amp;&amp; selectors.root) {
    // Use the selectors API if available.
    rootSelector = selectors?.root;
  } else if (supports?.__experimentalSelector) {
    // Use the old experimental selector supports property if set.
    rootSelector = supports.__experimentalSelector;
  } else {
    // If no root selector found, generate default block class selector.
    rootSelector = &#039;.wp-block-&#039; + name.replace(&#039;core/&#039;, &#039;&#039;).replace(&#039;/&#039;, &#039;-&#039;);
  }

  // Return selector if it&#039;s the root target we are looking for.
  if (path === &#039;root&#039;) {
    return rootSelector;
  }

  // If target is not `root` or `duotone` we have a feature or subfeature
  // as the target. If the target is a string convert to an array.
  const pathArray = Array.isArray(target) ? target : target.split(&#039;.&#039;);

  // Feature selectors ( may fallback to root selector );
  if (pathArray.length === 1) {
    const fallbackSelector = fallback ? rootSelector : null;

    // Prefer the selectors API if available.
    if (hasSelectors) {
      // Get selector from either `feature.root` or shorthand path.
      const featureSelector = getValueFromObjectPath(selectors, `${path}.root`, null) || getValueFromObjectPath(selectors, path, null);

      // Return feature selector if found or any available fallback.
      return featureSelector || fallbackSelector;
    }

    // Try getting old experimental supports selector value.
    const featureSelector = getValueFromObjectPath(supports, `${path}.__experimentalSelector`, null);

    // If nothing to work with, provide fallback selector if available.
    if (!featureSelector) {
      return fallbackSelector;
    }

    // Scope the feature selector by the block&#039;s root selector.
    return scopeSelector(rootSelector, featureSelector);
  }

  // Subfeature selector.
  // This may fallback either to parent feature or root selector.
  let subfeatureSelector;

  // Use selectors API if available.
  if (hasSelectors) {
    subfeatureSelector = getValueFromObjectPath(selectors, path, null);
  }

  // Only return if we have a subfeature selector.
  if (subfeatureSelector) {
    return subfeatureSelector;
  }

  // To this point we don&#039;t have a subfeature selector. If a fallback has been
  // requested, remove subfeature from target path and return results of a
  // call for the parent feature&#039;s selector.
  if (fallback) {
    return getBlockCSSSelector(blockType, pathArray[0], options);
  }

  // We tried.
  return null;
}

;// ./node_modules/@wordpress/block-editor/build-module/components/global-styles/filters-panel.js
/**
 * External dependencies
 */


/**
 * WordPress dependencies
 */





/**
 * Internal dependencies
 */



const filters_panel_EMPTY_ARRAY = [];
function useMultiOriginColorPresets(settings, {
  presetSetting,
  defaultSetting
}) {
  const disableDefault = !settings?.color?.[defaultSetting];
  const userPresets = settings?.color?.[presetSetting]?.custom || filters_panel_EMPTY_ARRAY;
  const themePresets = settings?.color?.[presetSetting]?.theme || filters_panel_EMPTY_ARRAY;
  const defaultPresets = settings?.color?.[presetSetting]?.default || filters_panel_EMPTY_ARRAY;
  return (0,external_wp_element_namespaceObject.useMemo)(() =&gt; [...userPresets, ...themePresets, ...(disableDefault ? filters_panel_EMPTY_ARRAY : defaultPresets)], [disableDefault, userPresets, themePresets, defaultPresets]);
}
function useHasFiltersPanel(settings) {
  return useHasDuotoneControl(settings);
}
function useHasDuotoneControl(settings) {
  return settings.color.customDuotone || settings.color.defaultDuotone || settings.color.duotone.length &gt; 0;
}
function FiltersToolsPanel({
  resetAllFilter,
  onChange,
  value,
  panelId,
  children
}) {
  const dropdownMenuProps = useToolsPanelDropdownMenuProps();
  const resetAll = () =&gt; {
    const updatedValue = resetAllFilter(value);
    onChange(updatedValue);
  };
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanel, {
    label: (0,external_wp_i18n_namespaceObject._x)(&#039;Filters&#039;, &#039;Name for applying graphical effects&#039;),
    resetAll: resetAll,
    panelId: panelId,
    dropdownMenuProps: dropdownMenuProps,
    children: children
  });
}
const filters_panel_DEFAULT_CONTROLS = {
  duotone: true
};
const filters_panel_popoverProps = {
  placement: &#039;left-start&#039;,
  offset: 36,
  shift: true,
  className: &#039;block-editor-duotone-control__popover&#039;,
  headerTitle: (0,external_wp_i18n_namespaceObject.__)(&#039;Duotone&#039;)
};
const LabeledColorIndicator = ({
  indicator,
  label
}) =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalHStack, {
  justify: &quot;flex-start&quot;,
  children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalZStack, {
    isLayered: false,
    offset: -8,
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Flex, {
      expanded: false,
      children: indicator === &#039;unset&#039; || !indicator ? /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ColorIndicator, {
        className: &quot;block-editor-duotone-control__unset-indicator&quot;
      }) : /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.DuotoneSwatch, {
        values: indicator
      })
    })
  }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FlexItem, {
    title: label,
    children: label
  })]
});
const renderToggle = (duotone, resetDuotone) =&gt; ({
  onToggle,
  isOpen
}) =&gt; {
  const duotoneButtonRef = (0,external_wp_element_namespaceObject.useRef)(undefined);
  const toggleProps = {
    onClick: onToggle,
    className: dist_clsx({
      &#039;is-open&#039;: isOpen
    }),
    &#039;aria-expanded&#039;: isOpen,
    ref: duotoneButtonRef
  };
  const removeButtonProps = {
    onClick: () =&gt; {
      if (isOpen) {
        onToggle();
      }
      resetDuotone();
      // Return focus to parent button.
      duotoneButtonRef.current?.focus();
    },
    className: &#039;block-editor-panel-duotone-settings__reset&#039;,
    label: (0,external_wp_i18n_namespaceObject.__)(&#039;Reset&#039;)
  };
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
      __next40pxDefaultSize: true,
      ...toggleProps,
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(LabeledColorIndicator, {
        indicator: duotone,
        label: (0,external_wp_i18n_namespaceObject.__)(&#039;Duotone&#039;)
      })
    }), duotone &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
      size: &quot;small&quot;,
      icon: library_reset,
      ...removeButtonProps
    })]
  });
};
function FiltersPanel({
  as: Wrapper = FiltersToolsPanel,
  value,
  onChange,
  inheritedValue = value,
  settings,
  panelId,
  defaultControls = filters_panel_DEFAULT_CONTROLS
}) {
  const decodeValue = rawValue =&gt; getValueFromVariable({
    settings
  }, &#039;&#039;, rawValue);

  // Duotone
  const hasDuotoneEnabled = useHasDuotoneControl(settings);
  const duotonePalette = useMultiOriginColorPresets(settings, {
    presetSetting: &#039;duotone&#039;,
    defaultSetting: &#039;defaultDuotone&#039;
  });
  const colorPalette = useMultiOriginColorPresets(settings, {
    presetSetting: &#039;palette&#039;,
    defaultSetting: &#039;defaultPalette&#039;
  });
  const duotone = decodeValue(inheritedValue?.filter?.duotone);
  const setDuotone = newValue =&gt; {
    const duotonePreset = duotonePalette.find(({
      colors
    }) =&gt; {
      return colors === newValue;
    });
    const duotoneValue = duotonePreset ? `var:preset|duotone|${duotonePreset.slug}` : newValue;
    onChange(setImmutably(value, [&#039;filter&#039;, &#039;duotone&#039;], duotoneValue));
  };
  const hasDuotone = () =&gt; !!value?.filter?.duotone;
  const resetDuotone = () =&gt; setDuotone(undefined);
  const resetAllFilter = (0,external_wp_element_namespaceObject.useCallback)(previousValue =&gt; {
    return {
      ...previousValue,
      filter: {
        ...previousValue.filter,
        duotone: undefined
      }
    };
  }, []);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Wrapper, {
    resetAllFilter: resetAllFilter,
    value: value,
    onChange: onChange,
    panelId: panelId,
    children: hasDuotoneEnabled &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanelItem, {
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Duotone&#039;),
      hasValue: hasDuotone,
      onDeselect: resetDuotone,
      isShownByDefault: defaultControls.duotone,
      panelId: panelId,
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Dropdown, {
        popoverProps: filters_panel_popoverProps,
        className: &quot;block-editor-global-styles-filters-panel__dropdown&quot;,
        renderToggle: renderToggle(duotone, resetDuotone),
        renderContent: () =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalDropdownContentWrapper, {
          paddingSize: &quot;small&quot;,
          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.MenuGroup, {
            label: (0,external_wp_i18n_namespaceObject.__)(&#039;Duotone&#039;),
            children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;p&quot;, {
              children: (0,external_wp_i18n_namespaceObject.__)(&#039;Create a two-tone color effect without losing your original image.&#039;)
            }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.DuotonePicker, {
              colorPalette: colorPalette,
              duotonePalette: duotonePalette
              // TODO: Re-enable both when custom colors are supported for block-level styles.
              ,
              disableCustomColors: true,
              disableCustomDuotone: true,
              value: duotone,
              onChange: setDuotone
            })]
          })
        })
      })
    })
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/hooks/duotone.js
/**
 * External dependencies
 */



/**
 * WordPress dependencies
 */





/**
 * Internal dependencies
 */









const duotone_EMPTY_ARRAY = [];

// Safari does not always update the duotone filter when the duotone colors
// are changed. This browser check is later used to force a re-render of the block
// element to ensure the duotone filter is updated. The check is included at the
// root of this file as it only needs to be run once per page load.
const isSafari = window?.navigator.userAgent &amp;&amp; window.navigator.userAgent.includes(&#039;Safari&#039;) &amp;&amp; !window.navigator.userAgent.includes(&#039;Chrome&#039;) &amp;&amp; !window.navigator.userAgent.includes(&#039;Chromium&#039;);
k([names]);
function useMultiOriginPresets({
  presetSetting,
  defaultSetting
}) {
  const [enableDefault, userPresets, themePresets, defaultPresets] = use_settings_useSettings(defaultSetting, `${presetSetting}.custom`, `${presetSetting}.theme`, `${presetSetting}.default`);
  return (0,external_wp_element_namespaceObject.useMemo)(() =&gt; [...(userPresets || duotone_EMPTY_ARRAY), ...(themePresets || duotone_EMPTY_ARRAY), ...(enableDefault &amp;&amp; defaultPresets || duotone_EMPTY_ARRAY)], [enableDefault, userPresets, themePresets, defaultPresets]);
}
function getColorsFromDuotonePreset(duotone, duotonePalette) {
  if (!duotone) {
    return;
  }
  const preset = duotonePalette?.find(({
    slug
  }) =&gt; {
    return duotone === `var:preset|duotone|${slug}`;
  });
  return preset ? preset.colors : undefined;
}
function getDuotonePresetFromColors(colors, duotonePalette) {
  if (!colors || !Array.isArray(colors)) {
    return;
  }
  const preset = duotonePalette?.find(duotonePreset =&gt; {
    return duotonePreset?.colors?.every((val, index) =&gt; val === colors[index]);
  });
  return preset ? `var:preset|duotone|${preset.slug}` : undefined;
}
function DuotonePanelPure({
  style,
  setAttributes,
  name
}) {
  const duotoneStyle = style?.color?.duotone;
  const settings = useBlockSettings(name);
  const blockEditingMode = useBlockEditingMode();
  const duotonePalette = useMultiOriginPresets({
    presetSetting: &#039;color.duotone&#039;,
    defaultSetting: &#039;color.defaultDuotone&#039;
  });
  const colorPalette = useMultiOriginPresets({
    presetSetting: &#039;color.palette&#039;,
    defaultSetting: &#039;color.defaultPalette&#039;
  });
  const [enableCustomColors, enableCustomDuotone] = use_settings_useSettings(&#039;color.custom&#039;, &#039;color.customDuotone&#039;);
  const disableCustomColors = !enableCustomColors;
  const disableCustomDuotone = !enableCustomDuotone || colorPalette?.length === 0 &amp;&amp; disableCustomColors;
  if (duotonePalette?.length === 0 &amp;&amp; disableCustomDuotone) {
    return null;
  }
  if (blockEditingMode !== &#039;default&#039;) {
    return null;
  }
  const duotonePresetOrColors = !Array.isArray(duotoneStyle) ? getColorsFromDuotonePreset(duotoneStyle, duotonePalette) : duotoneStyle;
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls, {
      group: &quot;filter&quot;,
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(FiltersPanel, {
        value: {
          filter: {
            duotone: duotonePresetOrColors
          }
        },
        onChange: newDuotone =&gt; {
          const newStyle = {
            ...style,
            color: {
              ...newDuotone?.filter
            }
          };
          setAttributes({
            style: newStyle
          });
        },
        settings: settings
      })
    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_controls, {
      group: &quot;block&quot;,
      __experimentalShareWithChildBlocks: true,
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(duotone_control, {
        duotonePalette: duotonePalette,
        colorPalette: colorPalette,
        disableCustomDuotone: disableCustomDuotone,
        disableCustomColors: disableCustomColors,
        value: duotonePresetOrColors,
        onChange: newDuotone =&gt; {
          const maybePreset = getDuotonePresetFromColors(newDuotone, duotonePalette);
          const newStyle = {
            ...style,
            color: {
              ...style?.color,
              duotone: maybePreset !== null &amp;&amp; maybePreset !== void 0 ? maybePreset : newDuotone // use preset or fallback to custom colors.
            }
          };
          setAttributes({
            style: newStyle
          });
        },
        settings: settings
      })
    })]
  });
}
/* harmony default export */ const duotone = ({
  shareWithChildBlocks: true,
  edit: DuotonePanelPure,
  useBlockProps: duotone_useBlockProps,
  attributeKeys: [&#039;style&#039;],
  hasSupport(name) {
    return (0,external_wp_blocks_namespaceObject.hasBlockSupport)(name, &#039;filter.duotone&#039;);
  }
});

/**
 * Filters registered block settings, extending attributes to include
 * the `duotone` attribute.
 *
 * @param {Object} settings Original block settings.
 *
 * @return {Object} Filtered block settings.
 */
function addDuotoneAttributes(settings) {
  // Previous `color.__experimentalDuotone` support flag is migrated via
  // block_type_metadata_settings filter in `lib/block-supports/duotone.php`.
  if (!(0,external_wp_blocks_namespaceObject.hasBlockSupport)(settings, &#039;filter.duotone&#039;)) {
    return settings;
  }

  // Allow blocks to specify their own attribute definition with default
  // values if needed.
  if (!settings.attributes.style) {
    Object.assign(settings.attributes, {
      style: {
        type: &#039;object&#039;
      }
    });
  }
  return settings;
}
function useDuotoneStyles({
  clientId,
  id: filterId,
  selector: duotoneSelector,
  attribute: duotoneAttr
}) {
  const duotonePalette = useMultiOriginPresets({
    presetSetting: &#039;color.duotone&#039;,
    defaultSetting: &#039;color.defaultDuotone&#039;
  });

  // Possible values for duotone attribute:
  // 1. Array of colors - e.g. [&#039;#000000&#039;, &#039;#ffffff&#039;].
  // 2. Variable for an existing Duotone preset - e.g. &#039;var:preset|duotone|green-blue&#039; or &#039;var(--wp--preset--duotone--green-blue)&#039;&#039;
  // 3. A CSS string - e.g. &#039;unset&#039; to remove globally applied duotone.
  const isCustom = Array.isArray(duotoneAttr);
  const duotonePreset = isCustom ? undefined : getColorsFromDuotonePreset(duotoneAttr, duotonePalette);
  const isPreset = typeof duotoneAttr === &#039;string&#039; &amp;&amp; duotonePreset;
  const isCSS = typeof duotoneAttr === &#039;string&#039; &amp;&amp; !isPreset;

  // Match the structure of WP_Duotone_Gutenberg::render_duotone_support() in PHP.
  let colors = null;
  if (isPreset) {
    // Array of colors.
    colors = duotonePreset;
  } else if (isCSS) {
    // CSS filter property string (e.g. &#039;unset&#039;).
    colors = duotoneAttr;
  } else if (isCustom) {
    // Array of colors.
    colors = duotoneAttr;
  }

  // Build the CSS selectors to which the filter will be applied.
  const selectors = duotoneSelector.split(&#039;,&#039;);
  const selectorsScoped = selectors.map(selectorPart =&gt; {
    // Assuming the selector part is a subclass selector (not a tag name)
    // so we can prepend the filter id class. If we want to support elements
    // such as `img` or namespaces, we&#039;ll need to add a case for that here.
    return `.${filterId}${selectorPart.trim()}`;
  });
  const selector = selectorsScoped.join(&#039;, &#039;);
  const isValidFilter = Array.isArray(colors) || colors === &#039;unset&#039;;
  usePrivateStyleOverride(isValidFilter ? {
    css: colors !== &#039;unset&#039; ? getDuotoneStylesheet(selector, filterId) : getDuotoneUnsetStylesheet(selector),
    __unstableType: &#039;presets&#039;
  } : undefined);
  usePrivateStyleOverride(isValidFilter ? {
    assets: colors !== &#039;unset&#039; ? getDuotoneFilter(filterId, colors) : &#039;&#039;,
    __unstableType: &#039;svgs&#039;
  } : undefined);
  const blockElement = useBlockElement(clientId);
  (0,external_wp_element_namespaceObject.useEffect)(() =&gt; {
    if (!isValidFilter) {
      return;
    }

    // Safari does not always update the duotone filter when the duotone
    // colors are changed. When using Safari, force the block element to be
    // repainted by the browser to ensure any changes are reflected
    // visually. This logic matches that used on the site frontend in
    // `block-supports/duotone.php`.
    if (blockElement &amp;&amp; isSafari) {
      const display = blockElement.style.display;
      // Switch to `inline-block` to force a repaint. In the editor,
      // `inline-block` is used instead of `none` to ensure that scroll
      // position is not affected, as `none` results in the editor
      // scrolling to the top of the block.
      blockElement.style.setProperty(&#039;display&#039;, &#039;inline-block&#039;);
      // Simply accessing el.offsetHeight flushes layout and style changes
      // in WebKit without having to wait for setTimeout.
      // eslint-disable-next-line no-unused-expressions
      blockElement.offsetHeight;
      blockElement.style.setProperty(&#039;display&#039;, display);
    }
    // `colors` must be a dependency so this effect runs when the colors
    // change in Safari.
  }, [isValidFilter, blockElement, colors]);
}

// Used for generating the instance ID
const DUOTONE_BLOCK_PROPS_REFERENCE = {};
function duotone_useBlockProps({
  clientId,
  name,
  style
}) {
  const id = (0,external_wp_compose_namespaceObject.useInstanceId)(DUOTONE_BLOCK_PROPS_REFERENCE);
  const selector = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; {
    const blockType = (0,external_wp_blocks_namespaceObject.getBlockType)(name);
    if (blockType) {
      // Backwards compatibility for `supports.color.__experimentalDuotone`
      // is provided via the `block_type_metadata_settings` filter. If
      // `supports.filter.duotone` has not been set and the
      // experimental property has been, the experimental property
      // value is copied into `supports.filter.duotone`.
      const duotoneSupport = (0,external_wp_blocks_namespaceObject.getBlockSupport)(blockType, &#039;filter.duotone&#039;, false);
      if (!duotoneSupport) {
        return null;
      }

      // If the experimental duotone support was set, that value is
      // to be treated as a selector and requires scoping.
      const experimentalDuotone = (0,external_wp_blocks_namespaceObject.getBlockSupport)(blockType, &#039;color.__experimentalDuotone&#039;, false);
      if (experimentalDuotone) {
        const rootSelector = getBlockCSSSelector(blockType);
        return typeof experimentalDuotone === &#039;string&#039; ? scopeSelector(rootSelector, experimentalDuotone) : rootSelector;
      }

      // Regular filter.duotone support uses filter.duotone selectors with fallbacks.
      return getBlockCSSSelector(blockType, &#039;filter.duotone&#039;, {
        fallback: true
      });
    }
  }, [name]);
  const attribute = style?.color?.duotone;
  const filterClass = `wp-duotone-${id}`;
  const shouldRender = selector &amp;&amp; attribute;
  useDuotoneStyles({
    clientId,
    id: filterClass,
    selector,
    attribute
  });
  return {
    className: shouldRender ? filterClass : &#039;&#039;
  };
}
(0,external_wp_hooks_namespaceObject.addFilter)(&#039;blocks.registerBlockType&#039;, &#039;core/editor/duotone/add-attributes&#039;, addDuotoneAttributes);

;// ./node_modules/@wordpress/block-editor/build-module/components/use-block-display-information/index.js
/**
 * WordPress dependencies
 */




/**
 * Internal dependencies
 */


/** @typedef {import(&#039;@wordpress/blocks&#039;).WPIcon} WPIcon */

/**
 * Contains basic block&#039;s information for display reasons.
 *
 * @typedef {Object} WPBlockDisplayInformation
 *
 * @property {boolean} isSynced    True if is a reusable block or template part
 * @property {string}  title       Human-readable block type label.
 * @property {WPIcon}  icon        Block type icon.
 * @property {string}  description A detailed block type description.
 * @property {string}  anchor      HTML anchor.
 * @property {name}    name        A custom, human readable name for the block.
 */

/**
 * Get the display label for a block&#039;s position type.
 *
 * @param {Object} attributes Block attributes.
 * @return {string} The position type label.
 */
function getPositionTypeLabel(attributes) {
  const positionType = attributes?.style?.position?.type;
  if (positionType === &#039;sticky&#039;) {
    return (0,external_wp_i18n_namespaceObject.__)(&#039;Sticky&#039;);
  }
  if (positionType === &#039;fixed&#039;) {
    return (0,external_wp_i18n_namespaceObject.__)(&#039;Fixed&#039;);
  }
  return null;
}

/**
 * Hook used to try to find a matching block variation and return
 * the appropriate information for display reasons. In order to
 * to try to find a match we need to things:
 * 1. Block&#039;s client id to extract it&#039;s current attributes.
 * 2. A block variation should have set `isActive` prop to a proper function.
 *
 * If for any reason a block variation match cannot be found,
 * the returned information come from the Block Type.
 * If no blockType is found with the provided clientId, returns null.
 *
 * @param {string} clientId Block&#039;s client id.
 * @return {?WPBlockDisplayInformation} Block&#039;s display information, or `null` when the block or its type not found.
 */

function useBlockDisplayInformation(clientId) {
  return (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    if (!clientId) {
      return null;
    }
    const {
      getBlockName,
      getBlockAttributes
    } = select(store);
    const {
      getBlockType,
      getActiveBlockVariation
    } = select(external_wp_blocks_namespaceObject.store);
    const blockName = getBlockName(clientId);
    const blockType = getBlockType(blockName);
    if (!blockType) {
      return null;
    }
    const attributes = getBlockAttributes(clientId);
    const match = getActiveBlockVariation(blockName, attributes);
    const isSynced = (0,external_wp_blocks_namespaceObject.isReusableBlock)(blockType) || (0,external_wp_blocks_namespaceObject.isTemplatePart)(blockType);
    const syncedTitle = isSynced ? (0,external_wp_blocks_namespaceObject.__experimentalGetBlockLabel)(blockType, attributes) : undefined;
    const title = syncedTitle || blockType.title;
    const positionLabel = getPositionTypeLabel(attributes);
    const blockTypeInfo = {
      isSynced,
      title,
      icon: blockType.icon,
      description: blockType.description,
      anchor: attributes?.anchor,
      positionLabel,
      positionType: attributes?.style?.position?.type,
      name: attributes?.metadata?.name
    };
    if (!match) {
      return blockTypeInfo;
    }
    return {
      isSynced,
      title: match.title || blockType.title,
      icon: match.icon || blockType.icon,
      description: match.description || blockType.description,
      anchor: attributes?.anchor,
      positionLabel,
      positionType: attributes?.style?.position?.type,
      name: attributes?.metadata?.name
    };
  }, [clientId]);
}

;// ./node_modules/@wordpress/block-editor/build-module/hooks/position.js
/**
 * External dependencies
 */


/**
 * WordPress dependencies
 */







/**
 * Internal dependencies
 */






const POSITION_SUPPORT_KEY = &#039;position&#039;;
const DEFAULT_OPTION = {
  key: &#039;default&#039;,
  value: &#039;&#039;,
  name: (0,external_wp_i18n_namespaceObject.__)(&#039;Default&#039;)
};
const STICKY_OPTION = {
  key: &#039;sticky&#039;,
  value: &#039;sticky&#039;,
  name: (0,external_wp_i18n_namespaceObject._x)(&#039;Sticky&#039;, &#039;Name for the value of the CSS position property&#039;),
  hint: (0,external_wp_i18n_namespaceObject.__)(&#039;The block will stick to the top of the window instead of scrolling.&#039;)
};
const FIXED_OPTION = {
  key: &#039;fixed&#039;,
  value: &#039;fixed&#039;,
  name: (0,external_wp_i18n_namespaceObject._x)(&#039;Fixed&#039;, &#039;Name for the value of the CSS position property&#039;),
  hint: (0,external_wp_i18n_namespaceObject.__)(&#039;The block will not move when the page is scrolled.&#039;)
};
const POSITION_SIDES = [&#039;top&#039;, &#039;right&#039;, &#039;bottom&#039;, &#039;left&#039;];
const VALID_POSITION_TYPES = [&#039;sticky&#039;, &#039;fixed&#039;];

/**
 * Get calculated position CSS.
 *
 * @param {Object} props          Component props.
 * @param {string} props.selector Selector to use.
 * @param {Object} props.style    Style object.
 * @return {string} The generated CSS rules.
 */
function getPositionCSS({
  selector,
  style
}) {
  let output = &#039;&#039;;
  const {
    type: positionType
  } = style?.position || {};
  if (!VALID_POSITION_TYPES.includes(positionType)) {
    return output;
  }
  output += `${selector} {`;
  output += `position: ${positionType};`;
  POSITION_SIDES.forEach(side =&gt; {
    if (style?.position?.[side] !== undefined) {
      output += `${side}: ${style.position[side]};`;
    }
  });
  if (positionType === &#039;sticky&#039; || positionType === &#039;fixed&#039;) {
    // TODO: Replace hard-coded z-index value with a z-index preset approach in theme.json.
    output += `z-index: 10`;
  }
  output += `}`;
  return output;
}

/**
 * Determines if there is sticky position support.
 *
 * @param {string|Object} blockType Block name or Block Type object.
 *
 * @return {boolean} Whether there is support.
 */
function hasStickyPositionSupport(blockType) {
  const support = (0,external_wp_blocks_namespaceObject.getBlockSupport)(blockType, POSITION_SUPPORT_KEY);
  return !!(true === support || support?.sticky);
}

/**
 * Determines if there is fixed position support.
 *
 * @param {string|Object} blockType Block name or Block Type object.
 *
 * @return {boolean} Whether there is support.
 */
function hasFixedPositionSupport(blockType) {
  const support = (0,external_wp_blocks_namespaceObject.getBlockSupport)(blockType, POSITION_SUPPORT_KEY);
  return !!(true === support || support?.fixed);
}

/**
 * Determines if there is position support.
 *
 * @param {string|Object} blockType Block name or Block Type object.
 *
 * @return {boolean} Whether there is support.
 */
function hasPositionSupport(blockType) {
  const support = (0,external_wp_blocks_namespaceObject.getBlockSupport)(blockType, POSITION_SUPPORT_KEY);
  return !!support;
}

/**
 * Checks if there is a current value in the position block support attributes.
 *
 * @param {Object} props Block props.
 * @return {boolean} Whether or not the block has a position value set.
 */
function hasPositionValue(props) {
  return props.attributes.style?.position?.type !== undefined;
}

/**
 * Checks if the block is currently set to a sticky or fixed position.
 * This check is helpful for determining how to position block toolbars or other elements.
 *
 * @param {Object} attributes Block attributes.
 * @return {boolean} Whether or not the block is set to a sticky or fixed position.
 */
function hasStickyOrFixedPositionValue(attributes) {
  const positionType = attributes?.style?.position?.type;
  return positionType === &#039;sticky&#039; || positionType === &#039;fixed&#039;;
}

/**
 * Resets the position block support attributes. This can be used when disabling
 * the position support controls for a block via a `ToolsPanel`.
 *
 * @param {Object} props               Block props.
 * @param {Object} props.attributes    Block&#039;s attributes.
 * @param {Object} props.setAttributes Function to set block&#039;s attributes.
 */
function resetPosition({
  attributes = {},
  setAttributes
}) {
  const {
    style = {}
  } = attributes;
  setAttributes({
    style: cleanEmptyObject({
      ...style,
      position: {
        ...style?.position,
        type: undefined,
        top: undefined,
        right: undefined,
        bottom: undefined,
        left: undefined
      }
    })
  });
}

/**
 * Custom hook that checks if position settings have been disabled.
 *
 * @param {string} name The name of the block.
 *
 * @return {boolean} Whether padding setting is disabled.
 */
function useIsPositionDisabled({
  name: blockName
} = {}) {
  const [allowFixed, allowSticky] = use_settings_useSettings(&#039;position.fixed&#039;, &#039;position.sticky&#039;);
  const isDisabled = !allowFixed &amp;&amp; !allowSticky;
  return !hasPositionSupport(blockName) || isDisabled;
}

/*
 * Position controls rendered in an inspector control panel.
 *
 * @param {Object} props
 *
 * @return {Element} Position panel.
 */
function PositionPanelPure({
  style = {},
  clientId,
  name: blockName,
  setAttributes
}) {
  const allowFixed = hasFixedPositionSupport(blockName);
  const allowSticky = hasStickyPositionSupport(blockName);
  const value = style?.position?.type;
  const {
    firstParentClientId
  } = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      getBlockParents
    } = select(store);
    const parents = getBlockParents(clientId);
    return {
      firstParentClientId: parents[parents.length - 1]
    };
  }, [clientId]);
  const blockInformation = useBlockDisplayInformation(firstParentClientId);
  const stickyHelpText = allowSticky &amp;&amp; value === STICKY_OPTION.value &amp;&amp; blockInformation ? (0,external_wp_i18n_namespaceObject.sprintf)(/* translators: %s: the name of the parent block. */
  (0,external_wp_i18n_namespaceObject.__)(&#039;The block will stick to the scrollable area of the parent %s block.&#039;), blockInformation.title) : null;
  const options = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; {
    const availableOptions = [DEFAULT_OPTION];
    // Display options if they are allowed, or if a block already has a valid value set.
    // This allows for a block to be switched off from a position type that is not allowed.
    if (allowSticky || value === STICKY_OPTION.value) {
      availableOptions.push(STICKY_OPTION);
    }
    if (allowFixed || value === FIXED_OPTION.value) {
      availableOptions.push(FIXED_OPTION);
    }
    return availableOptions;
  }, [allowFixed, allowSticky, value]);
  const onChangeType = next =&gt; {
    // For now, use a hard-coded `0px` value for the position.
    // `0px` is preferred over `0` as it can be used in `calc()` functions.
    // In the future, it could be useful to allow for an offset value.
    const placementValue = &#039;0px&#039;;
    const newStyle = {
      ...style,
      position: {
        ...style?.position,
        type: next,
        top: next === &#039;sticky&#039; || next === &#039;fixed&#039; ? placementValue : undefined
      }
    };
    setAttributes({
      style: utils_cleanEmptyObject(newStyle)
    });
  };
  const selectedOption = value ? options.find(option =&gt; option.value === value) || DEFAULT_OPTION : DEFAULT_OPTION;

  // Only display position controls if there is at least one option to choose from.
  return external_wp_element_namespaceObject.Platform.select({
    web: options.length &gt; 1 ? /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls, {
      group: &quot;position&quot;,
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.BaseControl, {
        __nextHasNoMarginBottom: true,
        help: stickyHelpText,
        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.CustomSelectControl, {
          __next40pxDefaultSize: true,
          label: (0,external_wp_i18n_namespaceObject.__)(&#039;Position&#039;),
          hideLabelFromVision: true,
          describedBy: (0,external_wp_i18n_namespaceObject.sprintf)(
          // translators: %s: Currently selected position.
          (0,external_wp_i18n_namespaceObject.__)(&#039;Currently selected position: %s&#039;), selectedOption.name),
          options: options,
          value: selectedOption,
          onChange: ({
            selectedItem
          }) =&gt; {
            onChangeType(selectedItem.value);
          },
          size: &quot;__unstable-large&quot;
        })
      })
    }) : null,
    native: null
  });
}
/* harmony default export */ const position = ({
  edit: function Edit(props) {
    const isPositionDisabled = useIsPositionDisabled(props);
    if (isPositionDisabled) {
      return null;
    }
    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PositionPanelPure, {
      ...props
    });
  },
  useBlockProps: position_useBlockProps,
  attributeKeys: [&#039;style&#039;],
  hasSupport(name) {
    return (0,external_wp_blocks_namespaceObject.hasBlockSupport)(name, POSITION_SUPPORT_KEY);
  }
});

// Used for generating the instance ID
const POSITION_BLOCK_PROPS_REFERENCE = {};
function position_useBlockProps({
  name,
  style
}) {
  const hasPositionBlockSupport = (0,external_wp_blocks_namespaceObject.hasBlockSupport)(name, POSITION_SUPPORT_KEY);
  const isPositionDisabled = useIsPositionDisabled({
    name
  });
  const allowPositionStyles = hasPositionBlockSupport &amp;&amp; !isPositionDisabled;
  const id = (0,external_wp_compose_namespaceObject.useInstanceId)(POSITION_BLOCK_PROPS_REFERENCE);

  // Higher specificity to override defaults in editor UI.
  const positionSelector = `.wp-container-${id}.wp-container-${id}`;

  // Get CSS string for the current position values.
  let css;
  if (allowPositionStyles) {
    css = getPositionCSS({
      selector: positionSelector,
      style
    }) || &#039;&#039;;
  }

  // Attach a `wp-container-` id-based class name.
  const className = dist_clsx({
    [`wp-container-${id}`]: allowPositionStyles &amp;&amp; !!css,
    // Only attach a container class if there is generated CSS to be attached.
    [`is-position-${style?.position?.type}`]: allowPositionStyles &amp;&amp; !!css &amp;&amp; !!style?.position?.type
  });
  useStyleOverride({
    css
  });
  return {
    className
  };
}

;// ./node_modules/@wordpress/block-editor/build-module/components/global-styles/use-global-styles-output.js
/**
 * WordPress dependencies
 */






/**
 * Internal dependencies
 */













// Elements that rely on class names in their selectors.
const ELEMENT_CLASS_NAMES = {
  button: &#039;wp-element-button&#039;,
  caption: &#039;wp-element-caption&#039;
};

// List of block support features that can have their related styles
// generated under their own feature level selector rather than the block&#039;s.
const BLOCK_SUPPORT_FEATURE_LEVEL_SELECTORS = {
  __experimentalBorder: &#039;border&#039;,
  color: &#039;color&#039;,
  spacing: &#039;spacing&#039;,
  typography: &#039;typography&#039;
};
const {
  kebabCase: use_global_styles_output_kebabCase
} = unlock(external_wp_components_namespaceObject.privateApis);

/**
 * Transform given preset tree into a set of style declarations.
 *
 * @param {Object} blockPresets
 * @param {Object} mergedSettings Merged theme.json settings.
 *
 * @return {Array&lt;Object&gt;} An array of style declarations.
 */
function getPresetsDeclarations(blockPresets = {}, mergedSettings) {
  return PRESET_METADATA.reduce((declarations, {
    path,
    valueKey,
    valueFunc,
    cssVarInfix
  }) =&gt; {
    const presetByOrigin = getValueFromObjectPath(blockPresets, path, []);
    [&#039;default&#039;, &#039;theme&#039;, &#039;custom&#039;].forEach(origin =&gt; {
      if (presetByOrigin[origin]) {
        presetByOrigin[origin].forEach(value =&gt; {
          if (valueKey &amp;&amp; !valueFunc) {
            declarations.push(`--wp--preset--${cssVarInfix}--${use_global_styles_output_kebabCase(value.slug)}: ${value[valueKey]}`);
          } else if (valueFunc &amp;&amp; typeof valueFunc === &#039;function&#039;) {
            declarations.push(`--wp--preset--${cssVarInfix}--${use_global_styles_output_kebabCase(value.slug)}: ${valueFunc(value, mergedSettings)}`);
          }
        });
      }
    });
    return declarations;
  }, []);
}

/**
 * Transform given preset tree into a set of preset class declarations.
 *
 * @param {?string} blockSelector
 * @param {Object}  blockPresets
 * @return {string} CSS declarations for the preset classes.
 */
function getPresetsClasses(blockSelector = &#039;*&#039;, blockPresets = {}) {
  return PRESET_METADATA.reduce((declarations, {
    path,
    cssVarInfix,
    classes
  }) =&gt; {
    if (!classes) {
      return declarations;
    }
    const presetByOrigin = getValueFromObjectPath(blockPresets, path, []);
    [&#039;default&#039;, &#039;theme&#039;, &#039;custom&#039;].forEach(origin =&gt; {
      if (presetByOrigin[origin]) {
        presetByOrigin[origin].forEach(({
          slug
        }) =&gt; {
          classes.forEach(({
            classSuffix,
            propertyName
          }) =&gt; {
            const classSelectorToUse = `.has-${use_global_styles_output_kebabCase(slug)}-${classSuffix}`;
            const selectorToUse = blockSelector.split(&#039;,&#039;) // Selector can be &quot;h1, h2, h3&quot;
            .map(selector =&gt; `${selector}${classSelectorToUse}`).join(&#039;,&#039;);
            const value = `var(--wp--preset--${cssVarInfix}--${use_global_styles_output_kebabCase(slug)})`;
            declarations += `${selectorToUse}{${propertyName}: ${value} !important;}`;
          });
        });
      }
    });
    return declarations;
  }, &#039;&#039;);
}
function getPresetsSvgFilters(blockPresets = {}) {
  return PRESET_METADATA.filter(
  // Duotone are the only type of filters for now.
  metadata =&gt; metadata.path.at(-1) === &#039;duotone&#039;).flatMap(metadata =&gt; {
    const presetByOrigin = getValueFromObjectPath(blockPresets, metadata.path, {});
    return [&#039;default&#039;, &#039;theme&#039;].filter(origin =&gt; presetByOrigin[origin]).flatMap(origin =&gt; presetByOrigin[origin].map(preset =&gt; getDuotoneFilter(`wp-duotone-${preset.slug}`, preset.colors))).join(&#039;&#039;);
  });
}
function flattenTree(input = {}, prefix, token) {
  let result = [];
  Object.keys(input).forEach(key =&gt; {
    const newKey = prefix + use_global_styles_output_kebabCase(key.replace(&#039;/&#039;, &#039;-&#039;));
    const newLeaf = input[key];
    if (newLeaf instanceof Object) {
      const newPrefix = newKey + token;
      result = [...result, ...flattenTree(newLeaf, newPrefix, token)];
    } else {
      result.push(`${newKey}: ${newLeaf}`);
    }
  });
  return result;
}

/**
 * Gets variation selector string from feature selector.
 *
 * @param {string} featureSelector        The feature selector.
 *
 * @param {string} styleVariationSelector The style variation selector.
 * @return {string} Combined selector string.
 */
function concatFeatureVariationSelectorString(featureSelector, styleVariationSelector) {
  const featureSelectors = featureSelector.split(&#039;,&#039;);
  const combinedSelectors = [];
  featureSelectors.forEach(selector =&gt; {
    combinedSelectors.push(`${styleVariationSelector.trim()}${selector.trim()}`);
  });
  return combinedSelectors.join(&#039;, &#039;);
}

/**
 * Generate style declarations for a block&#039;s custom feature and subfeature
 * selectors.
 *
 * NOTE: The passed `styles` object will be mutated by this function.
 *
 * @param {Object} selectors Custom selectors object for a block.
 * @param {Object} styles    A block&#039;s styles object.
 *
 * @return {Object} Style declarations.
 */
const getFeatureDeclarations = (selectors, styles) =&gt; {
  const declarations = {};
  Object.entries(selectors).forEach(([feature, selector]) =&gt; {
    // We&#039;re only processing features/subfeatures that have styles.
    if (feature === &#039;root&#039; || !styles?.[feature]) {
      return;
    }
    const isShorthand = typeof selector === &#039;string&#039;;

    // If we have a selector object instead of shorthand process it.
    if (!isShorthand) {
      Object.entries(selector).forEach(([subfeature, subfeatureSelector]) =&gt; {
        // Don&#039;t process root feature selector yet or any
        // subfeature that doesn&#039;t have a style.
        if (subfeature === &#039;root&#039; || !styles?.[feature][subfeature]) {
          return;
        }

        // Create a temporary styles object and build
        // declarations for subfeature.
        const subfeatureStyles = {
          [feature]: {
            [subfeature]: styles[feature][subfeature]
          }
        };
        const newDeclarations = getStylesDeclarations(subfeatureStyles);

        // Merge new declarations in with any others that
        // share the same selector.
        declarations[subfeatureSelector] = [...(declarations[subfeatureSelector] || []), ...newDeclarations];

        // Remove the subfeature&#039;s style now it will be
        // included under its own selector not the block&#039;s.
        delete styles[feature][subfeature];
      });
    }

    // Now subfeatures have been processed and removed, we can
    // process root, or shorthand, feature selectors.
    if (isShorthand || selector.root) {
      const featureSelector = isShorthand ? selector : selector.root;

      // Create temporary style object and build declarations for feature.
      const featureStyles = {
        [feature]: styles[feature]
      };
      const newDeclarations = getStylesDeclarations(featureStyles);

      // Merge new declarations with any others that share the selector.
      declarations[featureSelector] = [...(declarations[featureSelector] || []), ...newDeclarations];

      // Remove the feature from the block&#039;s styles now as it will be
      // included under its own selector not the block&#039;s.
      delete styles[feature];
    }
  });
  return declarations;
};

/**
 * Transform given style tree into a set of style declarations.
 *
 * @param {Object}  blockStyles         Block styles.
 *
 * @param {string}  selector            The selector these declarations should attach to.
 *
 * @param {boolean} useRootPaddingAlign Whether to use CSS custom properties in root selector.
 *
 * @param {Object}  tree                A theme.json tree containing layout definitions.
 *
 * @param {boolean} disableRootPadding  Whether to force disable the root padding styles.
 * @return {Array} An array of style declarations.
 */
function getStylesDeclarations(blockStyles = {}, selector = &#039;&#039;, useRootPaddingAlign, tree = {}, disableRootPadding = false) {
  const isRoot = ROOT_BLOCK_SELECTOR === selector;
  const output = Object.entries(external_wp_blocks_namespaceObject.__EXPERIMENTAL_STYLE_PROPERTY).reduce((declarations, [key, {
    value,
    properties,
    useEngine,
    rootOnly
  }]) =&gt; {
    if (rootOnly &amp;&amp; !isRoot) {
      return declarations;
    }
    const pathToValue = value;
    if (pathToValue[0] === &#039;elements&#039; || useEngine) {
      return declarations;
    }
    const styleValue = getValueFromObjectPath(blockStyles, pathToValue);

    // Root-level padding styles don&#039;t currently support strings with CSS shorthand values.
    // This may change: https://github.com/WordPress/gutenberg/issues/40132.
    if (key === &#039;--wp--style--root--padding&#039; &amp;&amp; (typeof styleValue === &#039;string&#039; || !useRootPaddingAlign)) {
      return declarations;
    }
    if (properties &amp;&amp; typeof styleValue !== &#039;string&#039;) {
      Object.entries(properties).forEach(entry =&gt; {
        const [name, prop] = entry;
        if (!getValueFromObjectPath(styleValue, [prop], false)) {
          // Do not create a declaration
          // for sub-properties that don&#039;t have any value.
          return;
        }
        const cssProperty = name.startsWith(&#039;--&#039;) ? name : use_global_styles_output_kebabCase(name);
        declarations.push(`${cssProperty}: ${(0,external_wp_styleEngine_namespaceObject.getCSSValueFromRawStyle)(getValueFromObjectPath(styleValue, [prop]))}`);
      });
    } else if (getValueFromObjectPath(blockStyles, pathToValue, false)) {
      const cssProperty = key.startsWith(&#039;--&#039;) ? key : use_global_styles_output_kebabCase(key);
      declarations.push(`${cssProperty}: ${(0,external_wp_styleEngine_namespaceObject.getCSSValueFromRawStyle)(getValueFromObjectPath(blockStyles, pathToValue))}`);
    }
    return declarations;
  }, []);

  /*
   * Preprocess background image values.
   *
   * Note: As we absorb more and more styles into the engine, we could simplify this function.
   * A refactor is for the style engine to handle ref resolution (and possibly defaults)
   * via a public util used internally and externally. Theme.json tree and defaults could be passed
   * as options.
   */
  if (!!blockStyles.background) {
    /*
     * Resolve dynamic values before they are compiled by the style engine,
     * which doesn&#039;t (yet) resolve dynamic values.
     */
    if (blockStyles.background?.backgroundImage) {
      blockStyles.background.backgroundImage = getResolvedValue(blockStyles.background.backgroundImage, tree);
    }

    /*
     * Set default values for block background styles.
     * Top-level styles are an exception as they are applied to the body.
     */
    if (!isRoot &amp;&amp; !!blockStyles.background?.backgroundImage?.id) {
      blockStyles = {
        ...blockStyles,
        background: {
          ...blockStyles.background,
          ...setBackgroundStyleDefaults(blockStyles.background)
        }
      };
    }
  }
  const extraRules = (0,external_wp_styleEngine_namespaceObject.getCSSRules)(blockStyles);
  extraRules.forEach(rule =&gt; {
    // Don&#039;t output padding properties if padding variables are set or if we&#039;re not editing a full template.
    if (isRoot &amp;&amp; (useRootPaddingAlign || disableRootPadding) &amp;&amp; rule.key.startsWith(&#039;padding&#039;)) {
      return;
    }
    const cssProperty = rule.key.startsWith(&#039;--&#039;) ? rule.key : use_global_styles_output_kebabCase(rule.key);
    let ruleValue = getResolvedValue(rule.value, tree, null);

    // Calculate fluid typography rules where available.
    if (cssProperty === &#039;font-size&#039;) {
      /*
       * getTypographyFontSizeValue() will check
       * if fluid typography has been activated and also
       * whether the incoming value can be converted to a fluid value.
       * Values that already have a &quot;clamp()&quot; function will not pass the test,
       * and therefore the original $value will be returned.
       */
      ruleValue = getTypographyFontSizeValue({
        size: ruleValue
      }, tree?.settings);
    }

    // For aspect ratio to work, other dimensions rules (and Cover block defaults) must be unset.
    // This ensures that a fixed height does not override the aspect ratio.
    if (cssProperty === &#039;aspect-ratio&#039;) {
      output.push(&#039;min-height: unset&#039;);
    }
    output.push(`${cssProperty}: ${ruleValue}`);
  });
  return output;
}

/**
 * Get generated CSS for layout styles by looking up layout definitions provided
 * in theme.json, and outputting common layout styles, and specific blockGap values.
 *
 * @param {Object}  props
 * @param {Object}  props.layoutDefinitions     Layout definitions, keyed by layout type.
 * @param {Object}  props.style                 A style object containing spacing values.
 * @param {string}  props.selector              Selector used to group together layout styling rules.
 * @param {boolean} props.hasBlockGapSupport    Whether or not the theme opts-in to blockGap support.
 * @param {boolean} props.hasFallbackGapSupport Whether or not the theme allows fallback gap styles.
 * @param {?string} props.fallbackGapValue      An optional fallback gap value if no real gap value is available.
 * @return {string} Generated CSS rules for the layout styles.
 */
function getLayoutStyles({
  layoutDefinitions = LAYOUT_DEFINITIONS,
  style,
  selector,
  hasBlockGapSupport,
  hasFallbackGapSupport,
  fallbackGapValue
}) {
  let ruleset = &#039;&#039;;
  let gapValue = hasBlockGapSupport ? getGapCSSValue(style?.spacing?.blockGap) : &#039;&#039;;

  // Ensure a fallback gap value for the root layout definitions,
  // and use a fallback value if one is provided for the current block.
  if (hasFallbackGapSupport) {
    if (selector === ROOT_BLOCK_SELECTOR) {
      gapValue = !gapValue ? &#039;0.5em&#039; : gapValue;
    } else if (!hasBlockGapSupport &amp;&amp; fallbackGapValue) {
      gapValue = fallbackGapValue;
    }
  }
  if (gapValue &amp;&amp; layoutDefinitions) {
    Object.values(layoutDefinitions).forEach(({
      className,
      name,
      spacingStyles
    }) =&gt; {
      // Allow outputting fallback gap styles for flex layout type when block gap support isn&#039;t available.
      if (!hasBlockGapSupport &amp;&amp; &#039;flex&#039; !== name &amp;&amp; &#039;grid&#039; !== name) {
        return;
      }
      if (spacingStyles?.length) {
        spacingStyles.forEach(spacingStyle =&gt; {
          const declarations = [];
          if (spacingStyle.rules) {
            Object.entries(spacingStyle.rules).forEach(([cssProperty, cssValue]) =&gt; {
              declarations.push(`${cssProperty}: ${cssValue ? cssValue : gapValue}`);
            });
          }
          if (declarations.length) {
            let combinedSelector = &#039;&#039;;
            if (!hasBlockGapSupport) {
              // For fallback gap styles, use lower specificity, to ensure styles do not unintentionally override theme styles.
              combinedSelector = selector === ROOT_BLOCK_SELECTOR ? `:where(.${className}${spacingStyle?.selector || &#039;&#039;})` : `:where(${selector}.${className}${spacingStyle?.selector || &#039;&#039;})`;
            } else {
              combinedSelector = selector === ROOT_BLOCK_SELECTOR ? `:root :where(.${className})${spacingStyle?.selector || &#039;&#039;}` : `:root :where(${selector}-${className})${spacingStyle?.selector || &#039;&#039;}`;
            }
            ruleset += `${combinedSelector} { ${declarations.join(&#039;; &#039;)}; }`;
          }
        });
      }
    });
    // For backwards compatibility, ensure the legacy block gap CSS variable is still available.
    if (selector === ROOT_BLOCK_SELECTOR &amp;&amp; hasBlockGapSupport) {
      ruleset += `${ROOT_CSS_PROPERTIES_SELECTOR} { --wp--style--block-gap: ${gapValue}; }`;
    }
  }

  // Output base styles
  if (selector === ROOT_BLOCK_SELECTOR &amp;&amp; layoutDefinitions) {
    const validDisplayModes = [&#039;block&#039;, &#039;flex&#039;, &#039;grid&#039;];
    Object.values(layoutDefinitions).forEach(({
      className,
      displayMode,
      baseStyles
    }) =&gt; {
      if (displayMode &amp;&amp; validDisplayModes.includes(displayMode)) {
        ruleset += `${selector} .${className} { display:${displayMode}; }`;
      }
      if (baseStyles?.length) {
        baseStyles.forEach(baseStyle =&gt; {
          const declarations = [];
          if (baseStyle.rules) {
            Object.entries(baseStyle.rules).forEach(([cssProperty, cssValue]) =&gt; {
              declarations.push(`${cssProperty}: ${cssValue}`);
            });
          }
          if (declarations.length) {
            const combinedSelector = `.${className}${baseStyle?.selector || &#039;&#039;}`;
            ruleset += `${combinedSelector} { ${declarations.join(&#039;; &#039;)}; }`;
          }
        });
      }
    });
  }
  return ruleset;
}
const STYLE_KEYS = [&#039;border&#039;, &#039;color&#039;, &#039;dimensions&#039;, &#039;spacing&#039;, &#039;typography&#039;, &#039;filter&#039;, &#039;outline&#039;, &#039;shadow&#039;, &#039;background&#039;];
function pickStyleKeys(treeToPickFrom) {
  if (!treeToPickFrom) {
    return {};
  }
  const entries = Object.entries(treeToPickFrom);
  const pickedEntries = entries.filter(([key]) =&gt; STYLE_KEYS.includes(key));
  // clone the style objects so that `getFeatureDeclarations` can remove consumed keys from it
  const clonedEntries = pickedEntries.map(([key, style]) =&gt; [key, JSON.parse(JSON.stringify(style))]);
  return Object.fromEntries(clonedEntries);
}
const getNodesWithStyles = (tree, blockSelectors) =&gt; {
  var _tree$styles$blocks;
  const nodes = [];
  if (!tree?.styles) {
    return nodes;
  }

  // Top-level.
  const styles = pickStyleKeys(tree.styles);
  if (styles) {
    nodes.push({
      styles,
      selector: ROOT_BLOCK_SELECTOR,
      // Root selector (body) styles should not be wrapped in `:root where()` to keep
      // specificity at (0,0,1) and maintain backwards compatibility.
      skipSelectorWrapper: true
    });
  }
  Object.entries(external_wp_blocks_namespaceObject.__EXPERIMENTAL_ELEMENTS).forEach(([name, selector]) =&gt; {
    if (tree.styles?.elements?.[name]) {
      nodes.push({
        styles: tree.styles?.elements?.[name],
        selector,
        // Top level elements that don&#039;t use a class name should not receive the
        // `:root :where()` wrapper to maintain backwards compatibility.
        skipSelectorWrapper: !ELEMENT_CLASS_NAMES[name]
      });
    }
  });

  // Iterate over blocks: they can have styles &amp; elements.
  Object.entries((_tree$styles$blocks = tree.styles?.blocks) !== null &amp;&amp; _tree$styles$blocks !== void 0 ? _tree$styles$blocks : {}).forEach(([blockName, node]) =&gt; {
    var _node$elements;
    const blockStyles = pickStyleKeys(node);
    if (node?.variations) {
      const variations = {};
      Object.entries(node.variations).forEach(([variationName, variation]) =&gt; {
        var _variation$elements, _variation$blocks;
        variations[variationName] = pickStyleKeys(variation);
        if (variation?.css) {
          variations[variationName].css = variation.css;
        }
        const variationSelector = blockSelectors[blockName]?.styleVariationSelectors?.[variationName];

        // Process the variation&#039;s inner element styles.
        // This comes before the inner block styles so the
        // element styles within the block type styles take
        // precedence over these.
        Object.entries((_variation$elements = variation?.elements) !== null &amp;&amp; _variation$elements !== void 0 ? _variation$elements : {}).forEach(([element, elementStyles]) =&gt; {
          if (elementStyles &amp;&amp; external_wp_blocks_namespaceObject.__EXPERIMENTAL_ELEMENTS[element]) {
            nodes.push({
              styles: elementStyles,
              selector: scopeSelector(variationSelector, external_wp_blocks_namespaceObject.__EXPERIMENTAL_ELEMENTS[element])
            });
          }
        });

        // Process the variations inner block type styles.
        Object.entries((_variation$blocks = variation?.blocks) !== null &amp;&amp; _variation$blocks !== void 0 ? _variation$blocks : {}).forEach(([variationBlockName, variationBlockStyles]) =&gt; {
          var _variationBlockStyles;
          const variationBlockSelector = scopeSelector(variationSelector, blockSelectors[variationBlockName]?.selector);
          const variationDuotoneSelector = scopeSelector(variationSelector, blockSelectors[variationBlockName]?.duotoneSelector);
          const variationFeatureSelectors = scopeFeatureSelectors(variationSelector, blockSelectors[variationBlockName]?.featureSelectors);
          const variationBlockStyleNodes = pickStyleKeys(variationBlockStyles);
          if (variationBlockStyles?.css) {
            variationBlockStyleNodes.css = variationBlockStyles.css;
          }
          nodes.push({
            selector: variationBlockSelector,
            duotoneSelector: variationDuotoneSelector,
            featureSelectors: variationFeatureSelectors,
            fallbackGapValue: blockSelectors[variationBlockName]?.fallbackGapValue,
            hasLayoutSupport: blockSelectors[variationBlockName]?.hasLayoutSupport,
            styles: variationBlockStyleNodes
          });

          // Process element styles for the inner blocks
          // of the variation.
          Object.entries((_variationBlockStyles = variationBlockStyles.elements) !== null &amp;&amp; _variationBlockStyles !== void 0 ? _variationBlockStyles : {}).forEach(([variationBlockElement, variationBlockElementStyles]) =&gt; {
            if (variationBlockElementStyles &amp;&amp; external_wp_blocks_namespaceObject.__EXPERIMENTAL_ELEMENTS[variationBlockElement]) {
              nodes.push({
                styles: variationBlockElementStyles,
                selector: scopeSelector(variationBlockSelector, external_wp_blocks_namespaceObject.__EXPERIMENTAL_ELEMENTS[variationBlockElement])
              });
            }
          });
        });
      });
      blockStyles.variations = variations;
    }
    if (blockSelectors?.[blockName]?.selector) {
      nodes.push({
        duotoneSelector: blockSelectors[blockName].duotoneSelector,
        fallbackGapValue: blockSelectors[blockName].fallbackGapValue,
        hasLayoutSupport: blockSelectors[blockName].hasLayoutSupport,
        selector: blockSelectors[blockName].selector,
        styles: blockStyles,
        featureSelectors: blockSelectors[blockName].featureSelectors,
        styleVariationSelectors: blockSelectors[blockName].styleVariationSelectors
      });
    }
    Object.entries((_node$elements = node?.elements) !== null &amp;&amp; _node$elements !== void 0 ? _node$elements : {}).forEach(([elementName, value]) =&gt; {
      if (value &amp;&amp; blockSelectors?.[blockName] &amp;&amp; external_wp_blocks_namespaceObject.__EXPERIMENTAL_ELEMENTS[elementName]) {
        nodes.push({
          styles: value,
          selector: blockSelectors[blockName]?.selector.split(&#039;,&#039;).map(sel =&gt; {
            const elementSelectors = external_wp_blocks_namespaceObject.__EXPERIMENTAL_ELEMENTS[elementName].split(&#039;,&#039;);
            return elementSelectors.map(elementSelector =&gt; sel + &#039; &#039; + elementSelector);
          }).join(&#039;,&#039;)
        });
      }
    });
  });
  return nodes;
};
const getNodesWithSettings = (tree, blockSelectors) =&gt; {
  var _tree$settings$blocks;
  const nodes = [];
  if (!tree?.settings) {
    return nodes;
  }
  const pickPresets = treeToPickFrom =&gt; {
    let presets = {};
    PRESET_METADATA.forEach(({
      path
    }) =&gt; {
      const value = getValueFromObjectPath(treeToPickFrom, path, false);
      if (value !== false) {
        presets = setImmutably(presets, path, value);
      }
    });
    return presets;
  };

  // Top-level.
  const presets = pickPresets(tree.settings);
  const custom = tree.settings?.custom;
  if (Object.keys(presets).length &gt; 0 || custom) {
    nodes.push({
      presets,
      custom,
      selector: ROOT_CSS_PROPERTIES_SELECTOR
    });
  }

  // Blocks.
  Object.entries((_tree$settings$blocks = tree.settings?.blocks) !== null &amp;&amp; _tree$settings$blocks !== void 0 ? _tree$settings$blocks : {}).forEach(([blockName, node]) =&gt; {
    const blockPresets = pickPresets(node);
    const blockCustom = node.custom;
    if (Object.keys(blockPresets).length &gt; 0 || blockCustom) {
      nodes.push({
        presets: blockPresets,
        custom: blockCustom,
        selector: blockSelectors[blockName]?.selector
      });
    }
  });
  return nodes;
};
const toCustomProperties = (tree, blockSelectors) =&gt; {
  const settings = getNodesWithSettings(tree, blockSelectors);
  let ruleset = &#039;&#039;;
  settings.forEach(({
    presets,
    custom,
    selector
  }) =&gt; {
    const declarations = getPresetsDeclarations(presets, tree?.settings);
    const customProps = flattenTree(custom, &#039;--wp--custom--&#039;, &#039;--&#039;);
    if (customProps.length &gt; 0) {
      declarations.push(...customProps);
    }
    if (declarations.length &gt; 0) {
      ruleset += `${selector}{${declarations.join(&#039;;&#039;)};}`;
    }
  });
  return ruleset;
};
const toStyles = (tree, blockSelectors, hasBlockGapSupport, hasFallbackGapSupport, disableLayoutStyles = false, disableRootPadding = false, styleOptions = undefined) =&gt; {
  // These allow opting out of certain sets of styles.
  const options = {
    blockGap: true,
    blockStyles: true,
    layoutStyles: true,
    marginReset: true,
    presets: true,
    rootPadding: true,
    variationStyles: false,
    ...styleOptions
  };
  const nodesWithStyles = getNodesWithStyles(tree, blockSelectors);
  const nodesWithSettings = getNodesWithSettings(tree, blockSelectors);
  const useRootPaddingAlign = tree?.settings?.useRootPaddingAwareAlignments;
  const {
    contentSize,
    wideSize
  } = tree?.settings?.layout || {};
  const hasBodyStyles = options.marginReset || options.rootPadding || options.layoutStyles;
  let ruleset = &#039;&#039;;
  if (options.presets &amp;&amp; (contentSize || wideSize)) {
    ruleset += `${ROOT_CSS_PROPERTIES_SELECTOR} {`;
    ruleset = contentSize ? ruleset + ` --wp--style--global--content-size: ${contentSize};` : ruleset;
    ruleset = wideSize ? ruleset + ` --wp--style--global--wide-size: ${wideSize};` : ruleset;
    ruleset += &#039;}&#039;;
  }
  if (hasBodyStyles) {
    /*
     * Reset default browser margin on the body element.
     * This is set on the body selector **before** generating the ruleset
     * from the `theme.json`. This is to ensure that if the `theme.json` declares
     * `margin` in its `spacing` declaration for the `body` element then these
     * user-generated values take precedence in the CSS cascade.
     * @link https://github.com/WordPress/gutenberg/issues/36147.
     */
    ruleset += &#039;:where(body) {margin: 0;&#039;;

    // Root padding styles should be output for full templates, patterns and template parts.
    if (options.rootPadding &amp;&amp; useRootPaddingAlign) {
      /*
       * These rules reproduce the ones from https://github.com/WordPress/gutenberg/blob/79103f124925d1f457f627e154f52a56228ed5ad/lib/class-wp-theme-json-gutenberg.php#L2508
       * almost exactly, but for the selectors that target block wrappers in the front end. This code only runs in the editor, so it doesn&#039;t need those selectors.
       */
      ruleset += `padding-right: 0; padding-left: 0; padding-top: var(--wp--style--root--padding-top); padding-bottom: var(--wp--style--root--padding-bottom) }
				.has-global-padding { padding-right: var(--wp--style--root--padding-right); padding-left: var(--wp--style--root--padding-left); }
				.has-global-padding &gt; .alignfull { margin-right: calc(var(--wp--style--root--padding-right) * -1); margin-left: calc(var(--wp--style--root--padding-left) * -1); }
				.has-global-padding :where(:not(.alignfull.is-layout-flow) &gt; .has-global-padding:not(.wp-block-block, .alignfull)) { padding-right: 0; padding-left: 0; }
				.has-global-padding :where(:not(.alignfull.is-layout-flow) &gt; .has-global-padding:not(.wp-block-block, .alignfull)) &gt; .alignfull { margin-left: 0; margin-right: 0;
				`;
    }
    ruleset += &#039;}&#039;;
  }
  if (options.blockStyles) {
    nodesWithStyles.forEach(({
      selector,
      duotoneSelector,
      styles,
      fallbackGapValue,
      hasLayoutSupport,
      featureSelectors,
      styleVariationSelectors,
      skipSelectorWrapper
    }) =&gt; {
      // Process styles for block support features with custom feature level
      // CSS selectors set.
      if (featureSelectors) {
        const featureDeclarations = getFeatureDeclarations(featureSelectors, styles);
        Object.entries(featureDeclarations).forEach(([cssSelector, declarations]) =&gt; {
          if (declarations.length) {
            const rules = declarations.join(&#039;;&#039;);
            ruleset += `:root :where(${cssSelector}){${rules};}`;
          }
        });
      }

      // Process duotone styles.
      if (duotoneSelector) {
        const duotoneStyles = {};
        if (styles?.filter) {
          duotoneStyles.filter = styles.filter;
          delete styles.filter;
        }
        const duotoneDeclarations = getStylesDeclarations(duotoneStyles);
        if (duotoneDeclarations.length) {
          ruleset += `${duotoneSelector}{${duotoneDeclarations.join(&#039;;&#039;)};}`;
        }
      }

      // Process blockGap and layout styles.
      if (!disableLayoutStyles &amp;&amp; (ROOT_BLOCK_SELECTOR === selector || hasLayoutSupport)) {
        ruleset += getLayoutStyles({
          style: styles,
          selector,
          hasBlockGapSupport,
          hasFallbackGapSupport,
          fallbackGapValue
        });
      }

      // Process the remaining block styles (they use either normal block class or __experimentalSelector).
      const styleDeclarations = getStylesDeclarations(styles, selector, useRootPaddingAlign, tree, disableRootPadding);
      if (styleDeclarations?.length) {
        const generalSelector = skipSelectorWrapper ? selector : `:root :where(${selector})`;
        ruleset += `${generalSelector}{${styleDeclarations.join(&#039;;&#039;)};}`;
      }
      if (styles?.css) {
        ruleset += processCSSNesting(styles.css, `:root :where(${selector})`);
      }
      if (options.variationStyles &amp;&amp; styleVariationSelectors) {
        Object.entries(styleVariationSelectors).forEach(([styleVariationName, styleVariationSelector]) =&gt; {
          const styleVariations = styles?.variations?.[styleVariationName];
          if (styleVariations) {
            // If the block uses any custom selectors for block support, add those first.
            if (featureSelectors) {
              const featureDeclarations = getFeatureDeclarations(featureSelectors, styleVariations);
              Object.entries(featureDeclarations).forEach(([baseSelector, declarations]) =&gt; {
                if (declarations.length) {
                  const cssSelector = concatFeatureVariationSelectorString(baseSelector, styleVariationSelector);
                  const rules = declarations.join(&#039;;&#039;);
                  ruleset += `:root :where(${cssSelector}){${rules};}`;
                }
              });
            }

            // Otherwise add regular selectors.
            const styleVariationDeclarations = getStylesDeclarations(styleVariations, styleVariationSelector, useRootPaddingAlign, tree);
            if (styleVariationDeclarations.length) {
              ruleset += `:root :where(${styleVariationSelector}){${styleVariationDeclarations.join(&#039;;&#039;)};}`;
            }
            if (styleVariations?.css) {
              ruleset += processCSSNesting(styleVariations.css, `:root :where(${styleVariationSelector})`);
            }
          }
        });
      }

      // Check for pseudo selector in `styles` and handle separately.
      const pseudoSelectorStyles = Object.entries(styles).filter(([key]) =&gt; key.startsWith(&#039;:&#039;));
      if (pseudoSelectorStyles?.length) {
        pseudoSelectorStyles.forEach(([pseudoKey, pseudoStyle]) =&gt; {
          const pseudoDeclarations = getStylesDeclarations(pseudoStyle);
          if (!pseudoDeclarations?.length) {
            return;
          }

          // `selector` may be provided in a form
          // where block level selectors have sub element
          // selectors appended to them as a comma separated
          // string.
          // e.g. `h1 a,h2 a,h3 a,h4 a,h5 a,h6 a`;
          // Split and append pseudo selector to create
          // the proper rules to target the elements.
          const _selector = selector.split(&#039;,&#039;).map(sel =&gt; sel + pseudoKey).join(&#039;,&#039;);

          // As pseudo classes such as :hover, :focus etc. have class-level
          // specificity, they must use the `:root :where()` wrapper. This.
          // caps the specificity at `0-1-0` to allow proper nesting of variations
          // and block type element styles.
          const pseudoRule = `:root :where(${_selector}){${pseudoDeclarations.join(&#039;;&#039;)};}`;
          ruleset += pseudoRule;
        });
      }
    });
  }
  if (options.layoutStyles) {
    /* Add alignment / layout styles */
    ruleset = ruleset + &#039;.wp-site-blocks &gt; .alignleft { float: left; margin-right: 2em; }&#039;;
    ruleset = ruleset + &#039;.wp-site-blocks &gt; .alignright { float: right; margin-left: 2em; }&#039;;
    ruleset = ruleset + &#039;.wp-site-blocks &gt; .aligncenter { justify-content: center; margin-left: auto; margin-right: auto; }&#039;;
  }
  if (options.blockGap &amp;&amp; hasBlockGapSupport) {
    // Use fallback of `0.5em` just in case, however if there is blockGap support, there should nearly always be a real value.
    const gapValue = getGapCSSValue(tree?.styles?.spacing?.blockGap) || &#039;0.5em&#039;;
    ruleset = ruleset + `:root :where(.wp-site-blocks) &gt; * { margin-block-start: ${gapValue}; margin-block-end: 0; }`;
    ruleset = ruleset + &#039;:root :where(.wp-site-blocks) &gt; :first-child { margin-block-start: 0; }&#039;;
    ruleset = ruleset + &#039;:root :where(.wp-site-blocks) &gt; :last-child { margin-block-end: 0; }&#039;;
  }
  if (options.presets) {
    nodesWithSettings.forEach(({
      selector,
      presets
    }) =&gt; {
      if (ROOT_BLOCK_SELECTOR === selector || ROOT_CSS_PROPERTIES_SELECTOR === selector) {
        // Do not add extra specificity for top-level classes.
        selector = &#039;&#039;;
      }
      const classes = getPresetsClasses(selector, presets);
      if (classes.length &gt; 0) {
        ruleset += classes;
      }
    });
  }
  return ruleset;
};
function toSvgFilters(tree, blockSelectors) {
  const nodesWithSettings = getNodesWithSettings(tree, blockSelectors);
  return nodesWithSettings.flatMap(({
    presets
  }) =&gt; {
    return getPresetsSvgFilters(presets);
  });
}
const getSelectorsConfig = (blockType, rootSelector) =&gt; {
  if (blockType?.selectors &amp;&amp; Object.keys(blockType.selectors).length &gt; 0) {
    return blockType.selectors;
  }
  const config = {
    root: rootSelector
  };
  Object.entries(BLOCK_SUPPORT_FEATURE_LEVEL_SELECTORS).forEach(([featureKey, featureName]) =&gt; {
    const featureSelector = getBlockCSSSelector(blockType, featureKey);
    if (featureSelector) {
      config[featureName] = featureSelector;
    }
  });
  return config;
};
const getBlockSelectors = (blockTypes, getBlockStyles, variationInstanceId) =&gt; {
  const result = {};
  blockTypes.forEach(blockType =&gt; {
    const name = blockType.name;
    const selector = getBlockCSSSelector(blockType);
    let duotoneSelector = getBlockCSSSelector(blockType, &#039;filter.duotone&#039;);

    // Keep backwards compatibility for support.color.__experimentalDuotone.
    if (!duotoneSelector) {
      const rootSelector = getBlockCSSSelector(blockType);
      const duotoneSupport = (0,external_wp_blocks_namespaceObject.getBlockSupport)(blockType, &#039;color.__experimentalDuotone&#039;, false);
      duotoneSelector = duotoneSupport &amp;&amp; scopeSelector(rootSelector, duotoneSupport);
    }
    const hasLayoutSupport = !!blockType?.supports?.layout || !!blockType?.supports?.__experimentalLayout;
    const fallbackGapValue = blockType?.supports?.spacing?.blockGap?.__experimentalDefault;
    const blockStyleVariations = getBlockStyles(name);
    const styleVariationSelectors = {};
    blockStyleVariations?.forEach(variation =&gt; {
      const variationSuffix = variationInstanceId ? `-${variationInstanceId}` : &#039;&#039;;
      const variationName = `${variation.name}${variationSuffix}`;
      const styleVariationSelector = getBlockStyleVariationSelector(variationName, selector);
      styleVariationSelectors[variationName] = styleVariationSelector;
    });

    // For each block support feature add any custom selectors.
    const featureSelectors = getSelectorsConfig(blockType, selector);
    result[name] = {
      duotoneSelector,
      fallbackGapValue,
      featureSelectors: Object.keys(featureSelectors).length ? featureSelectors : undefined,
      hasLayoutSupport,
      name,
      selector,
      styleVariationSelectors: blockStyleVariations?.length ? styleVariationSelectors : undefined
    };
  });
  return result;
};

/**
 * If there is a separator block whose color is defined in theme.json via background,
 * update the separator color to the same value by using border color.
 *
 * @param {Object} config Theme.json configuration file object.
 * @return {Object} configTheme.json configuration file object updated.
 */
function updateConfigWithSeparator(config) {
  const needsSeparatorStyleUpdate = config.styles?.blocks?.[&#039;core/separator&#039;] &amp;&amp; config.styles?.blocks?.[&#039;core/separator&#039;].color?.background &amp;&amp; !config.styles?.blocks?.[&#039;core/separator&#039;].color?.text &amp;&amp; !config.styles?.blocks?.[&#039;core/separator&#039;].border?.color;
  if (needsSeparatorStyleUpdate) {
    return {
      ...config,
      styles: {
        ...config.styles,
        blocks: {
          ...config.styles.blocks,
          &#039;core/separator&#039;: {
            ...config.styles.blocks[&#039;core/separator&#039;],
            color: {
              ...config.styles.blocks[&#039;core/separator&#039;].color,
              text: config.styles?.blocks[&#039;core/separator&#039;].color.background
            }
          }
        }
      }
    };
  }
  return config;
}
function processCSSNesting(css, blockSelector) {
  let processedCSS = &#039;&#039;;
  if (!css || css.trim() === &#039;&#039;) {
    return processedCSS;
  }

  // Split CSS nested rules.
  const parts = css.split(&#039;&amp;&#039;);
  parts.forEach(part =&gt; {
    if (!part || part.trim() === &#039;&#039;) {
      return;
    }
    const isRootCss = !part.includes(&#039;{&#039;);
    if (isRootCss) {
      // If the part doesn&#039;t contain braces, it applies to the root level.
      processedCSS += `:root :where(${blockSelector}){${part.trim()}}`;
    } else {
      // If the part contains braces, it&#039;s a nested CSS rule.
      const splitPart = part.replace(&#039;}&#039;, &#039;&#039;).split(&#039;{&#039;);
      if (splitPart.length !== 2) {
        return;
      }
      const [nestedSelector, cssValue] = splitPart;

      // Handle pseudo elements such as ::before, ::after, etc. Regex will also
      // capture any leading combinator such as &gt;, +, or ~, as well as spaces.
      // This allows pseudo elements as descendants e.g. `.parent ::before`.
      const matches = nestedSelector.match(/([&gt;+~\s]*::[a-zA-Z-]+)/);
      const pseudoPart = matches ? matches[1] : &#039;&#039;;
      const withoutPseudoElement = matches ? nestedSelector.replace(pseudoPart, &#039;&#039;).trim() : nestedSelector.trim();
      let combinedSelector;
      if (withoutPseudoElement === &#039;&#039;) {
        // Only contained a pseudo element to use the block selector to form
        // the final `:root :where()` selector.
        combinedSelector = blockSelector;
      } else {
        // If the nested selector is a descendant of the block scope it with the
        // block selector. Otherwise append it to the block selector.
        combinedSelector = nestedSelector.startsWith(&#039; &#039;) ? scopeSelector(blockSelector, withoutPseudoElement) : appendToSelector(blockSelector, withoutPseudoElement);
      }

      // Build final rule, re-adding any pseudo element outside the `:where()`
      // to maintain valid CSS selector.
      processedCSS += `:root :where(${combinedSelector})${pseudoPart}{${cssValue.trim()}}`;
    }
  });
  return processedCSS;
}

/**
 * Returns the global styles output using a global styles configuration.
 * If wishing to generate global styles and settings based on the
 * global styles config loaded in the editor context, use `useGlobalStylesOutput()`.
 * The use case for a custom config is to generate bespoke styles
 * and settings for previews, or other out-of-editor experiences.
 *
 * @param {Object}  mergedConfig       Global styles configuration.
 * @param {boolean} disableRootPadding Disable root padding styles.
 *
 * @return {Array} Array of stylesheets and settings.
 */
function useGlobalStylesOutputWithConfig(mergedConfig = {}, disableRootPadding) {
  const [blockGap] = useGlobalSetting(&#039;spacing.blockGap&#039;);
  const hasBlockGapSupport = blockGap !== null;
  const hasFallbackGapSupport = !hasBlockGapSupport; // This setting isn&#039;t useful yet: it exists as a placeholder for a future explicit fallback styles support.
  const disableLayoutStyles = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      getSettings
    } = select(store);
    return !!getSettings().disableLayoutStyles;
  });
  const {
    getBlockStyles
  } = (0,external_wp_data_namespaceObject.useSelect)(external_wp_blocks_namespaceObject.store);
  return (0,external_wp_element_namespaceObject.useMemo)(() =&gt; {
    var _updatedConfig$styles;
    if (!mergedConfig?.styles || !mergedConfig?.settings) {
      return [];
    }
    const updatedConfig = updateConfigWithSeparator(mergedConfig);
    const blockSelectors = getBlockSelectors((0,external_wp_blocks_namespaceObject.getBlockTypes)(), getBlockStyles);
    const customProperties = toCustomProperties(updatedConfig, blockSelectors);
    const globalStyles = toStyles(updatedConfig, blockSelectors, hasBlockGapSupport, hasFallbackGapSupport, disableLayoutStyles, disableRootPadding);
    const svgs = toSvgFilters(updatedConfig, blockSelectors);
    const styles = [{
      css: customProperties,
      isGlobalStyles: true
    }, {
      css: globalStyles,
      isGlobalStyles: true
    },
    // Load custom CSS in own stylesheet so that any invalid CSS entered in the input won&#039;t break all the global styles in the editor.
    {
      css: (_updatedConfig$styles = updatedConfig.styles.css) !== null &amp;&amp; _updatedConfig$styles !== void 0 ? _updatedConfig$styles : &#039;&#039;,
      isGlobalStyles: true
    }, {
      assets: svgs,
      __unstableType: &#039;svg&#039;,
      isGlobalStyles: true
    }];

    // Loop through the blocks to check if there are custom CSS values.
    // If there are, get the block selector and push the selector together with
    // the CSS value to the &#039;stylesheets&#039; array.
    (0,external_wp_blocks_namespaceObject.getBlockTypes)().forEach(blockType =&gt; {
      if (updatedConfig.styles.blocks[blockType.name]?.css) {
        const selector = blockSelectors[blockType.name].selector;
        styles.push({
          css: processCSSNesting(updatedConfig.styles.blocks[blockType.name]?.css, selector),
          isGlobalStyles: true
        });
      }
    });
    return [styles, updatedConfig.settings];
  }, [hasBlockGapSupport, hasFallbackGapSupport, mergedConfig, disableLayoutStyles, disableRootPadding, getBlockStyles]);
}

/**
 * Returns the global styles output based on the current state of global styles config loaded in the editor context.
 *
 * @param {boolean} disableRootPadding Disable root padding styles.
 *
 * @return {Array} Array of stylesheets and settings.
 */
function useGlobalStylesOutput(disableRootPadding = false) {
  const {
    merged: mergedConfig
  } = (0,external_wp_element_namespaceObject.useContext)(GlobalStylesContext);
  return useGlobalStylesOutputWithConfig(mergedConfig, disableRootPadding);
}

;// ./node_modules/@wordpress/block-editor/build-module/hooks/block-style-variation.js
/**
 * WordPress dependencies
 */




/**
 * Internal dependencies
 */







const VARIATION_PREFIX = &#039;is-style-&#039;;
function getVariationMatches(className) {
  if (!className) {
    return [];
  }
  return className.split(/\s+/).reduce((matches, name) =&gt; {
    if (name.startsWith(VARIATION_PREFIX)) {
      const match = name.slice(VARIATION_PREFIX.length);
      if (match !== &#039;default&#039;) {
        matches.push(match);
      }
    }
    return matches;
  }, []);
}

/**
 * Get the first block style variation that has been registered from the class string.
 *
 * @param {string} className        CSS class string for a block.
 * @param {Array}  registeredStyles Currently registered block styles.
 *
 * @return {string|null} The name of the first registered variation.
 */
function getVariationNameFromClass(className, registeredStyles = []) {
  // The global flag affects how capturing groups work in JS. So the regex
  // below will only return full CSS classes not just the variation name.
  const matches = getVariationMatches(className);
  if (!matches) {
    return null;
  }
  for (const variation of matches) {
    if (registeredStyles.some(style =&gt; style.name === variation)) {
      return variation;
    }
  }
  return null;
}

// A helper component to apply a style override using the useStyleOverride hook.
function OverrideStyles({
  override
}) {
  usePrivateStyleOverride(override);
}

/**
 * This component is used to generate new block style variation overrides
 * based on an incoming theme config. If a matching style is found in the config,
 * a new override is created and returned. The overrides can be used in conjunction with
 * useStyleOverride to apply the new styles to the editor. Its use is
 * subject to change.
 *
 * @param {Object} props        Props.
 * @param {Object} props.config A global styles object, containing settings and styles.
 * @return {JSX.Element|undefined} An array of new block variation overrides.
 */
function __unstableBlockStyleVariationOverridesWithConfig({
  config
}) {
  const {
    getBlockStyles,
    overrides
  } = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; ({
    getBlockStyles: select(external_wp_blocks_namespaceObject.store).getBlockStyles,
    overrides: unlock(select(store)).getStyleOverrides()
  }), []);
  const {
    getBlockName
  } = (0,external_wp_data_namespaceObject.useSelect)(store);
  const overridesWithConfig = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; {
    if (!overrides?.length) {
      return;
    }
    const newOverrides = [];
    const overriddenClientIds = [];
    for (const [, override] of overrides) {
      if (override?.variation &amp;&amp; override?.clientId &amp;&amp;
      /*
       * Because this component overwrites existing style overrides,
       * filter out any overrides that are already present in the store.
       */
      !overriddenClientIds.includes(override.clientId)) {
        const blockName = getBlockName(override.clientId);
        const configStyles = config?.styles?.blocks?.[blockName]?.variations?.[override.variation];
        if (configStyles) {
          const variationConfig = {
            settings: config?.settings,
            // The variation style data is all that is needed to generate
            // the styles for the current application to a block. The variation
            // name is updated to match the instance specific class name.
            styles: {
              blocks: {
                [blockName]: {
                  variations: {
                    [`${override.variation}-${override.clientId}`]: configStyles
                  }
                }
              }
            }
          };
          const blockSelectors = getBlockSelectors((0,external_wp_blocks_namespaceObject.getBlockTypes)(), getBlockStyles, override.clientId);
          const hasBlockGapSupport = false;
          const hasFallbackGapSupport = true;
          const disableLayoutStyles = true;
          const disableRootPadding = true;
          const variationStyles = toStyles(variationConfig, blockSelectors, hasBlockGapSupport, hasFallbackGapSupport, disableLayoutStyles, disableRootPadding, {
            blockGap: false,
            blockStyles: true,
            layoutStyles: false,
            marginReset: false,
            presets: false,
            rootPadding: false,
            variationStyles: true
          });
          newOverrides.push({
            id: `${override.variation}-${override.clientId}`,
            css: variationStyles,
            __unstableType: &#039;variation&#039;,
            variation: override.variation,
            // The clientId will be stored with the override and used to ensure
            // the order of overrides matches the order of blocks so that the
            // correct CSS cascade is maintained.
            clientId: override.clientId
          });
          overriddenClientIds.push(override.clientId);
        }
      }
    }
    return newOverrides;
  }, [config, overrides, getBlockStyles, getBlockName]);
  if (!overridesWithConfig || !overridesWithConfig.length) {
    return;
  }
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_ReactJSXRuntime_namespaceObject.Fragment, {
    children: overridesWithConfig.map(override =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(OverrideStyles, {
      override: override
    }, override.id))
  });
}

/**
 * Retrieves any variation styles data and resolves any referenced values.
 *
 * @param {Object}    globalStyles A complete global styles object, containing settings and styles.
 * @param {string}    name         The name of the desired block type.
 * @param {variation} variation    The of the block style variation to retrieve data for.
 *
 * @return {Object|undefined} The global styles data for the specified variation.
 */
function getVariationStylesWithRefValues(globalStyles, name, variation) {
  if (!globalStyles?.styles?.blocks?.[name]?.variations?.[variation]) {
    return;
  }

  // Helper to recursively look for `ref` values to resolve.
  const replaceRefs = variationStyles =&gt; {
    Object.keys(variationStyles).forEach(key =&gt; {
      const value = variationStyles[key];

      // Only process objects.
      if (typeof value === &#039;object&#039; &amp;&amp; value !== null) {
        // Process `ref` value if present.
        if (value.ref !== undefined) {
          if (typeof value.ref !== &#039;string&#039; || value.ref.trim() === &#039;&#039;) {
            // Remove invalid ref.
            delete variationStyles[key];
          } else {
            // Resolve `ref` value.
            const refValue = getValueFromObjectPath(globalStyles, value.ref);
            if (refValue) {
              variationStyles[key] = refValue;
            } else {
              delete variationStyles[key];
            }
          }
        } else {
          // Recursively resolve `ref` values in nested objects.
          replaceRefs(value);

          // After recursion, if value is empty due to explicitly
          // `undefined` ref value, remove it.
          if (Object.keys(value).length === 0) {
            delete variationStyles[key];
          }
        }
      }
    });
  };

  // Deep clone variation node to avoid mutating it within global styles and losing refs.
  const styles = JSON.parse(JSON.stringify(globalStyles.styles.blocks[name].variations[variation]));
  replaceRefs(styles);
  return styles;
}
function useBlockStyleVariation(name, variation, clientId) {
  // Prefer global styles data in GlobalStylesContext, which are available
  // if in the site editor. Otherwise fall back to whatever is in the
  // editor settings and available in the post editor.
  const {
    merged: mergedConfig
  } = (0,external_wp_element_namespaceObject.useContext)(GlobalStylesContext);
  const {
    globalSettings,
    globalStyles
  } = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const settings = select(store).getSettings();
    return {
      globalSettings: settings.__experimentalFeatures,
      globalStyles: settings[globalStylesDataKey]
    };
  }, []);
  return (0,external_wp_element_namespaceObject.useMemo)(() =&gt; {
    var _mergedConfig$setting, _mergedConfig$styles, _mergedConfig$setting2;
    const variationStyles = getVariationStylesWithRefValues({
      settings: (_mergedConfig$setting = mergedConfig?.settings) !== null &amp;&amp; _mergedConfig$setting !== void 0 ? _mergedConfig$setting : globalSettings,
      styles: (_mergedConfig$styles = mergedConfig?.styles) !== null &amp;&amp; _mergedConfig$styles !== void 0 ? _mergedConfig$styles : globalStyles
    }, name, variation);
    return {
      settings: (_mergedConfig$setting2 = mergedConfig?.settings) !== null &amp;&amp; _mergedConfig$setting2 !== void 0 ? _mergedConfig$setting2 : globalSettings,
      // The variation style data is all that is needed to generate
      // the styles for the current application to a block. The variation
      // name is updated to match the instance specific class name.
      styles: {
        blocks: {
          [name]: {
            variations: {
              [`${variation}-${clientId}`]: variationStyles
            }
          }
        }
      }
    };
  }, [mergedConfig, globalSettings, globalStyles, variation, clientId, name]);
}

// Rather than leveraging `useInstanceId` here, the `clientId` is used.
// This is so that the variation style override&#039;s ID is predictable
// when the order of applied style variations changes.
function block_style_variation_useBlockProps({
  name,
  className,
  clientId
}) {
  const {
    getBlockStyles
  } = (0,external_wp_data_namespaceObject.useSelect)(external_wp_blocks_namespaceObject.store);
  const registeredStyles = getBlockStyles(name);
  const variation = getVariationNameFromClass(className, registeredStyles);
  const variationClass = `${VARIATION_PREFIX}${variation}-${clientId}`;
  const {
    settings,
    styles
  } = useBlockStyleVariation(name, variation, clientId);
  const variationStyles = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; {
    if (!variation) {
      return;
    }
    const variationConfig = {
      settings,
      styles
    };
    const blockSelectors = getBlockSelectors((0,external_wp_blocks_namespaceObject.getBlockTypes)(), getBlockStyles, clientId);
    const hasBlockGapSupport = false;
    const hasFallbackGapSupport = true;
    const disableLayoutStyles = true;
    const disableRootPadding = true;
    return toStyles(variationConfig, blockSelectors, hasBlockGapSupport, hasFallbackGapSupport, disableLayoutStyles, disableRootPadding, {
      blockGap: false,
      blockStyles: true,
      layoutStyles: false,
      marginReset: false,
      presets: false,
      rootPadding: false,
      variationStyles: true
    });
  }, [variation, settings, styles, getBlockStyles, clientId]);
  usePrivateStyleOverride({
    id: `variation-${clientId}`,
    css: variationStyles,
    __unstableType: &#039;variation&#039;,
    variation,
    // The clientId will be stored with the override and used to ensure
    // the order of overrides matches the order of blocks so that the
    // correct CSS cascade is maintained.
    clientId
  });
  return variation ? {
    className: variationClass
  } : {};
}
/* harmony default export */ const block_style_variation = ({
  hasSupport: () =&gt; true,
  attributeKeys: [&#039;className&#039;],
  isMatch: ({
    className
  }) =&gt; getVariationMatches(className).length &gt; 0,
  useBlockProps: block_style_variation_useBlockProps
});

;// ./node_modules/@wordpress/block-editor/build-module/hooks/layout.js
/**
 * External dependencies
 */


/**
 * WordPress dependencies
 */







/**
 * Internal dependencies
 */









const layoutBlockSupportKey = &#039;layout&#039;;
const {
  kebabCase: layout_kebabCase
} = unlock(external_wp_components_namespaceObject.privateApis);
function hasLayoutBlockSupport(blockName) {
  return (0,external_wp_blocks_namespaceObject.hasBlockSupport)(blockName, &#039;layout&#039;) || (0,external_wp_blocks_namespaceObject.hasBlockSupport)(blockName, &#039;__experimentalLayout&#039;);
}

/**
 * Generates the utility classnames for the given block&#039;s layout attributes.
 *
 * @param { Object } blockAttributes Block attributes.
 * @param { string } blockName       Block name.
 *
 * @return { Array } Array of CSS classname strings.
 */
function useLayoutClasses(blockAttributes = {}, blockName = &#039;&#039;) {
  const {
    layout
  } = blockAttributes;
  const {
    default: defaultBlockLayout
  } = (0,external_wp_blocks_namespaceObject.getBlockSupport)(blockName, layoutBlockSupportKey) || {};
  const usedLayout = layout?.inherit || layout?.contentSize || layout?.wideSize ? {
    ...layout,
    type: &#039;constrained&#039;
  } : layout || defaultBlockLayout || {};
  const layoutClassnames = [];
  if (LAYOUT_DEFINITIONS[usedLayout?.type || &#039;default&#039;]?.className) {
    const baseClassName = LAYOUT_DEFINITIONS[usedLayout?.type || &#039;default&#039;]?.className;
    const splitBlockName = blockName.split(&#039;/&#039;);
    const fullBlockName = splitBlockName[0] === &#039;core&#039; ? splitBlockName.pop() : splitBlockName.join(&#039;-&#039;);
    const compoundClassName = `wp-block-${fullBlockName}-${baseClassName}`;
    layoutClassnames.push(baseClassName, compoundClassName);
  }
  const hasGlobalPadding = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    return (usedLayout?.inherit || usedLayout?.contentSize || usedLayout?.type === &#039;constrained&#039;) &amp;&amp; select(store).getSettings().__experimentalFeatures?.useRootPaddingAwareAlignments;
  }, [usedLayout?.contentSize, usedLayout?.inherit, usedLayout?.type]);
  if (hasGlobalPadding) {
    layoutClassnames.push(&#039;has-global-padding&#039;);
  }
  if (usedLayout?.orientation) {
    layoutClassnames.push(`is-${layout_kebabCase(usedLayout.orientation)}`);
  }
  if (usedLayout?.justifyContent) {
    layoutClassnames.push(`is-content-justification-${layout_kebabCase(usedLayout.justifyContent)}`);
  }
  if (usedLayout?.flexWrap &amp;&amp; usedLayout.flexWrap === &#039;nowrap&#039;) {
    layoutClassnames.push(&#039;is-nowrap&#039;);
  }
  return layoutClassnames;
}

/**
 * Generates a CSS rule with the given block&#039;s layout styles.
 *
 * @param { Object } blockAttributes Block attributes.
 * @param { string } blockName       Block name.
 * @param { string } selector        A selector to use in generating the CSS rule.
 *
 * @return { string } CSS rule.
 */
function useLayoutStyles(blockAttributes = {}, blockName, selector) {
  const {
    layout = {},
    style = {}
  } = blockAttributes;
  // Update type for blocks using legacy layouts.
  const usedLayout = layout?.inherit || layout?.contentSize || layout?.wideSize ? {
    ...layout,
    type: &#039;constrained&#039;
  } : layout || {};
  const fullLayoutType = getLayoutType(usedLayout?.type || &#039;default&#039;);
  const [blockGapSupport] = use_settings_useSettings(&#039;spacing.blockGap&#039;);
  const hasBlockGapSupport = blockGapSupport !== null;
  return fullLayoutType?.getLayoutStyle?.({
    blockName,
    selector,
    layout,
    style,
    hasBlockGapSupport
  });
}
function LayoutPanelPure({
  layout,
  setAttributes,
  name: blockName,
  clientId
}) {
  const settings = useBlockSettings(blockName);
  // Block settings come from theme.json under settings.[blockName].
  const {
    layout: layoutSettings
  } = settings;
  const {
    themeSupportsLayout
  } = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      getSettings
    } = select(store);
    return {
      themeSupportsLayout: getSettings().supportsLayout
    };
  }, []);
  const blockEditingMode = useBlockEditingMode();
  if (blockEditingMode !== &#039;default&#039;) {
    return null;
  }

  // Layout block support comes from the block&#039;s block.json.
  const layoutBlockSupport = (0,external_wp_blocks_namespaceObject.getBlockSupport)(blockName, layoutBlockSupportKey, {});
  const blockSupportAndThemeSettings = {
    ...layoutSettings,
    ...layoutBlockSupport
  };
  const {
    allowSwitching,
    allowEditing = true,
    allowInheriting = true,
    default: defaultBlockLayout
  } = blockSupportAndThemeSettings;
  if (!allowEditing) {
    return null;
  }

  /*
   * Try to find the layout type from either the
   * block&#039;s layout settings or any saved layout config.
   */
  const blockSupportAndLayout = {
    ...layoutBlockSupport,
    ...layout
  };
  const {
    type,
    default: {
      type: defaultType = &#039;default&#039;
    } = {}
  } = blockSupportAndLayout;
  const blockLayoutType = type || defaultType;

  // Only show the inherit toggle if it&#039;s supported,
  // and either the default / flow or the constrained layout type is in use, as the toggle switches from one to the other.
  const showInheritToggle = !!(allowInheriting &amp;&amp; (!blockLayoutType || blockLayoutType === &#039;default&#039; || blockLayoutType === &#039;constrained&#039; || blockSupportAndLayout.inherit));
  const usedLayout = layout || defaultBlockLayout || {};
  const {
    inherit = false,
    contentSize = null
  } = usedLayout;
  /**
   * `themeSupportsLayout` is only relevant to the `default/flow` or
   * `constrained` layouts and it should not be taken into account when other
   * `layout` types are used.
   */
  if ((blockLayoutType === &#039;default&#039; || blockLayoutType === &#039;constrained&#039;) &amp;&amp; !themeSupportsLayout) {
    return null;
  }
  const layoutType = getLayoutType(blockLayoutType);
  const constrainedType = getLayoutType(&#039;constrained&#039;);
  const displayControlsForLegacyLayouts = !usedLayout.type &amp;&amp; (contentSize || inherit);
  const hasContentSizeOrLegacySettings = !!inherit || !!contentSize;
  const onChangeType = newType =&gt; setAttributes({
    layout: {
      type: newType
    }
  });
  const onChangeLayout = newLayout =&gt; setAttributes({
    layout: newLayout
  });
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls, {
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.PanelBody, {
        title: (0,external_wp_i18n_namespaceObject.__)(&#039;Layout&#039;),
        children: [showInheritToggle &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_ReactJSXRuntime_namespaceObject.Fragment, {
          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToggleControl, {
            __nextHasNoMarginBottom: true,
            label: (0,external_wp_i18n_namespaceObject.__)(&#039;Inner blocks use content width&#039;),
            checked: layoutType?.name === &#039;constrained&#039; || hasContentSizeOrLegacySettings,
            onChange: () =&gt; setAttributes({
              layout: {
                type: layoutType?.name === &#039;constrained&#039; || hasContentSizeOrLegacySettings ? &#039;default&#039; : &#039;constrained&#039;
              }
            }),
            help: layoutType?.name === &#039;constrained&#039; || hasContentSizeOrLegacySettings ? (0,external_wp_i18n_namespaceObject.__)(&#039;Nested blocks use content width with options for full and wide widths.&#039;) : (0,external_wp_i18n_namespaceObject.__)(&#039;Nested blocks will fill the width of this container.&#039;)
          })
        }), !inherit &amp;&amp; allowSwitching &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(LayoutTypeSwitcher, {
          type: blockLayoutType,
          onChange: onChangeType
        }), layoutType &amp;&amp; layoutType.name !== &#039;default&#039; &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(layoutType.inspectorControls, {
          layout: usedLayout,
          onChange: onChangeLayout,
          layoutBlockSupport: blockSupportAndThemeSettings,
          name: blockName,
          clientId: clientId
        }), constrainedType &amp;&amp; displayControlsForLegacyLayouts &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(constrainedType.inspectorControls, {
          layout: usedLayout,
          onChange: onChangeLayout,
          layoutBlockSupport: blockSupportAndThemeSettings,
          name: blockName,
          clientId: clientId
        })]
      })
    }), !inherit &amp;&amp; layoutType &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(layoutType.toolBarControls, {
      layout: usedLayout,
      onChange: onChangeLayout,
      layoutBlockSupport: layoutBlockSupport,
      name: blockName,
      clientId: clientId
    })]
  });
}
/* harmony default export */ const layout = ({
  shareWithChildBlocks: true,
  edit: LayoutPanelPure,
  attributeKeys: [&#039;layout&#039;],
  hasSupport(name) {
    return hasLayoutBlockSupport(name);
  }
});
function LayoutTypeSwitcher({
  type,
  onChange
}) {
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControl, {
    __next40pxDefaultSize: true,
    isBlock: true,
    label: (0,external_wp_i18n_namespaceObject.__)(&#039;Layout type&#039;),
    __nextHasNoMarginBottom: true,
    hideLabelFromVision: true,
    isAdaptiveWidth: true,
    value: type,
    onChange: onChange,
    children: getLayoutTypes().map(({
      name,
      label
    }) =&gt; {
      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControlOption, {
        value: name,
        label: label
      }, name);
    })
  });
}

/**
 * Filters registered block settings, extending attributes to include `layout`.
 *
 * @param {Object} settings Original block settings.
 *
 * @return {Object} Filtered block settings.
 */
function layout_addAttribute(settings) {
  var _settings$attributes$;
  if (&#039;type&#039; in ((_settings$attributes$ = settings.attributes?.layout) !== null &amp;&amp; _settings$attributes$ !== void 0 ? _settings$attributes$ : {})) {
    return settings;
  }
  if (hasLayoutBlockSupport(settings)) {
    settings.attributes = {
      ...settings.attributes,
      layout: {
        type: &#039;object&#039;
      }
    };
  }
  return settings;
}
function BlockWithLayoutStyles({
  block: BlockListBlock,
  props,
  blockGapSupport,
  layoutClasses
}) {
  const {
    name,
    attributes
  } = props;
  const id = (0,external_wp_compose_namespaceObject.useInstanceId)(BlockListBlock);
  const {
    layout
  } = attributes;
  const {
    default: defaultBlockLayout
  } = (0,external_wp_blocks_namespaceObject.getBlockSupport)(name, layoutBlockSupportKey) || {};
  const usedLayout = layout?.inherit || layout?.contentSize || layout?.wideSize ? {
    ...layout,
    type: &#039;constrained&#039;
  } : layout || defaultBlockLayout || {};
  const selectorPrefix = `wp-container-${layout_kebabCase(name)}-is-layout-`;
  // Higher specificity to override defaults from theme.json.
  const selector = `.${selectorPrefix}${id}`;
  const hasBlockGapSupport = blockGapSupport !== null;

  // Get CSS string for the current layout type.
  // The CSS and `style` element is only output if it is not empty.
  const fullLayoutType = getLayoutType(usedLayout?.type || &#039;default&#039;);
  const css = fullLayoutType?.getLayoutStyle?.({
    blockName: name,
    selector,
    layout: usedLayout,
    style: attributes?.style,
    hasBlockGapSupport
  });

  // Attach a `wp-container-` id-based class name as well as a layout class name such as `is-layout-flex`.
  const layoutClassNames = dist_clsx({
    [`${selectorPrefix}${id}`]: !!css // Only attach a container class if there is generated CSS to be attached.
  }, layoutClasses);
  useStyleOverride({
    css
  });
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockListBlock, {
    ...props,
    __unstableLayoutClassNames: layoutClassNames
  });
}

/**
 * Override the default block element to add the layout styles.
 *
 * @param {Function} BlockListBlock Original component.
 *
 * @return {Function} Wrapped component.
 */
const withLayoutStyles = (0,external_wp_compose_namespaceObject.createHigherOrderComponent)(BlockListBlock =&gt; props =&gt; {
  const {
    clientId,
    name,
    attributes
  } = props;
  const blockSupportsLayout = hasLayoutBlockSupport(name);
  const layoutClasses = useLayoutClasses(attributes, name);
  const extraProps = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    // The callback returns early to avoid block editor subscription.
    if (!blockSupportsLayout) {
      return;
    }
    const {
      getSettings,
      getBlockSettings
    } = unlock(select(store));
    const {
      disableLayoutStyles
    } = getSettings();
    if (disableLayoutStyles) {
      return;
    }
    const [blockGapSupport] = getBlockSettings(clientId, &#039;spacing.blockGap&#039;);
    return {
      blockGapSupport
    };
  }, [blockSupportsLayout, clientId]);
  if (!extraProps) {
    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockListBlock, {
      ...props,
      __unstableLayoutClassNames: blockSupportsLayout ? layoutClasses : undefined
    });
  }
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockWithLayoutStyles, {
    block: BlockListBlock,
    props: props,
    layoutClasses: layoutClasses,
    ...extraProps
  });
}, &#039;withLayoutStyles&#039;);
(0,external_wp_hooks_namespaceObject.addFilter)(&#039;blocks.registerBlockType&#039;, &#039;core/layout/addAttribute&#039;, layout_addAttribute);
(0,external_wp_hooks_namespaceObject.addFilter)(&#039;editor.BlockListBlock&#039;, &#039;core/editor/layout/with-layout-styles&#039;, withLayoutStyles);

;// ./node_modules/@wordpress/block-editor/build-module/components/grid/utils.js
function range(start, length) {
  return Array.from({
    length
  }, (_, i) =&gt; start + i);
}
class GridRect {
  constructor({
    columnStart,
    rowStart,
    columnEnd,
    rowEnd,
    columnSpan,
    rowSpan
  } = {}) {
    this.columnStart = columnStart !== null &amp;&amp; columnStart !== void 0 ? columnStart : 1;
    this.rowStart = rowStart !== null &amp;&amp; rowStart !== void 0 ? rowStart : 1;
    if (columnSpan !== undefined) {
      this.columnEnd = this.columnStart + columnSpan - 1;
    } else {
      this.columnEnd = columnEnd !== null &amp;&amp; columnEnd !== void 0 ? columnEnd : this.columnStart;
    }
    if (rowSpan !== undefined) {
      this.rowEnd = this.rowStart + rowSpan - 1;
    } else {
      this.rowEnd = rowEnd !== null &amp;&amp; rowEnd !== void 0 ? rowEnd : this.rowStart;
    }
  }
  get columnSpan() {
    return this.columnEnd - this.columnStart + 1;
  }
  get rowSpan() {
    return this.rowEnd - this.rowStart + 1;
  }
  contains(column, row) {
    return column &gt;= this.columnStart &amp;&amp; column &lt;= this.columnEnd &amp;&amp; row &gt;= this.rowStart &amp;&amp; row &lt;= this.rowEnd;
  }
  containsRect(rect) {
    return this.contains(rect.columnStart, rect.rowStart) &amp;&amp; this.contains(rect.columnEnd, rect.rowEnd);
  }
  intersectsRect(rect) {
    return this.columnStart &lt;= rect.columnEnd &amp;&amp; this.columnEnd &gt;= rect.columnStart &amp;&amp; this.rowStart &lt;= rect.rowEnd &amp;&amp; this.rowEnd &gt;= rect.rowStart;
  }
}
function utils_getComputedCSS(element, property) {
  return element.ownerDocument.defaultView.getComputedStyle(element).getPropertyValue(property);
}

/**
 * Given a grid-template-columns or grid-template-rows CSS property value, gets the start and end
 * position in pixels of each grid track.
 *
 * https://css-tricks.com/snippets/css/complete-guide-grid/#aa-grid-track
 *
 * @param {string} template The grid-template-columns or grid-template-rows CSS property value.
 *                          Only supports fixed sizes in pixels.
 * @param {number} gap      The gap between grid tracks in pixels.
 *
 * @return {Array&lt;{start: number, end: number}&gt;} An array of objects with the start and end
 *                                               position in pixels of each grid track.
 */
function getGridTracks(template, gap) {
  const tracks = [];
  for (const size of template.split(&#039; &#039;)) {
    const previousTrack = tracks[tracks.length - 1];
    const start = previousTrack ? previousTrack.end + gap : 0;
    const end = start + parseFloat(size);
    tracks.push({
      start,
      end
    });
  }
  return tracks;
}

/**
 * Given an array of grid tracks and a position in pixels, gets the index of the closest track to
 * that position.
 *
 * https://css-tricks.com/snippets/css/complete-guide-grid/#aa-grid-track
 *
 * @param {Array&lt;{start: number, end: number}&gt;} tracks   An array of objects with the start and end
 *                                                       position in pixels of each grid track.
 * @param {number}                              position The position in pixels.
 * @param {string}                              edge     The edge of the track to compare the
 *                                                       position to. Either &#039;start&#039; or &#039;end&#039;.
 *
 * @return {number} The index of the closest track to the position. 0-based, unlike CSS grid which
 *                  is 1-based.
 */
function getClosestTrack(tracks, position, edge = &#039;start&#039;) {
  return tracks.reduce((closest, track, index) =&gt; Math.abs(track[edge] - position) &lt; Math.abs(tracks[closest][edge] - position) ? index : closest, 0);
}
function getGridRect(gridElement, rect) {
  const columnGap = parseFloat(utils_getComputedCSS(gridElement, &#039;column-gap&#039;));
  const rowGap = parseFloat(utils_getComputedCSS(gridElement, &#039;row-gap&#039;));
  const gridColumnTracks = getGridTracks(utils_getComputedCSS(gridElement, &#039;grid-template-columns&#039;), columnGap);
  const gridRowTracks = getGridTracks(utils_getComputedCSS(gridElement, &#039;grid-template-rows&#039;), rowGap);
  const columnStart = getClosestTrack(gridColumnTracks, rect.left) + 1;
  const rowStart = getClosestTrack(gridRowTracks, rect.top) + 1;
  const columnEnd = getClosestTrack(gridColumnTracks, rect.right, &#039;end&#039;) + 1;
  const rowEnd = getClosestTrack(gridRowTracks, rect.bottom, &#039;end&#039;) + 1;
  return new GridRect({
    columnStart,
    columnEnd,
    rowStart,
    rowEnd
  });
}
function getGridItemRect(gridItemElement) {
  return getGridRect(gridItemElement.parentElement, new window.DOMRect(gridItemElement.offsetLeft, gridItemElement.offsetTop, gridItemElement.offsetWidth, gridItemElement.offsetHeight));
}
function getGridInfo(gridElement) {
  const gridTemplateColumns = utils_getComputedCSS(gridElement, &#039;grid-template-columns&#039;);
  const gridTemplateRows = utils_getComputedCSS(gridElement, &#039;grid-template-rows&#039;);
  const borderTopWidth = utils_getComputedCSS(gridElement, &#039;border-top-width&#039;);
  const borderRightWidth = utils_getComputedCSS(gridElement, &#039;border-right-width&#039;);
  const borderBottomWidth = utils_getComputedCSS(gridElement, &#039;border-bottom-width&#039;);
  const borderLeftWidth = utils_getComputedCSS(gridElement, &#039;border-left-width&#039;);
  const paddingTop = utils_getComputedCSS(gridElement, &#039;padding-top&#039;);
  const paddingRight = utils_getComputedCSS(gridElement, &#039;padding-right&#039;);
  const paddingBottom = utils_getComputedCSS(gridElement, &#039;padding-bottom&#039;);
  const paddingLeft = utils_getComputedCSS(gridElement, &#039;padding-left&#039;);
  const numColumns = gridTemplateColumns.split(&#039; &#039;).length;
  const numRows = gridTemplateRows.split(&#039; &#039;).length;
  const numItems = numColumns * numRows;
  return {
    numColumns,
    numRows,
    numItems,
    currentColor: utils_getComputedCSS(gridElement, &#039;color&#039;),
    style: {
      gridTemplateColumns,
      gridTemplateRows,
      gap: utils_getComputedCSS(gridElement, &#039;gap&#039;),
      inset: `
				calc(${paddingTop} + ${borderTopWidth})
				calc(${paddingRight} + ${borderRightWidth})
				calc(${paddingBottom} + ${borderBottomWidth})
				calc(${paddingLeft} + ${borderLeftWidth})
			`
    }
  };
}

;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/tips.js
/**
 * WordPress dependencies
 */




const globalTips = [(0,external_wp_element_namespaceObject.createInterpolateElement)((0,external_wp_i18n_namespaceObject.__)(&#039;While writing, you can press &lt;kbd&gt;/&lt;/kbd&gt; to quickly insert new blocks.&#039;), {
  kbd: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;kbd&quot;, {})
}), (0,external_wp_element_namespaceObject.createInterpolateElement)((0,external_wp_i18n_namespaceObject.__)(&#039;Indent a list by pressing &lt;kbd&gt;space&lt;/kbd&gt; at the beginning of a line.&#039;), {
  kbd: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;kbd&quot;, {})
}), (0,external_wp_element_namespaceObject.createInterpolateElement)((0,external_wp_i18n_namespaceObject.__)(&#039;Outdent a list by pressing &lt;kbd&gt;backspace&lt;/kbd&gt; at the beginning of a line.&#039;), {
  kbd: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;kbd&quot;, {})
}), (0,external_wp_i18n_namespaceObject.__)(&#039;Drag files into the editor to automatically insert media blocks.&#039;), (0,external_wp_i18n_namespaceObject.__)(&quot;Change a block&#039;s type by pressing the block icon on the toolbar.&quot;)];
function Tips() {
  const [randomIndex] = (0,external_wp_element_namespaceObject.useState)(
  // Disable Reason: I&#039;m not generating an HTML id.
  // eslint-disable-next-line no-restricted-syntax
  Math.floor(Math.random() * globalTips.length));
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Tip, {
    children: globalTips[randomIndex]
  });
}
/* harmony default export */ const tips = (Tips);

;// ./node_modules/@wordpress/icons/build-module/library/chevron-right.js
/**
 * WordPress dependencies
 */


const chevronRight = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;M10.6 6L9.4 7l4.6 5-4.6 5 1.2 1 5.4-6z&quot;
  })
});
/* harmony default export */ const chevron_right = (chevronRight);

;// ./node_modules/@wordpress/icons/build-module/library/chevron-left.js
/**
 * WordPress dependencies
 */


const chevronLeft = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;M14.6 7l-1.2-1L8 12l5.4 6 1.2-1-4.6-5z&quot;
  })
});
/* harmony default export */ const chevron_left = (chevronLeft);

;// ./node_modules/@wordpress/icons/build-module/library/block-default.js
/**
 * WordPress dependencies
 */


const blockDefault = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;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&quot;
  })
});
/* harmony default export */ const block_default = (blockDefault);

;// ./node_modules/@wordpress/block-editor/build-module/components/block-icon/index.js
/**
 * External dependencies
 */


/**
 * WordPress dependencies
 */




function BlockIcon({
  icon,
  showColors = false,
  className,
  context
}) {
  if (icon?.src === &#039;block-default&#039;) {
    icon = {
      src: block_default
    };
  }
  const renderedIcon = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Icon, {
    icon: icon &amp;&amp; icon.src ? icon.src : icon,
    context: context
  });
  const style = showColors ? {
    backgroundColor: icon &amp;&amp; icon.background,
    color: icon &amp;&amp; icon.foreground
  } : {};
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;span&quot;, {
    style: style,
    className: dist_clsx(&#039;block-editor-block-icon&#039;, className, {
      &#039;has-colors&#039;: showColors
    }),
    children: renderedIcon
  });
}

/**
 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/block-icon/README.md
 */
/* harmony default export */ const block_icon = ((0,external_wp_element_namespaceObject.memo)(BlockIcon));

;// ./node_modules/@wordpress/block-editor/build-module/components/block-card/index.js
/**
 * External dependencies
 */


/**
 * WordPress dependencies
 */






/**
 * Internal dependencies
 */




const {
  Badge
} = unlock(external_wp_components_namespaceObject.privateApis);

/**
 * A card component that displays block information including title, icon, and description.
 * Can be used to show block metadata and navigation controls for parent blocks.
 *
 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/block-card/README.md
 *
 * @example
 * ```jsx
 * function Example() {
 *   return (
 *     &lt;BlockCard
 *       title=&quot;My Block&quot;
 *       icon=&quot;smiley&quot;
 *       description=&quot;A simple block example&quot;
 *       name=&quot;Custom Block&quot;
 *     /&gt;
 *   );
 * }
 * ```
 *
 * @param {Object}        props             Component props.
 * @param {string}        props.title       The title of the block.
 * @param {string|Object} props.icon        The icon of the block. This can be any of [WordPress&#039; Dashicons](https://developer.wordpress.org/resource/dashicons/), or a custom `svg` element.
 * @param {string}        props.description The description of the block.
 * @param {Object}        [props.blockType] Deprecated: Object containing block type data.
 * @param {string}        [props.className] Additional classes to apply to the card.
 * @param {string}        [props.name]      Custom block name to display before the title.
 * @return {Element}                        Block card component.
 */
function BlockCard({
  title,
  icon,
  description,
  blockType,
  className,
  name
}) {
  if (blockType) {
    external_wp_deprecated_default()(&#039;`blockType` property in `BlockCard component`&#039;, {
      since: &#039;5.7&#039;,
      alternative: &#039;`title, icon and description` properties&#039;
    });
    ({
      title,
      icon,
      description
    } = blockType);
  }
  const {
    parentNavBlockClientId
  } = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      getSelectedBlockClientId,
      getBlockParentsByBlockName
    } = select(store);
    const _selectedBlockClientId = getSelectedBlockClientId();
    return {
      parentNavBlockClientId: getBlockParentsByBlockName(_selectedBlockClientId, &#039;core/navigation&#039;, true)[0]
    };
  }, []);
  const {
    selectBlock
  } = (0,external_wp_data_namespaceObject.useDispatch)(store);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;div&quot;, {
    className: dist_clsx(&#039;block-editor-block-card&#039;, className),
    children: [parentNavBlockClientId &amp;&amp;
    /*#__PURE__*/
    // This is only used by the Navigation block for now. It&#039;s not ideal having Navigation block specific code here.
    (0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
      onClick: () =&gt; selectBlock(parentNavBlockClientId),
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Go to parent Navigation block&#039;),
      style:
      // TODO: This style override is also used in ToolsPanelHeader.
      // It should be supported out-of-the-box by Button.
      {
        minWidth: 24,
        padding: 0
      },
      icon: (0,external_wp_i18n_namespaceObject.isRTL)() ? chevron_right : chevron_left,
      size: &quot;small&quot;
    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_icon, {
      icon: icon,
      showColors: true
    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalVStack, {
      spacing: 1,
      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;h2&quot;, {
        className: &quot;block-editor-block-card__title&quot;,
        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;span&quot;, {
          className: &quot;block-editor-block-card__name&quot;,
          children: !!name?.length ? name : title
        }), !!name?.length &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Badge, {
          children: title
        })]
      }), description &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalText, {
        className: &quot;block-editor-block-card__description&quot;,
        children: description
      })]
    })]
  });
}
/* harmony default export */ const block_card = (BlockCard);

;// ./node_modules/@wordpress/upload-media/build-module/store/types.js
let Type = /*#__PURE__*/function (Type) {
  Type[&quot;Unknown&quot;] = &quot;REDUX_UNKNOWN&quot;;
  Type[&quot;Add&quot;] = &quot;ADD_ITEM&quot;;
  Type[&quot;Prepare&quot;] = &quot;PREPARE_ITEM&quot;;
  Type[&quot;Cancel&quot;] = &quot;CANCEL_ITEM&quot;;
  Type[&quot;Remove&quot;] = &quot;REMOVE_ITEM&quot;;
  Type[&quot;PauseItem&quot;] = &quot;PAUSE_ITEM&quot;;
  Type[&quot;ResumeItem&quot;] = &quot;RESUME_ITEM&quot;;
  Type[&quot;PauseQueue&quot;] = &quot;PAUSE_QUEUE&quot;;
  Type[&quot;ResumeQueue&quot;] = &quot;RESUME_QUEUE&quot;;
  Type[&quot;OperationStart&quot;] = &quot;OPERATION_START&quot;;
  Type[&quot;OperationFinish&quot;] = &quot;OPERATION_FINISH&quot;;
  Type[&quot;AddOperations&quot;] = &quot;ADD_OPERATIONS&quot;;
  Type[&quot;CacheBlobUrl&quot;] = &quot;CACHE_BLOB_URL&quot;;
  Type[&quot;RevokeBlobUrls&quot;] = &quot;REVOKE_BLOB_URLS&quot;;
  Type[&quot;UpdateSettings&quot;] = &quot;UPDATE_SETTINGS&quot;;
  return Type;
}({});

// Must match the Attachment type from the media-utils package.

let ItemStatus = /*#__PURE__*/function (ItemStatus) {
  ItemStatus[&quot;Processing&quot;] = &quot;PROCESSING&quot;;
  ItemStatus[&quot;Paused&quot;] = &quot;PAUSED&quot;;
  return ItemStatus;
}({});
let OperationType = /*#__PURE__*/function (OperationType) {
  OperationType[&quot;Prepare&quot;] = &quot;PREPARE&quot;;
  OperationType[&quot;Upload&quot;] = &quot;UPLOAD&quot;;
  return OperationType;
}({});

;// ./node_modules/@wordpress/upload-media/build-module/store/reducer.js
/**
 * Internal dependencies
 */

const reducer_noop = () =&gt; {};
const DEFAULT_STATE = {
  queue: [],
  queueStatus: &#039;active&#039;,
  blobUrls: {},
  settings: {
    mediaUpload: reducer_noop
  }
};
function reducer_reducer(state = DEFAULT_STATE, action = {
  type: Type.Unknown
}) {
  switch (action.type) {
    case Type.PauseQueue:
      {
        return {
          ...state,
          queueStatus: &#039;paused&#039;
        };
      }
    case Type.ResumeQueue:
      {
        return {
          ...state,
          queueStatus: &#039;active&#039;
        };
      }
    case Type.Add:
      return {
        ...state,
        queue: [...state.queue, action.item]
      };
    case Type.Cancel:
      return {
        ...state,
        queue: state.queue.map(item =&gt; item.id === action.id ? {
          ...item,
          error: action.error
        } : item)
      };
    case Type.Remove:
      return {
        ...state,
        queue: state.queue.filter(item =&gt; item.id !== action.id)
      };
    case Type.OperationStart:
      {
        return {
          ...state,
          queue: state.queue.map(item =&gt; item.id === action.id ? {
            ...item,
            currentOperation: action.operation
          } : item)
        };
      }
    case Type.AddOperations:
      return {
        ...state,
        queue: state.queue.map(item =&gt; {
          if (item.id !== action.id) {
            return item;
          }
          return {
            ...item,
            operations: [...(item.operations || []), ...action.operations]
          };
        })
      };
    case Type.OperationFinish:
      return {
        ...state,
        queue: state.queue.map(item =&gt; {
          if (item.id !== action.id) {
            return item;
          }
          const operations = item.operations ? item.operations.slice(1) : [];

          // Prevent an empty object if there&#039;s no attachment data.
          const attachment = item.attachment || action.item.attachment ? {
            ...item.attachment,
            ...action.item.attachment
          } : undefined;
          return {
            ...item,
            currentOperation: undefined,
            operations,
            ...action.item,
            attachment,
            additionalData: {
              ...item.additionalData,
              ...action.item.additionalData
            }
          };
        })
      };
    case Type.CacheBlobUrl:
      {
        const blobUrls = state.blobUrls[action.id] || [];
        return {
          ...state,
          blobUrls: {
            ...state.blobUrls,
            [action.id]: [...blobUrls, action.blobUrl]
          }
        };
      }
    case Type.RevokeBlobUrls:
      {
        const newBlobUrls = {
          ...state.blobUrls
        };
        delete newBlobUrls[action.id];
        return {
          ...state,
          blobUrls: newBlobUrls
        };
      }
    case Type.UpdateSettings:
      {
        return {
          ...state,
          settings: {
            ...state.settings,
            ...action.settings
          }
        };
      }
  }
  return state;
}
/* harmony default export */ const store_reducer = (reducer_reducer);

;// ./node_modules/@wordpress/upload-media/build-module/store/selectors.js
/**
 * Internal dependencies
 */

/**
 * Returns all items currently being uploaded.
 *
 * @param state Upload state.
 *
 * @return Queue items.
 */
function getItems(state) {
  return state.queue;
}

/**
 * Determines whether any upload is currently in progress.
 *
 * @param state Upload state.
 *
 * @return Whether any upload is currently in progress.
 */
function isUploading(state) {
  return state.queue.length &gt;= 1;
}

/**
 * Determines whether an upload is currently in progress given an attachment URL.
 *
 * @param state Upload state.
 * @param url   Attachment URL.
 *
 * @return Whether upload is currently in progress for the given attachment.
 */
function isUploadingByUrl(state, url) {
  return state.queue.some(item =&gt; item.attachment?.url === url || item.sourceUrl === url);
}

/**
 * Determines whether an upload is currently in progress given an attachment ID.
 *
 * @param state        Upload state.
 * @param attachmentId Attachment ID.
 *
 * @return Whether upload is currently in progress for the given attachment.
 */
function isUploadingById(state, attachmentId) {
  return state.queue.some(item =&gt; item.attachment?.id === attachmentId || item.sourceAttachmentId === attachmentId);
}

/**
 * Returns the media upload settings.
 *
 * @param state Upload state.
 *
 * @return Settings
 */
function selectors_getSettings(state) {
  return state.settings;
}

;// ./node_modules/@wordpress/upload-media/build-module/store/private-selectors.js
/**
 * Internal dependencies
 */


/**
 * Returns all items currently being uploaded.
 *
 * @param state Upload state.
 *
 * @return Queue items.
 */
function getAllItems(state) {
  return state.queue;
}

/**
 * Returns a specific item given its unique ID.
 *
 * @param state Upload state.
 * @param id    Item ID.
 *
 * @return Queue item.
 */
function getItem(state, id) {
  return state.queue.find(item =&gt; item.id === id);
}

/**
 * Determines whether a batch has been successfully uploaded, given its unique ID.
 *
 * @param state   Upload state.
 * @param batchId Batch ID.
 *
 * @return Whether a batch has been uploaded.
 */
function isBatchUploaded(state, batchId) {
  const batchItems = state.queue.filter(item =&gt; batchId === item.batchId);
  return batchItems.length === 0;
}

/**
 * Determines whether an upload is currently in progress given a post or attachment ID.
 *
 * @param state              Upload state.
 * @param postOrAttachmentId Post ID or attachment ID.
 *
 * @return Whether upload is currently in progress for the given post or attachment.
 */
function isUploadingToPost(state, postOrAttachmentId) {
  return state.queue.some(item =&gt; item.currentOperation === OperationType.Upload &amp;&amp; item.additionalData.post === postOrAttachmentId);
}

/**
 * Returns the next paused upload for a given post or attachment ID.
 *
 * @param state              Upload state.
 * @param postOrAttachmentId Post ID or attachment ID.
 *
 * @return Paused item.
 */
function getPausedUploadForPost(state, postOrAttachmentId) {
  return state.queue.find(item =&gt; item.status === ItemStatus.Paused &amp;&amp; item.additionalData.post === postOrAttachmentId);
}

/**
 * Determines whether uploading is currently paused.
 *
 * @param state Upload state.
 *
 * @return Whether uploading is currently paused.
 */
function isPaused(state) {
  return state.queueStatus === &#039;paused&#039;;
}

/**
 * Returns all cached blob URLs for a given item ID.
 *
 * @param state Upload state.
 * @param id    Item ID
 *
 * @return List of blob URLs.
 */
function getBlobUrls(state, id) {
  return state.blobUrls[id] || [];
}

;// ./node_modules/@wordpress/upload-media/node_modules/uuid/dist/esm-browser/native.js
const randomUUID = typeof crypto !== &#039;undefined&#039; &amp;&amp; crypto.randomUUID &amp;&amp; crypto.randomUUID.bind(crypto);
/* harmony default export */ const esm_browser_native = ({
  randomUUID
});
;// ./node_modules/@wordpress/upload-media/node_modules/uuid/dist/esm-browser/rng.js
// Unique ID creation requires a high quality random # generator. In the browser we therefore
// require the crypto API and do not support built-in fallback to lower quality random number
// generators (like Math.random()).
let getRandomValues;
const rnds8 = new Uint8Array(16);
function rng() {
  // lazy load so that environments that need to polyfill have a chance to do so
  if (!getRandomValues) {
    // getRandomValues needs to be invoked in a context where &quot;this&quot; is a Crypto implementation.
    getRandomValues = typeof crypto !== &#039;undefined&#039; &amp;&amp; crypto.getRandomValues &amp;&amp; crypto.getRandomValues.bind(crypto);

    if (!getRandomValues) {
      throw new Error(&#039;crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported&#039;);
    }
  }

  return getRandomValues(rnds8);
}
;// ./node_modules/@wordpress/upload-media/node_modules/uuid/dist/esm-browser/stringify.js

/**
 * Convert array of 16 byte values to UUID string format of the form:
 * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
 */

const byteToHex = [];

for (let i = 0; i &lt; 256; ++i) {
  byteToHex.push((i + 0x100).toString(16).slice(1));
}

function unsafeStringify(arr, offset = 0) {
  // Note: Be careful editing this code!  It&#039;s been tuned for performance
  // and works in ways you may not expect. See https://github.com/uuidjs/uuid/pull/434
  return byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + &#039;-&#039; + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + &#039;-&#039; + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + &#039;-&#039; + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + &#039;-&#039; + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]];
}

function stringify(arr, offset = 0) {
  const uuid = unsafeStringify(arr, offset); // Consistency check for valid UUID.  If this throws, it&#039;s likely due to one
  // of the following:
  // - One or more input array values don&#039;t map to a hex octet (leading to
  // &quot;undefined&quot; in the uuid)
  // - Invalid input values for the RFC `version` or `variant` fields

  if (!validate(uuid)) {
    throw TypeError(&#039;Stringified UUID is invalid&#039;);
  }

  return uuid;
}

/* harmony default export */ const esm_browser_stringify = ((/* unused pure expression or super */ null &amp;&amp; (stringify)));
;// ./node_modules/@wordpress/upload-media/node_modules/uuid/dist/esm-browser/v4.js




function v4(options, buf, offset) {
  if (esm_browser_native.randomUUID &amp;&amp; !buf &amp;&amp; !options) {
    return esm_browser_native.randomUUID();
  }

  options = options || {};
  const rnds = options.random || (options.rng || rng)(); // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`

  rnds[6] = rnds[6] &amp; 0x0f | 0x40;
  rnds[8] = rnds[8] &amp; 0x3f | 0x80; // Copy bytes to buffer, if provided

  if (buf) {
    offset = offset || 0;

    for (let i = 0; i &lt; 16; ++i) {
      buf[offset + i] = rnds[i];
    }

    return buf;
  }

  return unsafeStringify(rnds);
}

/* harmony default export */ const esm_browser_v4 = (v4);
;// ./node_modules/@wordpress/upload-media/build-module/upload-error.js
/**
 * MediaError class.
 *
 * Small wrapper around the `Error` class
 * to hold an error code and a reference to a file object.
 */
class UploadError extends Error {
  constructor({
    code,
    message,
    file,
    cause
  }) {
    super(message, {
      cause
    });
    Object.setPrototypeOf(this, new.target.prototype);
    this.code = code;
    this.file = file;
  }
}

;// ./node_modules/@wordpress/upload-media/build-module/validate-mime-type.js
/**
 * WordPress dependencies
 */


/**
 * Internal dependencies
 */


/**
 * Verifies if the caller (e.g. a block) supports this mime type.
 *
 * @param file         File object.
 * @param allowedTypes List of allowed mime types.
 */
function validateMimeType(file, allowedTypes) {
  if (!allowedTypes) {
    return;
  }

  // Allowed type specified by consumer.
  const isAllowedType = allowedTypes.some(allowedType =&gt; {
    // If a complete mimetype is specified verify if it matches exactly the mime type of the file.
    if (allowedType.includes(&#039;/&#039;)) {
      return allowedType === file.type;
    }
    // Otherwise a general mime type is used, and we should verify if the file mimetype starts with it.
    return file.type.startsWith(`${allowedType}/`);
  });
  if (file.type &amp;&amp; !isAllowedType) {
    throw new UploadError({
      code: &#039;MIME_TYPE_NOT_SUPPORTED&#039;,
      message: (0,external_wp_i18n_namespaceObject.sprintf)(
      // translators: %s: file name.
      (0,external_wp_i18n_namespaceObject.__)(&#039;%s: Sorry, this file type is not supported here.&#039;), file.name),
      file
    });
  }
}

;// ./node_modules/@wordpress/upload-media/build-module/get-mime-types-array.js
/**
 * Browsers may use unexpected mime types, and they differ from browser to browser.
 * This function computes a flexible array of mime types from the mime type structured provided by the server.
 * Converts { jpg|jpeg|jpe: &quot;image/jpeg&quot; } into [ &quot;image/jpeg&quot;, &quot;image/jpg&quot;, &quot;image/jpeg&quot;, &quot;image/jpe&quot; ]
 *
 * @param {?Object} wpMimeTypesObject Mime type object received from the server.
 *                                    Extensions are keys separated by &#039;|&#039; and values are mime types associated with an extension.
 *
 * @return An array of mime types or null
 */
function getMimeTypesArray(wpMimeTypesObject) {
  if (!wpMimeTypesObject) {
    return null;
  }
  return Object.entries(wpMimeTypesObject).flatMap(([extensionsString, mime]) =&gt; {
    const [type] = mime.split(&#039;/&#039;);
    const extensions = extensionsString.split(&#039;|&#039;);
    return [mime, ...extensions.map(extension =&gt; `${type}/${extension}`)];
  });
}

;// ./node_modules/@wordpress/upload-media/build-module/validate-mime-type-for-user.js
/**
 * WordPress dependencies
 */


/**
 * Internal dependencies
 */



/**
 * Verifies if the user is allowed to upload this mime type.
 *
 * @param file               File object.
 * @param wpAllowedMimeTypes List of allowed mime types and file extensions.
 */
function validateMimeTypeForUser(file, wpAllowedMimeTypes) {
  // Allowed types for the current WP_User.
  const allowedMimeTypesForUser = getMimeTypesArray(wpAllowedMimeTypes);
  if (!allowedMimeTypesForUser) {
    return;
  }
  const isAllowedMimeTypeForUser = allowedMimeTypesForUser.includes(file.type);
  if (file.type &amp;&amp; !isAllowedMimeTypeForUser) {
    throw new UploadError({
      code: &#039;MIME_TYPE_NOT_ALLOWED_FOR_USER&#039;,
      message: (0,external_wp_i18n_namespaceObject.sprintf)(
      // translators: %s: file name.
      (0,external_wp_i18n_namespaceObject.__)(&#039;%s: Sorry, you are not allowed to upload this file type.&#039;), file.name),
      file
    });
  }
}

;// ./node_modules/@wordpress/upload-media/build-module/validate-file-size.js
/**
 * WordPress dependencies
 */


/**
 * Internal dependencies
 */


/**
 * Verifies whether the file is within the file upload size limits for the site.
 *
 * @param file              File object.
 * @param maxUploadFileSize Maximum upload size in bytes allowed for the site.
 */
function validateFileSize(file, maxUploadFileSize) {
  // Don&#039;t allow empty files to be uploaded.
  if (file.size &lt;= 0) {
    throw new UploadError({
      code: &#039;EMPTY_FILE&#039;,
      message: (0,external_wp_i18n_namespaceObject.sprintf)(
      // translators: %s: file name.
      (0,external_wp_i18n_namespaceObject.__)(&#039;%s: This file is empty.&#039;), file.name),
      file
    });
  }
  if (maxUploadFileSize &amp;&amp; file.size &gt; maxUploadFileSize) {
    throw new UploadError({
      code: &#039;SIZE_ABOVE_LIMIT&#039;,
      message: (0,external_wp_i18n_namespaceObject.sprintf)(
      // translators: %s: file name.
      (0,external_wp_i18n_namespaceObject.__)(&#039;%s: This file exceeds the maximum upload size for this site.&#039;), file.name),
      file
    });
  }
}

;// ./node_modules/@wordpress/upload-media/build-module/store/actions.js
/**
 * External dependencies
 */


/**
 * WordPress dependencies
 */

/**
 * Internal dependencies
 */





/**
 * Adds a new item to the upload queue.
 *
 * @param $0
 * @param $0.files            Files
 * @param [$0.onChange]       Function called each time a file or a temporary representation of the file is available.
 * @param [$0.onSuccess]      Function called after the file is uploaded.
 * @param [$0.onBatchSuccess] Function called after a batch of files is uploaded.
 * @param [$0.onError]        Function called when an error happens.
 * @param [$0.additionalData] Additional data to include in the request.
 * @param [$0.allowedTypes]   Array with the types of media that can be uploaded, if unset all types are allowed.
 */
function addItems({
  files,
  onChange,
  onSuccess,
  onError,
  onBatchSuccess,
  additionalData,
  allowedTypes
}) {
  return async ({
    select,
    dispatch
  }) =&gt; {
    const batchId = esm_browser_v4();
    for (const file of files) {
      /*
       Check if the caller (e.g. a block) supports this mime type.
       Special case for file types such as HEIC which will be converted before upload anyway.
       Another check will be done before upload.
      */
      try {
        validateMimeType(file, allowedTypes);
        validateMimeTypeForUser(file, select.getSettings().allowedMimeTypes);
      } catch (error) {
        onError?.(error);
        continue;
      }
      try {
        validateFileSize(file, select.getSettings().maxUploadFileSize);
      } catch (error) {
        onError?.(error);
        continue;
      }
      dispatch.addItem({
        file,
        batchId,
        onChange,
        onSuccess,
        onBatchSuccess,
        onError,
        additionalData
      });
    }
  };
}

/**
 * Cancels an item in the queue based on an error.
 *
 * @param id     Item ID.
 * @param error  Error instance.
 * @param silent Whether to cancel the item silently,
 *               without invoking its `onError` callback.
 */
function cancelItem(id, error, silent = false) {
  return async ({
    select,
    dispatch
  }) =&gt; {
    const item = select.getItem(id);
    if (!item) {
      /*
       * Do nothing if item has already been removed.
       * This can happen if an upload is cancelled manually
       * while transcoding with vips is still in progress.
       * Then, cancelItem() is once invoked manually and once
       * by the error handler in optimizeImageItem().
       */
      return;
    }
    item.abortController?.abort();
    if (!silent) {
      const {
        onError
      } = item;
      onError?.(error !== null &amp;&amp; error !== void 0 ? error : new Error(&#039;Upload cancelled&#039;));
      if (!onError &amp;&amp; error) {
        // TODO: Find better way to surface errors with sideloads etc.
        // eslint-disable-next-line no-console -- Deliberately log errors here.
        console.error(&#039;Upload cancelled&#039;, error);
      }
    }
    dispatch({
      type: Type.Cancel,
      id,
      error
    });
    dispatch.removeItem(id);
    dispatch.revokeBlobUrls(id);

    // All items of this batch were cancelled or finished.
    if (item.batchId &amp;&amp; select.isBatchUploaded(item.batchId)) {
      item.onBatchSuccess?.();
    }
  };
}

;// ./node_modules/@wordpress/upload-media/build-module/utils.js
/**
 * WordPress dependencies
 */



/**
 * Converts a Blob to a File with a default name like &quot;image.png&quot;.
 *
 * If it is already a File object, it is returned unchanged.
 *
 * @param fileOrBlob Blob object.
 * @return File object.
 */
function convertBlobToFile(fileOrBlob) {
  if (fileOrBlob instanceof File) {
    return fileOrBlob;
  }

  // Extension is only an approximation.
  // The server will override it if incorrect.
  const ext = fileOrBlob.type.split(&#039;/&#039;)[1];
  const mediaType = &#039;application/pdf&#039; === fileOrBlob.type ? &#039;document&#039; : fileOrBlob.type.split(&#039;/&#039;)[0];
  return new File([fileOrBlob], `${mediaType}.${ext}`, {
    type: fileOrBlob.type
  });
}

/**
 * Renames a given file and returns a new file.
 *
 * Copies over the last modified time.
 *
 * @param file File object.
 * @param name File name.
 * @return Renamed file object.
 */
function renameFile(file, name) {
  return new File([file], name, {
    type: file.type,
    lastModified: file.lastModified
  });
}

/**
 * Clones a given file object.
 *
 * @param file File object.
 * @return New file object.
 */
function cloneFile(file) {
  return renameFile(file, file.name);
}

/**
 * Returns the file extension from a given file name or URL.
 *
 * @param file File URL.
 * @return File extension or null if it does not have one.
 */
function getFileExtension(file) {
  return file.includes(&#039;.&#039;) ? file.split(&#039;.&#039;).pop() || null : null;
}

/**
 * Returns file basename without extension.
 *
 * For example, turns &quot;my-awesome-file.jpeg&quot; into &quot;my-awesome-file&quot;.
 *
 * @param name File name.
 * @return File basename.
 */
function getFileBasename(name) {
  return name.includes(&#039;.&#039;) ? name.split(&#039;.&#039;).slice(0, -1).join(&#039;.&#039;) : name;
}

/**
 * Returns the file name including extension from a URL.
 *
 * @param url File URL.
 * @return File name.
 */
function getFileNameFromUrl(url) {
  return getFilename(url) || _x(&#039;unnamed&#039;, &#039;file name&#039;);
}

;// ./node_modules/@wordpress/upload-media/build-module/stub-file.js
class StubFile extends File {
  constructor(fileName = &#039;stub-file&#039;) {
    super([], fileName);
  }
}

;// ./node_modules/@wordpress/upload-media/build-module/store/private-actions.js
/**
 * External dependencies
 */


/**
 * WordPress dependencies
 */

/**
 * Internal dependencies
 */



/**
 * Adds a new item to the upload queue.
 *
 * @param $0
 * @param $0.file                 File
 * @param [$0.batchId]            Batch ID.
 * @param [$0.onChange]           Function called each time a file or a temporary representation of the file is available.
 * @param [$0.onSuccess]          Function called after the file is uploaded.
 * @param [$0.onBatchSuccess]     Function called after a batch of files is uploaded.
 * @param [$0.onError]            Function called when an error happens.
 * @param [$0.additionalData]     Additional data to include in the request.
 * @param [$0.sourceUrl]          Source URL. Used when importing a file from a URL or optimizing an existing file.
 * @param [$0.sourceAttachmentId] Source attachment ID. Used when optimizing an existing file for example.
 * @param [$0.abortController]    Abort controller for upload cancellation.
 * @param [$0.operations]         List of operations to perform. Defaults to automatically determined list, based on the file.
 */
function addItem({
  file: fileOrBlob,
  batchId,
  onChange,
  onSuccess,
  onBatchSuccess,
  onError,
  additionalData = {},
  sourceUrl,
  sourceAttachmentId,
  abortController,
  operations
}) {
  return async ({
    dispatch
  }) =&gt; {
    const itemId = esm_browser_v4();

    // Hardening in case a Blob is passed instead of a File.
    // See https://github.com/WordPress/gutenberg/pull/65693 for an example.
    const file = convertBlobToFile(fileOrBlob);
    let blobUrl;

    // StubFile could be coming from addItemFromUrl().
    if (!(file instanceof StubFile)) {
      blobUrl = (0,external_wp_blob_namespaceObject.createBlobURL)(file);
      dispatch({
        type: Type.CacheBlobUrl,
        id: itemId,
        blobUrl
      });
    }
    dispatch({
      type: Type.Add,
      item: {
        id: itemId,
        batchId,
        status: ItemStatus.Processing,
        sourceFile: cloneFile(file),
        file,
        attachment: {
          url: blobUrl
        },
        additionalData: {
          convert_format: false,
          ...additionalData
        },
        onChange,
        onSuccess,
        onBatchSuccess,
        onError,
        sourceUrl,
        sourceAttachmentId,
        abortController: abortController || new AbortController(),
        operations: Array.isArray(operations) ? operations : [OperationType.Prepare]
      }
    });
    dispatch.processItem(itemId);
  };
}

/**
 * Processes a single item in the queue.
 *
 * Runs the next operation in line and invokes any callbacks.
 *
 * @param id Item ID.
 */
function processItem(id) {
  return async ({
    select,
    dispatch
  }) =&gt; {
    if (select.isPaused()) {
      return;
    }
    const item = select.getItem(id);
    const {
      attachment,
      onChange,
      onSuccess,
      onBatchSuccess,
      batchId
    } = item;
    const operation = Array.isArray(item.operations?.[0]) ? item.operations[0][0] : item.operations?.[0];
    if (attachment) {
      onChange?.([attachment]);
    }

    /*
     If there are no more operations, the item can be removed from the queue,
     but only if there are no thumbnails still being side-loaded,
     or if itself is a side-loaded item.
    */

    if (!operation) {
      if (attachment) {
        onSuccess?.([attachment]);
      }

      // dispatch.removeItem( id );
      dispatch.revokeBlobUrls(id);
      if (batchId &amp;&amp; select.isBatchUploaded(batchId)) {
        onBatchSuccess?.();
      }

      /*
       At this point we are dealing with a parent whose children haven&#039;t fully uploaded yet.
       Do nothing and let the removal happen once the last side-loaded item finishes.
       */

      return;
    }
    if (!operation) {
      // This shouldn&#039;t really happen.
      return;
    }
    dispatch({
      type: Type.OperationStart,
      id,
      operation
    });
    switch (operation) {
      case OperationType.Prepare:
        dispatch.prepareItem(item.id);
        break;
      case OperationType.Upload:
        dispatch.uploadItem(id);
        break;
    }
  };
}

/**
 * Returns an action object that pauses all processing in the queue.
 *
 * Useful for testing purposes.
 *
 * @return Action object.
 */
function pauseQueue() {
  return {
    type: Type.PauseQueue
  };
}

/**
 * Resumes all processing in the queue.
 *
 * Dispatches an action object for resuming the queue itself,
 * and triggers processing for each remaining item in the queue individually.
 */
function resumeQueue() {
  return async ({
    select,
    dispatch
  }) =&gt; {
    dispatch({
      type: Type.ResumeQueue
    });
    for (const item of select.getAllItems()) {
      dispatch.processItem(item.id);
    }
  };
}

/**
 * Removes a specific item from the queue.
 *
 * @param id Item ID.
 */
function removeItem(id) {
  return async ({
    select,
    dispatch
  }) =&gt; {
    const item = select.getItem(id);
    if (!item) {
      return;
    }
    dispatch({
      type: Type.Remove,
      id
    });
  };
}

/**
 * Finishes an operation for a given item ID and immediately triggers processing the next one.
 *
 * @param id      Item ID.
 * @param updates Updated item data.
 */
function finishOperation(id, updates) {
  return async ({
    dispatch
  }) =&gt; {
    dispatch({
      type: Type.OperationFinish,
      id,
      item: updates
    });
    dispatch.processItem(id);
  };
}

/**
 * Prepares an item for initial processing.
 *
 * Determines the list of operations to perform for a given image,
 * depending on its media type.
 *
 * For example, HEIF images first need to be converted, resized,
 * compressed, and then uploaded.
 *
 * Or videos need to be compressed, and then need poster generation
 * before upload.
 *
 * @param id Item ID.
 */
function prepareItem(id) {
  return async ({
    dispatch
  }) =&gt; {
    const operations = [OperationType.Upload];
    dispatch({
      type: Type.AddOperations,
      id,
      operations
    });
    dispatch.finishOperation(id, {});
  };
}

/**
 * Uploads an item to the server.
 *
 * @param id Item ID.
 */
function uploadItem(id) {
  return async ({
    select,
    dispatch
  }) =&gt; {
    const item = select.getItem(id);
    select.getSettings().mediaUpload({
      filesList: [item.file],
      additionalData: item.additionalData,
      signal: item.abortController?.signal,
      onFileChange: ([attachment]) =&gt; {
        if (!(0,external_wp_blob_namespaceObject.isBlobURL)(attachment.url)) {
          dispatch.finishOperation(id, {
            attachment
          });
        }
      },
      onSuccess: ([attachment]) =&gt; {
        dispatch.finishOperation(id, {
          attachment
        });
      },
      onError: error =&gt; {
        dispatch.cancelItem(id, error);
      }
    });
  };
}

/**
 * Revokes all blob URLs for a given item, freeing up memory.
 *
 * @param id Item ID.
 */
function revokeBlobUrls(id) {
  return async ({
    select,
    dispatch
  }) =&gt; {
    const blobUrls = select.getBlobUrls(id);
    for (const blobUrl of blobUrls) {
      (0,external_wp_blob_namespaceObject.revokeBlobURL)(blobUrl);
    }
    dispatch({
      type: Type.RevokeBlobUrls,
      id
    });
  };
}

/**
 * Returns an action object that pauses all processing in the queue.
 *
 * Useful for testing purposes.
 *
 * @param settings
 * @return Action object.
 */
function private_actions_updateSettings(settings) {
  return {
    type: Type.UpdateSettings,
    settings
  };
}

;// ./node_modules/@wordpress/upload-media/build-module/lock-unlock.js
/**
 * WordPress dependencies
 */

const {
  lock: lock_unlock_lock,
  unlock: lock_unlock_unlock
} = (0,external_wp_privateApis_namespaceObject.__dangerousOptInToUnstableAPIsOnlyForCoreModules)(&#039;I acknowledge private features are not for use in themes or plugins and doing so will break in the next version of WordPress.&#039;, &#039;@wordpress/upload-media&#039;);

;// ./node_modules/@wordpress/upload-media/build-module/store/constants.js
const constants_STORE_NAME = &#039;core/upload-media&#039;;

;// ./node_modules/@wordpress/upload-media/build-module/store/index.js
/**
 * WordPress dependencies
 */


/**
 * Internal dependencies
 */








/**
 * Media upload data store configuration.
 *
 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/data/README.md#registerStore
 */
const store_storeConfig = {
  reducer: store_reducer,
  selectors: store_selectors_namespaceObject,
  actions: store_actions_namespaceObject
};

/**
 * Store definition for the media upload namespace.
 *
 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/data/README.md#createReduxStore
 */
const store_store = (0,external_wp_data_namespaceObject.createReduxStore)(constants_STORE_NAME, {
  reducer: store_reducer,
  selectors: store_selectors_namespaceObject,
  actions: store_actions_namespaceObject
});
(0,external_wp_data_namespaceObject.register)(store_store);
// @ts-ignore
lock_unlock_unlock(store_store).registerPrivateActions(store_private_actions_namespaceObject);
// @ts-ignore
lock_unlock_unlock(store_store).registerPrivateSelectors(store_private_selectors_namespaceObject);

;// ./node_modules/@wordpress/upload-media/build-module/components/provider/with-registry-provider.js
/**
 * WordPress dependencies
 */




/**
 * Internal dependencies
 */



function getSubRegistry(subRegistries, registry, useSubRegistry) {
  if (!useSubRegistry) {
    return registry;
  }
  let subRegistry = subRegistries.get(registry);
  if (!subRegistry) {
    subRegistry = (0,external_wp_data_namespaceObject.createRegistry)({}, registry);
    subRegistry.registerStore(constants_STORE_NAME, store_storeConfig);
    subRegistries.set(registry, subRegistry);
  }
  return subRegistry;
}
const withRegistryProvider = (0,external_wp_compose_namespaceObject.createHigherOrderComponent)(WrappedComponent =&gt; ({
  useSubRegistry = true,
  ...props
}) =&gt; {
  const registry = (0,external_wp_data_namespaceObject.useRegistry)();
  const [subRegistries] = (0,external_wp_element_namespaceObject.useState)(() =&gt; new WeakMap());
  const subRegistry = getSubRegistry(subRegistries, registry, useSubRegistry);
  if (subRegistry === registry) {
    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(WrappedComponent, {
      registry: registry,
      ...props
    });
  }
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_data_namespaceObject.RegistryProvider, {
    value: subRegistry,
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(WrappedComponent, {
      registry: subRegistry,
      ...props
    })
  });
}, &#039;withRegistryProvider&#039;);
/* harmony default export */ const with_registry_provider = (withRegistryProvider);

;// ./node_modules/@wordpress/upload-media/build-module/components/provider/index.js
/**
 * WordPress dependencies
 */



/**
 * Internal dependencies
 */




const MediaUploadProvider = with_registry_provider(props =&gt; {
  const {
    children,
    settings
  } = props;
  const {
    updateSettings
  } = lock_unlock_unlock((0,external_wp_data_namespaceObject.useDispatch)(store_store));
  (0,external_wp_element_namespaceObject.useEffect)(() =&gt; {
    updateSettings(settings);
  }, [settings, updateSettings]);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_ReactJSXRuntime_namespaceObject.Fragment, {
    children: children
  });
});
/* harmony default export */ const provider = (MediaUploadProvider);

;// ./node_modules/@wordpress/block-editor/build-module/components/provider/with-registry-provider.js
/**
 * WordPress dependencies
 */




/**
 * Internal dependencies
 */



function with_registry_provider_getSubRegistry(subRegistries, registry, useSubRegistry) {
  if (!useSubRegistry) {
    return registry;
  }
  let subRegistry = subRegistries.get(registry);
  if (!subRegistry) {
    subRegistry = (0,external_wp_data_namespaceObject.createRegistry)({}, registry);
    subRegistry.registerStore(STORE_NAME, storeConfig);
    subRegistries.set(registry, subRegistry);
  }
  return subRegistry;
}
const with_registry_provider_withRegistryProvider = (0,external_wp_compose_namespaceObject.createHigherOrderComponent)(WrappedComponent =&gt; ({
  useSubRegistry = true,
  ...props
}) =&gt; {
  const registry = (0,external_wp_data_namespaceObject.useRegistry)();
  const [subRegistries] = (0,external_wp_element_namespaceObject.useState)(() =&gt; new WeakMap());
  const subRegistry = with_registry_provider_getSubRegistry(subRegistries, registry, useSubRegistry);
  if (subRegistry === registry) {
    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(WrappedComponent, {
      registry: registry,
      ...props
    });
  }
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_data_namespaceObject.RegistryProvider, {
    value: subRegistry,
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(WrappedComponent, {
      registry: subRegistry,
      ...props
    })
  });
}, &#039;withRegistryProvider&#039;);
/* harmony default export */ const provider_with_registry_provider = (with_registry_provider_withRegistryProvider);

;// ./node_modules/@wordpress/block-editor/build-module/components/provider/use-block-sync.js
/**
 * WordPress dependencies
 */




/**
 * Internal dependencies
 */

const use_block_sync_noop = () =&gt; {};

/**
 * A function to call when the block value has been updated in the block-editor
 * store.
 *
 * @callback onBlockUpdate
 * @param {Object[]} blocks  The updated blocks.
 * @param {Object}   options The updated block options, such as selectionStart
 *                           and selectionEnd.
 */

/**
 * useBlockSync is a side effect which handles bidirectional sync between the
 * block-editor store and a controlling data source which provides blocks. This
 * is most commonly used by the BlockEditorProvider to synchronize the contents
 * of the block-editor store with the root entity, like a post.
 *
 * Another example would be the template part block, which provides blocks from
 * a separate entity data source than a root entity. This hook syncs edits to
 * the template part in the block editor back to the entity and vice-versa.
 *
 * Here are some of its basic functions:
 * - Initializes the block-editor store for the given clientID to the blocks
 *   given via props.
 * - Adds incoming changes (like undo) to the block-editor store.
 * - Adds outgoing changes (like editing content) to the controlling entity,
 *   determining if a change should be considered persistent or not.
 * - Handles edge cases and race conditions which occur in those operations.
 * - Ignores changes which happen to other entities (like nested inner block
 *   controllers.
 * - Passes selection state from the block-editor store to the controlling entity.
 *
 * @param {Object}        props           Props for the block sync hook
 * @param {string}        props.clientId  The client ID of the inner block controller.
 *                                        If none is passed, then it is assumed to be a
 *                                        root controller rather than an inner block
 *                                        controller.
 * @param {Object[]}      props.value     The control value for the blocks. This value
 *                                        is used to initialize the block-editor store
 *                                        and for resetting the blocks to incoming
 *                                        changes like undo.
 * @param {Object}        props.selection The selection state responsible to restore the selection on undo/redo.
 * @param {onBlockUpdate} props.onChange  Function to call when a persistent
 *                                        change has been made in the block-editor blocks
 *                                        for the given clientId. For example, after
 *                                        this function is called, an entity is marked
 *                                        dirty because it has changes to save.
 * @param {onBlockUpdate} props.onInput   Function to call when a non-persistent
 *                                        change has been made in the block-editor blocks
 *                                        for the given clientId. When this is called,
 *                                        controlling sources do not become dirty.
 */
function useBlockSync({
  clientId = null,
  value: controlledBlocks,
  selection: controlledSelection,
  onChange = use_block_sync_noop,
  onInput = use_block_sync_noop
}) {
  const registry = (0,external_wp_data_namespaceObject.useRegistry)();
  const {
    resetBlocks,
    resetSelection,
    replaceInnerBlocks,
    setHasControlledInnerBlocks,
    __unstableMarkNextChangeAsNotPersistent
  } = registry.dispatch(store);
  const {
    getBlockName,
    getBlocks,
    getSelectionStart,
    getSelectionEnd
  } = registry.select(store);
  const isControlled = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    return !clientId || select(store).areInnerBlocksControlled(clientId);
  }, [clientId]);
  const pendingChangesRef = (0,external_wp_element_namespaceObject.useRef)({
    incoming: null,
    outgoing: []
  });
  const subscribedRef = (0,external_wp_element_namespaceObject.useRef)(false);
  const setControlledBlocks = () =&gt; {
    if (!controlledBlocks) {
      return;
    }

    // We don&#039;t need to persist this change because we only replace
    // controlled inner blocks when the change was caused by an entity,
    // and so it would already be persisted.
    __unstableMarkNextChangeAsNotPersistent();
    if (clientId) {
      // It is important to batch here because otherwise,
      // as soon as `setHasControlledInnerBlocks` is called
      // the effect to restore might be triggered
      // before the actual blocks get set properly in state.
      registry.batch(() =&gt; {
        setHasControlledInnerBlocks(clientId, true);
        const storeBlocks = controlledBlocks.map(block =&gt; (0,external_wp_blocks_namespaceObject.cloneBlock)(block));
        if (subscribedRef.current) {
          pendingChangesRef.current.incoming = storeBlocks;
        }
        __unstableMarkNextChangeAsNotPersistent();
        replaceInnerBlocks(clientId, storeBlocks);
      });
    } else {
      if (subscribedRef.current) {
        pendingChangesRef.current.incoming = controlledBlocks;
      }
      resetBlocks(controlledBlocks);
    }
  };

  // Clean up the changes made by setControlledBlocks() when the component
  // containing useBlockSync() unmounts.
  const unsetControlledBlocks = () =&gt; {
    __unstableMarkNextChangeAsNotPersistent();
    if (clientId) {
      setHasControlledInnerBlocks(clientId, false);
      __unstableMarkNextChangeAsNotPersistent();
      replaceInnerBlocks(clientId, []);
    } else {
      resetBlocks([]);
    }
  };

  // Add a subscription to the block-editor registry to detect when changes
  // have been made. This lets us inform the data source of changes. This
  // is an effect so that the subscriber can run synchronously without
  // waiting for React renders for changes.
  const onInputRef = (0,external_wp_element_namespaceObject.useRef)(onInput);
  const onChangeRef = (0,external_wp_element_namespaceObject.useRef)(onChange);
  (0,external_wp_element_namespaceObject.useEffect)(() =&gt; {
    onInputRef.current = onInput;
    onChangeRef.current = onChange;
  }, [onInput, onChange]);

  // Determine if blocks need to be reset when they change.
  (0,external_wp_element_namespaceObject.useEffect)(() =&gt; {
    if (pendingChangesRef.current.outgoing.includes(controlledBlocks)) {
      // Skip block reset if the value matches expected outbound sync
      // triggered by this component by a preceding change detection.
      // Only skip if the value matches expectation, since a reset should
      // still occur if the value is modified (not equal by reference),
      // to allow that the consumer may apply modifications to reflect
      // back on the editor.
      if (pendingChangesRef.current.outgoing[pendingChangesRef.current.outgoing.length - 1] === controlledBlocks) {
        pendingChangesRef.current.outgoing = [];
      }
    } else if (getBlocks(clientId) !== controlledBlocks) {
      // Reset changing value in all other cases than the sync described
      // above. Since this can be reached in an update following an out-
      // bound sync, unset the outbound value to avoid considering it in
      // subsequent renders.
      pendingChangesRef.current.outgoing = [];
      setControlledBlocks();
      if (controlledSelection) {
        resetSelection(controlledSelection.selectionStart, controlledSelection.selectionEnd, controlledSelection.initialPosition);
      }
    }
  }, [controlledBlocks, clientId]);
  const isMountedRef = (0,external_wp_element_namespaceObject.useRef)(false);
  (0,external_wp_element_namespaceObject.useEffect)(() =&gt; {
    // On mount, controlled blocks are already set in the effect above.
    if (!isMountedRef.current) {
      isMountedRef.current = true;
      return;
    }

    // When the block becomes uncontrolled, it means its inner state has been reset
    // we need to take the blocks again from the external value property.
    if (!isControlled) {
      pendingChangesRef.current.outgoing = [];
      setControlledBlocks();
    }
  }, [isControlled]);
  (0,external_wp_element_namespaceObject.useEffect)(() =&gt; {
    const {
      getSelectedBlocksInitialCaretPosition,
      isLastBlockChangePersistent,
      __unstableIsLastBlockChangeIgnored,
      areInnerBlocksControlled
    } = registry.select(store);
    let blocks = getBlocks(clientId);
    let isPersistent = isLastBlockChangePersistent();
    let previousAreBlocksDifferent = false;
    subscribedRef.current = true;
    const unsubscribe = registry.subscribe(() =&gt; {
      // Sometimes, when changing block lists, lingering subscriptions
      // might trigger before they are cleaned up. If the block for which
      // the subscription runs is no longer in the store, this would clear
      // its parent entity&#039;s block list. To avoid this, we bail out if
      // the subscription is triggering for a block (`clientId !== null`)
      // and its block name can&#039;t be found because it&#039;s not on the list.
      // (`getBlockName( clientId ) === null`).
      if (clientId !== null &amp;&amp; getBlockName(clientId) === null) {
        return;
      }

      // When RESET_BLOCKS on parent blocks get called, the controlled blocks
      // can reset to uncontrolled, in these situations, it means we need to populate
      // the blocks again from the external blocks (the value property here)
      // and we should stop triggering onChange
      const isStillControlled = !clientId || areInnerBlocksControlled(clientId);
      if (!isStillControlled) {
        return;
      }
      const newIsPersistent = isLastBlockChangePersistent();
      const newBlocks = getBlocks(clientId);
      const areBlocksDifferent = newBlocks !== blocks;
      blocks = newBlocks;
      if (areBlocksDifferent &amp;&amp; (pendingChangesRef.current.incoming || __unstableIsLastBlockChangeIgnored())) {
        pendingChangesRef.current.incoming = null;
        isPersistent = newIsPersistent;
        return;
      }

      // Since we often dispatch an action to mark the previous action as
      // persistent, we need to make sure that the blocks changed on the
      // previous action before committing the change.
      const didPersistenceChange = previousAreBlocksDifferent &amp;&amp; !areBlocksDifferent &amp;&amp; newIsPersistent &amp;&amp; !isPersistent;
      if (areBlocksDifferent || didPersistenceChange) {
        isPersistent = newIsPersistent;
        // We know that onChange/onInput will update controlledBlocks.
        // We need to be aware that it was caused by an outgoing change
        // so that we do not treat it as an incoming change later on,
        // which would cause a block reset.
        pendingChangesRef.current.outgoing.push(blocks);

        // Inform the controlling entity that changes have been made to
        // the block-editor store they should be aware about.
        const updateParent = isPersistent ? onChangeRef.current : onInputRef.current;
        updateParent(blocks, {
          selection: {
            selectionStart: getSelectionStart(),
            selectionEnd: getSelectionEnd(),
            initialPosition: getSelectedBlocksInitialCaretPosition()
          }
        });
      }
      previousAreBlocksDifferent = areBlocksDifferent;
    }, store);
    return () =&gt; {
      subscribedRef.current = false;
      unsubscribe();
    };
  }, [registry, clientId]);
  (0,external_wp_element_namespaceObject.useEffect)(() =&gt; {
    return () =&gt; {
      unsetControlledBlocks();
    };
  }, []);
}

;// external [&quot;wp&quot;,&quot;keyboardShortcuts&quot;]
const external_wp_keyboardShortcuts_namespaceObject = window[&quot;wp&quot;][&quot;keyboardShortcuts&quot;];
;// ./node_modules/@wordpress/block-editor/build-module/components/keyboard-shortcuts/index.js
/**
 * WordPress dependencies
 */




function KeyboardShortcuts() {
  return null;
}
function KeyboardShortcutsRegister() {
  // Registering the shortcuts.
  const {
    registerShortcut
  } = (0,external_wp_data_namespaceObject.useDispatch)(external_wp_keyboardShortcuts_namespaceObject.store);
  (0,external_wp_element_namespaceObject.useEffect)(() =&gt; {
    registerShortcut({
      name: &#039;core/block-editor/copy&#039;,
      category: &#039;block&#039;,
      description: (0,external_wp_i18n_namespaceObject.__)(&#039;Copy the selected block(s).&#039;),
      keyCombination: {
        modifier: &#039;primary&#039;,
        character: &#039;c&#039;
      }
    });
    registerShortcut({
      name: &#039;core/block-editor/cut&#039;,
      category: &#039;block&#039;,
      description: (0,external_wp_i18n_namespaceObject.__)(&#039;Cut the selected block(s).&#039;),
      keyCombination: {
        modifier: &#039;primary&#039;,
        character: &#039;x&#039;
      }
    });
    registerShortcut({
      name: &#039;core/block-editor/paste&#039;,
      category: &#039;block&#039;,
      description: (0,external_wp_i18n_namespaceObject.__)(&#039;Paste the selected block(s).&#039;),
      keyCombination: {
        modifier: &#039;primary&#039;,
        character: &#039;v&#039;
      }
    });
    registerShortcut({
      name: &#039;core/block-editor/duplicate&#039;,
      category: &#039;block&#039;,
      description: (0,external_wp_i18n_namespaceObject.__)(&#039;Duplicate the selected block(s).&#039;),
      keyCombination: {
        modifier: &#039;primaryShift&#039;,
        character: &#039;d&#039;
      }
    });
    registerShortcut({
      name: &#039;core/block-editor/remove&#039;,
      category: &#039;block&#039;,
      description: (0,external_wp_i18n_namespaceObject.__)(&#039;Remove the selected block(s).&#039;),
      keyCombination: {
        modifier: &#039;primaryShift&#039;,
        character: &#039;backspace&#039;
      }
    });
    registerShortcut({
      name: &#039;core/block-editor/insert-before&#039;,
      category: &#039;block&#039;,
      description: (0,external_wp_i18n_namespaceObject.__)(&#039;Insert a new block before the selected block(s).&#039;),
      keyCombination: {
        modifier: &#039;primaryAlt&#039;,
        character: &#039;t&#039;
      }
    });
    registerShortcut({
      name: &#039;core/block-editor/insert-after&#039;,
      category: &#039;block&#039;,
      description: (0,external_wp_i18n_namespaceObject.__)(&#039;Insert a new block after the selected block(s).&#039;),
      keyCombination: {
        modifier: &#039;primaryAlt&#039;,
        character: &#039;y&#039;
      }
    });
    registerShortcut({
      name: &#039;core/block-editor/delete-multi-selection&#039;,
      category: &#039;block&#039;,
      description: (0,external_wp_i18n_namespaceObject.__)(&#039;Delete selection.&#039;),
      keyCombination: {
        character: &#039;del&#039;
      },
      aliases: [{
        character: &#039;backspace&#039;
      }]
    });
    registerShortcut({
      name: &#039;core/block-editor/select-all&#039;,
      category: &#039;selection&#039;,
      description: (0,external_wp_i18n_namespaceObject.__)(&#039;Select all text when typing. Press again to select all blocks.&#039;),
      keyCombination: {
        modifier: &#039;primary&#039;,
        character: &#039;a&#039;
      }
    });
    registerShortcut({
      name: &#039;core/block-editor/unselect&#039;,
      category: &#039;selection&#039;,
      description: (0,external_wp_i18n_namespaceObject.__)(&#039;Clear selection.&#039;),
      keyCombination: {
        character: &#039;escape&#039;
      }
    });
    registerShortcut({
      name: &#039;core/block-editor/multi-text-selection&#039;,
      category: &#039;selection&#039;,
      description: (0,external_wp_i18n_namespaceObject.__)(&#039;Select text across multiple blocks.&#039;),
      keyCombination: {
        modifier: &#039;shift&#039;,
        character: &#039;arrow&#039;
      }
    });
    registerShortcut({
      name: &#039;core/block-editor/focus-toolbar&#039;,
      category: &#039;global&#039;,
      description: (0,external_wp_i18n_namespaceObject.__)(&#039;Navigate to the nearest toolbar.&#039;),
      keyCombination: {
        modifier: &#039;alt&#039;,
        character: &#039;F10&#039;
      }
    });
    registerShortcut({
      name: &#039;core/block-editor/move-up&#039;,
      category: &#039;block&#039;,
      description: (0,external_wp_i18n_namespaceObject.__)(&#039;Move the selected block(s) up.&#039;),
      keyCombination: {
        modifier: &#039;secondary&#039;,
        character: &#039;t&#039;
      }
    });
    registerShortcut({
      name: &#039;core/block-editor/move-down&#039;,
      category: &#039;block&#039;,
      description: (0,external_wp_i18n_namespaceObject.__)(&#039;Move the selected block(s) down.&#039;),
      keyCombination: {
        modifier: &#039;secondary&#039;,
        character: &#039;y&#039;
      }
    });

    // List view shortcuts.
    registerShortcut({
      name: &#039;core/block-editor/collapse-list-view&#039;,
      category: &#039;list-view&#039;,
      description: (0,external_wp_i18n_namespaceObject.__)(&#039;Collapse all other items.&#039;),
      keyCombination: {
        modifier: &#039;alt&#039;,
        character: &#039;l&#039;
      }
    });
    registerShortcut({
      name: &#039;core/block-editor/group&#039;,
      category: &#039;block&#039;,
      description: (0,external_wp_i18n_namespaceObject.__)(&#039;Create a group block from the selected multiple blocks.&#039;),
      keyCombination: {
        modifier: &#039;primary&#039;,
        character: &#039;g&#039;
      }
    });
  }, [registerShortcut]);
  return null;
}
KeyboardShortcuts.Register = KeyboardShortcutsRegister;
/* harmony default export */ const keyboard_shortcuts = (KeyboardShortcuts);

;// ./node_modules/@wordpress/block-editor/build-module/components/provider/use-media-upload-settings.js
/**
 * WordPress dependencies
 */


/**
 * React hook used to compute the media upload settings to use in the post editor.
 *
 * @param {Object} settings Media upload settings prop.
 *
 * @return {Object} Media upload settings.
 */
function useMediaUploadSettings(settings = {}) {
  return (0,external_wp_element_namespaceObject.useMemo)(() =&gt; ({
    mediaUpload: settings.mediaUpload,
    mediaSideload: settings.mediaSideload,
    maxUploadFileSize: settings.maxUploadFileSize,
    allowedMimeTypes: settings.allowedMimeTypes
  }), [settings]);
}
/* harmony default export */ const use_media_upload_settings = (useMediaUploadSettings);

;// ./node_modules/@wordpress/block-editor/build-module/components/provider/index.js
/**
 * WordPress dependencies
 */





/**
 * Internal dependencies
 */








/** @typedef {import(&#039;@wordpress/data&#039;).WPDataRegistry} WPDataRegistry */

const provider_noop = () =&gt; {};

/**
 * Upload a media file when the file upload button is activated
 * or when adding a file to the editor via drag &amp; drop.
 *
 * @param {WPDataRegistry} registry
 * @param {Object}         $3                Parameters object passed to the function.
 * @param {Array}          $3.allowedTypes   Array with the types of media that can be uploaded, if unset all types are allowed.
 * @param {Object}         $3.additionalData Additional data to include in the request.
 * @param {Array&lt;File&gt;}    $3.filesList      List of files.
 * @param {Function}       $3.onError        Function called when an error happens.
 * @param {Function}       $3.onFileChange   Function called each time a file or a temporary representation of the file is available.
 * @param {Function}       $3.onSuccess      Function called once a file has completely finished uploading, including thumbnails.
 * @param {Function}       $3.onBatchSuccess Function called once all files in a group have completely finished uploading, including thumbnails.
 */
function mediaUpload(registry, {
  allowedTypes,
  additionalData = {},
  filesList,
  onError = provider_noop,
  onFileChange,
  onSuccess,
  onBatchSuccess
}) {
  void registry.dispatch(store_store).addItems({
    files: filesList,
    onChange: onFileChange,
    onSuccess,
    onBatchSuccess,
    onError: ({
      message
    }) =&gt; onError(message),
    additionalData,
    allowedTypes
  });
}
const ExperimentalBlockEditorProvider = provider_with_registry_provider(props =&gt; {
  const {
    settings: _settings,
    registry,
    stripExperimentalSettings = false
  } = props;
  const mediaUploadSettings = use_media_upload_settings(_settings);
  let settings = _settings;
  if (window.__experimentalMediaProcessing &amp;&amp; _settings.mediaUpload) {
    // Create a new variable so that the original props.settings.mediaUpload is not modified.
    settings = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; ({
      ..._settings,
      mediaUpload: mediaUpload.bind(null, registry)
    }), [_settings, registry]);
  }
  const {
    __experimentalUpdateSettings
  } = unlock((0,external_wp_data_namespaceObject.useDispatch)(store));
  (0,external_wp_element_namespaceObject.useEffect)(() =&gt; {
    __experimentalUpdateSettings({
      ...settings,
      __internalIsInitialized: true
    }, {
      stripExperimentalSettings,
      reset: true
    });
  }, [settings, stripExperimentalSettings, __experimentalUpdateSettings]);

  // Syncs the entity provider with changes in the block-editor store.
  useBlockSync(props);
  const children = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.SlotFillProvider, {
    passthrough: true,
    children: [!settings?.isPreviewMode &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(keyboard_shortcuts.Register, {}), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockRefsProvider, {
      children: props.children
    })]
  });
  if (window.__experimentalMediaProcessing) {
    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(provider, {
      settings: mediaUploadSettings,
      useSubRegistry: false,
      children: children
    });
  }
  return children;
});
const BlockEditorProvider = props =&gt; {
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ExperimentalBlockEditorProvider, {
    ...props,
    stripExperimentalSettings: true,
    children: props.children
  });
};
/* harmony default export */ const components_provider = (BlockEditorProvider);

;// ./node_modules/@wordpress/block-editor/build-module/components/block-context/index.js
/**
 * WordPress dependencies
 */


/** @typedef {import(&#039;react&#039;).ReactNode} ReactNode */

/**
 * @typedef BlockContextProviderProps
 *
 * @property {Record&lt;string,*&gt;} value    Context value to merge with current
 *                                       value.
 * @property {ReactNode}        children Component children.
 */

/** @type {import(&#039;react&#039;).Context&lt;Record&lt;string,*&gt;&gt;} */

const block_context_Context = (0,external_wp_element_namespaceObject.createContext)({});

/**
 * Component which merges passed value with current consumed block context.
 *
 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/block-context/README.md
 *
 * @param {BlockContextProviderProps} props
 */
function BlockContextProvider({
  value,
  children
}) {
  const context = (0,external_wp_element_namespaceObject.useContext)(block_context_Context);
  const nextValue = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; ({
    ...context,
    ...value
  }), [context, value]);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_context_Context.Provider, {
    value: nextValue,
    children: children
  });
}
/* harmony default export */ const block_context = (block_context_Context);

;// ./node_modules/@wordpress/block-editor/build-module/utils/block-bindings.js
/**
 * WordPress dependencies
 */


/**
 * Internal dependencies
 */


const DEFAULT_ATTRIBUTE = &#039;__default&#039;;
const PATTERN_OVERRIDES_SOURCE = &#039;core/pattern-overrides&#039;;
const BLOCK_BINDINGS_ALLOWED_BLOCKS = {
  &#039;core/paragraph&#039;: [&#039;content&#039;],
  &#039;core/heading&#039;: [&#039;content&#039;],
  &#039;core/image&#039;: [&#039;id&#039;, &#039;url&#039;, &#039;title&#039;, &#039;alt&#039;],
  &#039;core/button&#039;: [&#039;url&#039;, &#039;text&#039;, &#039;linkTarget&#039;, &#039;rel&#039;]
};

/**
 * Checks if the given object is empty.
 *
 * @param {?Object} object The object to check.
 *
 * @return {boolean} Whether the object is empty.
 */
function isObjectEmpty(object) {
  return !object || Object.keys(object).length === 0;
}

/**
 * Based on the given block name, checks if it is possible to bind the block.
 *
 * @param {string} blockName The name of the block.
 *
 * @return {boolean} Whether it is possible to bind the block to sources.
 */
function canBindBlock(blockName) {
  return blockName in BLOCK_BINDINGS_ALLOWED_BLOCKS;
}

/**
 * Based on the given block name and attribute name, checks if it is possible to bind the block attribute.
 *
 * @param {string} blockName     The name of the block.
 * @param {string} attributeName The name of attribute.
 *
 * @return {boolean} Whether it is possible to bind the block attribute.
 */
function canBindAttribute(blockName, attributeName) {
  return canBindBlock(blockName) &amp;&amp; BLOCK_BINDINGS_ALLOWED_BLOCKS[blockName].includes(attributeName);
}

/**
 * Gets the bindable attributes for a given block.
 *
 * @param {string} blockName The name of the block.
 *
 * @return {string[]} The bindable attributes for the block.
 */
function getBindableAttributes(blockName) {
  return BLOCK_BINDINGS_ALLOWED_BLOCKS[blockName];
}

/**
 * Checks if the block has the `__default` binding for pattern overrides.
 *
 * @param {?Record&lt;string, object&gt;} bindings A block&#039;s bindings from the metadata attribute.
 *
 * @return {boolean} Whether the block has the `__default` binding for pattern overrides.
 */
function hasPatternOverridesDefaultBinding(bindings) {
  return bindings?.[DEFAULT_ATTRIBUTE]?.source === PATTERN_OVERRIDES_SOURCE;
}

/**
 * Returns the bindings with the `__default` binding for pattern overrides
 * replaced with the full-set of supported attributes. e.g.:
 *
 * - bindings passed in: `{ __default: { source: &#039;core/pattern-overrides&#039; } }`
 * - bindings returned: `{ content: { source: &#039;core/pattern-overrides&#039; } }`
 *
 * @param {string}                  blockName The block name (e.g. &#039;core/paragraph&#039;).
 * @param {?Record&lt;string, object&gt;} bindings  A block&#039;s bindings from the metadata attribute.
 *
 * @return {Object} The bindings with default replaced for pattern overrides.
 */
function replacePatternOverridesDefaultBinding(blockName, bindings) {
  // The `__default` binding currently only works for pattern overrides.
  if (hasPatternOverridesDefaultBinding(bindings)) {
    const supportedAttributes = BLOCK_BINDINGS_ALLOWED_BLOCKS[blockName];
    const bindingsWithDefaults = {};
    for (const attributeName of supportedAttributes) {
      // If the block has mixed binding sources, retain any non pattern override bindings.
      const bindingSource = bindings[attributeName] ? bindings[attributeName] : {
        source: PATTERN_OVERRIDES_SOURCE
      };
      bindingsWithDefaults[attributeName] = bindingSource;
    }
    return bindingsWithDefaults;
  }
  return bindings;
}

/**
 * Contains utils to update the block `bindings` metadata.
 *
 * @typedef {Object} WPBlockBindingsUtils
 *
 * @property {Function} updateBlockBindings    Updates the value of the bindings connected to block attributes.
 * @property {Function} removeAllBlockBindings Removes the bindings property of the `metadata` attribute.
 */

/**
 * Retrieves the existing utils needed to update the block `bindings` metadata.
 * They can be used to create, modify, or remove connections from the existing block attributes.
 *
 * It contains the following utils:
 * - `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`.
 * - `removeAllBlockBindings`: Removes the bindings property of the `metadata` attribute.
 *
 * @since 6.7.0 Introduced in WordPress core.
 *
 * @param {?string} clientId Optional block client ID. If not set, it will use the current block client ID from the context.
 *
 * @return {?WPBlockBindingsUtils} Object containing the block bindings utils.
 *
 * @example
 * ```js
 * import { useBlockBindingsUtils } from &#039;@wordpress/block-editor&#039;
 * const { updateBlockBindings, removeAllBlockBindings } = useBlockBindingsUtils();
 *
 * // Update url and alt attributes.
 * updateBlockBindings( {
 *     url: {
 *         source: &#039;core/post-meta&#039;,
 *         args: {
 *             key: &#039;url_custom_field&#039;,
 *         },
 *     },
 *     alt: {
 *         source: &#039;core/post-meta&#039;,
 *         args: {
 *             key: &#039;text_custom_field&#039;,
 *         },
 *     },
 * } );
 *
 * // Remove binding from url attribute.
 * updateBlockBindings( { url: undefined } );
 *
 * // Remove bindings from all attributes.
 * removeAllBlockBindings();
 * ```
 */
function useBlockBindingsUtils(clientId) {
  const {
    clientId: contextClientId
  } = useBlockEditContext();
  const blockClientId = clientId || contextClientId;
  const {
    updateBlockAttributes
  } = (0,external_wp_data_namespaceObject.useDispatch)(store);
  const {
    getBlockAttributes
  } = (0,external_wp_data_namespaceObject.useRegistry)().select(store);

  /**
   * Updates the value of the bindings connected to block attributes.
   * It removes the binding when the new value is `undefined`.
   *
   * @param {Object} bindings        Bindings including the attributes to update and the new object.
   * @param {string} bindings.source The source name to connect to.
   * @param {Object} [bindings.args] Object containing the arguments needed by the source.
   *
   * @example
   * ```js
   * import { useBlockBindingsUtils } from &#039;@wordpress/block-editor&#039;
   *
   * const { updateBlockBindings } = useBlockBindingsUtils();
   * updateBlockBindings( {
   *     url: {
   *         source: &#039;core/post-meta&#039;,
   *         args: {
   *             key: &#039;url_custom_field&#039;,
   *         },
   * 	   },
   *     alt: {
   *         source: &#039;core/post-meta&#039;,
   *         args: {
   *             key: &#039;text_custom_field&#039;,
   *         },
   * 	   }
   * } );
   * ```
   */
  const updateBlockBindings = bindings =&gt; {
    const {
      metadata: {
        bindings: currentBindings,
        ...metadata
      } = {}
    } = getBlockAttributes(blockClientId);
    const newBindings = {
      ...currentBindings
    };
    Object.entries(bindings).forEach(([attribute, binding]) =&gt; {
      if (!binding &amp;&amp; newBindings[attribute]) {
        delete newBindings[attribute];
        return;
      }
      newBindings[attribute] = binding;
    });
    const newMetadata = {
      ...metadata,
      bindings: newBindings
    };
    if (isObjectEmpty(newMetadata.bindings)) {
      delete newMetadata.bindings;
    }
    updateBlockAttributes(blockClientId, {
      metadata: isObjectEmpty(newMetadata) ? undefined : newMetadata
    });
  };

  /**
   * Removes the bindings property of the `metadata` attribute.
   *
   * @example
   * ```js
   * import { useBlockBindingsUtils } from &#039;@wordpress/block-editor&#039;
   *
   * const { removeAllBlockBindings } = useBlockBindingsUtils();
   * removeAllBlockBindings();
   * ```
   */
  const removeAllBlockBindings = () =&gt; {
    const {
      metadata: {
        bindings,
        ...metadata
      } = {}
    } = getBlockAttributes(blockClientId);
    updateBlockAttributes(blockClientId, {
      metadata: isObjectEmpty(metadata) ? undefined : metadata
    });
  };
  return {
    updateBlockBindings,
    removeAllBlockBindings
  };
}

;// ./node_modules/@wordpress/block-editor/build-module/components/block-edit/edit.js
/**
 * External dependencies
 */


/**
 * WordPress dependencies
 */





/**
 * Internal dependencies
 */





/**
 * Default value used for blocks which do not define their own context needs,
 * used to guarantee that a block&#039;s `context` prop will always be an object. It
 * is assigned as a constant since it is always expected to be an empty object,
 * and in order to avoid unnecessary React reconciliations of a changing object.
 *
 * @type {{}}
 */

const DEFAULT_BLOCK_CONTEXT = {};
const Edit = props =&gt; {
  const {
    name
  } = props;
  const blockType = (0,external_wp_blocks_namespaceObject.getBlockType)(name);
  if (!blockType) {
    return null;
  }

  // `edit` and `save` are functions or components describing the markup
  // with which a block is displayed. If `blockType` is valid, assign
  // them preferentially as the render value for the block.
  const Component = blockType.edit || blockType.save;
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Component, {
    ...props
  });
};
const EditWithFilters = (0,external_wp_components_namespaceObject.withFilters)(&#039;editor.BlockEdit&#039;)(Edit);
const EditWithGeneratedProps = props =&gt; {
  const {
    name,
    clientId,
    attributes,
    setAttributes
  } = props;
  const registry = (0,external_wp_data_namespaceObject.useRegistry)();
  const blockType = (0,external_wp_blocks_namespaceObject.getBlockType)(name);
  const blockContext = (0,external_wp_element_namespaceObject.useContext)(block_context);
  const registeredSources = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; unlock(select(external_wp_blocks_namespaceObject.store)).getAllBlockBindingsSources(), []);
  const {
    blockBindings,
    context,
    hasPatternOverrides
  } = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; {
    // Assign context values using the block type&#039;s declared context needs.
    const computedContext = blockType?.usesContext ? Object.fromEntries(Object.entries(blockContext).filter(([key]) =&gt; blockType.usesContext.includes(key))) : DEFAULT_BLOCK_CONTEXT;
    // Add context requested by Block Bindings sources.
    if (attributes?.metadata?.bindings) {
      Object.values(attributes?.metadata?.bindings || {}).forEach(binding =&gt; {
        registeredSources[binding?.source]?.usesContext?.forEach(key =&gt; {
          computedContext[key] = blockContext[key];
        });
      });
    }
    return {
      blockBindings: replacePatternOverridesDefaultBinding(name, attributes?.metadata?.bindings),
      context: computedContext,
      hasPatternOverrides: hasPatternOverridesDefaultBinding(attributes?.metadata?.bindings)
    };
  }, [name, blockType?.usesContext, blockContext, attributes?.metadata?.bindings, registeredSources]);
  const computedAttributes = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    if (!blockBindings) {
      return attributes;
    }
    const attributesFromSources = {};
    const blockBindingsBySource = new Map();
    for (const [attributeName, binding] of Object.entries(blockBindings)) {
      const {
        source: sourceName,
        args: sourceArgs
      } = binding;
      const source = registeredSources[sourceName];
      if (!source || !canBindAttribute(name, attributeName)) {
        continue;
      }
      blockBindingsBySource.set(source, {
        ...blockBindingsBySource.get(source),
        [attributeName]: {
          args: sourceArgs
        }
      });
    }
    if (blockBindingsBySource.size) {
      for (const [source, bindings] of blockBindingsBySource) {
        // Get values in batch if the source supports it.
        let values = {};
        if (!source.getValues) {
          Object.keys(bindings).forEach(attr =&gt; {
            // Default to the the source label when `getValues` doesn&#039;t exist.
            values[attr] = source.label;
          });
        } else {
          values = source.getValues({
            select,
            context,
            clientId,
            bindings
          });
        }
        for (const [attributeName, value] of Object.entries(values)) {
          if (attributeName === &#039;url&#039; &amp;&amp; (!value || !isURLLike(value))) {
            // Return null if value is not a valid URL.
            attributesFromSources[attributeName] = null;
          } else {
            attributesFromSources[attributeName] = value;
          }
        }
      }
    }
    return {
      ...attributes,
      ...attributesFromSources
    };
  }, [attributes, blockBindings, clientId, context, name, registeredSources]);
  const setBoundAttributes = (0,external_wp_element_namespaceObject.useCallback)(nextAttributes =&gt; {
    if (!blockBindings) {
      setAttributes(nextAttributes);
      return;
    }
    registry.batch(() =&gt; {
      const keptAttributes = {
        ...nextAttributes
      };
      const blockBindingsBySource = new Map();

      // Loop only over the updated attributes to avoid modifying the bound ones that haven&#039;t changed.
      for (const [attributeName, newValue] of Object.entries(keptAttributes)) {
        if (!blockBindings[attributeName] || !canBindAttribute(name, attributeName)) {
          continue;
        }
        const binding = blockBindings[attributeName];
        const source = registeredSources[binding?.source];
        if (!source?.setValues) {
          continue;
        }
        blockBindingsBySource.set(source, {
          ...blockBindingsBySource.get(source),
          [attributeName]: {
            args: binding.args,
            newValue
          }
        });
        delete keptAttributes[attributeName];
      }
      if (blockBindingsBySource.size) {
        for (const [source, bindings] of blockBindingsBySource) {
          source.setValues({
            select: registry.select,
            dispatch: registry.dispatch,
            context,
            clientId,
            bindings
          });
        }
      }
      const hasParentPattern = !!context[&#039;pattern/overrides&#039;];
      if (
      // Don&#039;t update non-connected attributes if the block is using pattern overrides
      // and the editing is happening while overriding the pattern (not editing the original).
      !(hasPatternOverrides &amp;&amp; hasParentPattern) &amp;&amp; Object.keys(keptAttributes).length) {
        // Don&#039;t update caption and href until they are supported.
        if (hasPatternOverrides) {
          delete keptAttributes.caption;
          delete keptAttributes.href;
        }
        setAttributes(keptAttributes);
      }
    });
  }, [blockBindings, clientId, context, hasPatternOverrides, setAttributes, registeredSources, name, registry]);
  if (!blockType) {
    return null;
  }
  if (blockType.apiVersion &gt; 1) {
    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(EditWithFilters, {
      ...props,
      attributes: computedAttributes,
      context: context,
      setAttributes: setBoundAttributes
    });
  }

  // Generate a class name for the block&#039;s editable form.
  const generatedClassName = (0,external_wp_blocks_namespaceObject.hasBlockSupport)(blockType, &#039;className&#039;, true) ? (0,external_wp_blocks_namespaceObject.getBlockDefaultClassName)(name) : null;
  const className = dist_clsx(generatedClassName, attributes?.className, props.className);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(EditWithFilters, {
    ...props,
    attributes: computedAttributes,
    className: className,
    context: context,
    setAttributes: setBoundAttributes
  });
};
/* harmony default export */ const block_edit_edit = (EditWithGeneratedProps);

;// ./node_modules/@wordpress/icons/build-module/library/more-vertical.js
/**
 * WordPress dependencies
 */


const moreVertical = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;M13 19h-2v-2h2v2zm0-6h-2v-2h2v2zm0-6h-2V5h2v2z&quot;
  })
});
/* harmony default export */ const more_vertical = (moreVertical);

;// ./node_modules/@wordpress/block-editor/build-module/components/warning/index.js
/**
 * External dependencies
 */


/**
 * WordPress dependencies
 */




function Warning({
  className,
  actions,
  children,
  secondaryActions
}) {
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
    style: {
      display: &#039;contents&#039;,
      all: &#039;initial&#039;
    },
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
      className: dist_clsx(className, &#039;block-editor-warning&#039;),
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;div&quot;, {
        className: &quot;block-editor-warning__contents&quot;,
        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;p&quot;, {
          className: &quot;block-editor-warning__message&quot;,
          children: children
        }), (actions?.length &gt; 0 || secondaryActions) &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;div&quot;, {
          className: &quot;block-editor-warning__actions&quot;,
          children: [actions?.length &gt; 0 &amp;&amp; actions.map((action, i) =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;span&quot;, {
            className: &quot;block-editor-warning__action&quot;,
            children: action
          }, i)), secondaryActions &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.DropdownMenu, {
            className: &quot;block-editor-warning__secondary&quot;,
            icon: more_vertical,
            label: (0,external_wp_i18n_namespaceObject.__)(&#039;More options&#039;),
            popoverProps: {
              position: &#039;bottom left&#039;,
              className: &#039;block-editor-warning__dropdown&#039;
            },
            noIcons: true,
            children: () =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuGroup, {
              children: secondaryActions.map((item, pos) =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, {
                onClick: item.onClick,
                children: item.title
              }, pos))
            })
          })]
        })]
      })
    })
  });
}

/**
 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/warning/README.md
 */
/* harmony default export */ const warning = (Warning);

;// ./node_modules/@wordpress/block-editor/build-module/components/block-edit/multiple-usage-warning.js
/**
 * WordPress dependencies
 */





/**
 * Internal dependencies
 */



function MultipleUsageWarning({
  originalBlockClientId,
  name,
  onReplace
}) {
  const {
    selectBlock
  } = (0,external_wp_data_namespaceObject.useDispatch)(store);
  const blockType = (0,external_wp_blocks_namespaceObject.getBlockType)(name);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(warning, {
    actions: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
      __next40pxDefaultSize: true,
      variant: &quot;secondary&quot;,
      onClick: () =&gt; selectBlock(originalBlockClientId),
      children: (0,external_wp_i18n_namespaceObject.__)(&#039;Find original&#039;)
    }, &quot;find-original&quot;), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
      __next40pxDefaultSize: true,
      variant: &quot;secondary&quot;,
      onClick: () =&gt; onReplace([]),
      children: (0,external_wp_i18n_namespaceObject.__)(&#039;Remove&#039;)
    }, &quot;remove&quot;)],
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;strong&quot;, {
      children: [blockType?.title, &quot;: &quot;]
    }), (0,external_wp_i18n_namespaceObject.__)(&#039;This block can only be used once.&#039;)]
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/block-list/private-block-context.js
/**
 * WordPress dependencies
 */

const PrivateBlockContext = (0,external_wp_element_namespaceObject.createContext)({});

;// ./node_modules/@wordpress/block-editor/build-module/components/block-edit/index.js
/**
 * WordPress dependencies
 */



/**
 * Internal dependencies
 */





/**
 * The `useBlockEditContext` hook provides information about the block this hook is being used in.
 * It returns an object with the `name`, `isSelected` state, and the `clientId` of the block.
 * It is useful if you want to create custom hooks that need access to the current blocks clientId
 * but don&#039;t want to rely on the data getting passed in as a parameter.
 *
 * @return {Object} Block edit context
 */


function BlockEdit({
  mayDisplayControls,
  mayDisplayParentControls,
  blockEditingMode,
  isPreviewMode,
  // The remaining props are passed through the BlockEdit filters and are thus
  // public API!
  ...props
}) {
  const {
    name,
    isSelected,
    clientId,
    attributes = {},
    __unstableLayoutClassNames
  } = props;
  const {
    layout = null,
    metadata = {}
  } = attributes;
  const {
    bindings
  } = metadata;
  const layoutSupport = (0,external_wp_blocks_namespaceObject.hasBlockSupport)(name, &#039;layout&#039;, false) || (0,external_wp_blocks_namespaceObject.hasBlockSupport)(name, &#039;__experimentalLayout&#039;, false);
  const {
    originalBlockClientId
  } = (0,external_wp_element_namespaceObject.useContext)(PrivateBlockContext);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(Provider
  // It is important to return the same object if props haven&#039;t
  // changed to avoid  unnecessary rerenders.
  // See https://reactjs.org/docs/context.html#caveats.
  , {
    value: (0,external_wp_element_namespaceObject.useMemo)(() =&gt; ({
      name,
      isSelected,
      clientId,
      layout: layoutSupport ? layout : null,
      __unstableLayoutClassNames,
      // We use symbols in favour of an __unstable prefix to avoid
      // usage outside of the package (this context is exposed).
      [mayDisplayControlsKey]: mayDisplayControls,
      [mayDisplayParentControlsKey]: mayDisplayParentControls,
      [blockEditingModeKey]: blockEditingMode,
      [blockBindingsKey]: bindings,
      [isPreviewModeKey]: isPreviewMode
    }), [name, isSelected, clientId, layoutSupport, layout, __unstableLayoutClassNames, mayDisplayControls, mayDisplayParentControls, blockEditingMode, bindings, isPreviewMode]),
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_edit_edit, {
      ...props
    }), originalBlockClientId &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(MultipleUsageWarning, {
      originalBlockClientId: originalBlockClientId,
      name: name,
      onReplace: props.onReplace
    })]
  });
}

// EXTERNAL MODULE: ./node_modules/diff/lib/diff/character.js
var character = __webpack_require__(8021);
;// ./node_modules/@wordpress/block-editor/build-module/components/block-compare/block-view.js
/**
 * WordPress dependencies
 */




function BlockView({
  title,
  rawContent,
  renderedContent,
  action,
  actionText,
  className
}) {
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;div&quot;, {
    className: className,
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;div&quot;, {
      className: &quot;block-editor-block-compare__content&quot;,
      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;h2&quot;, {
        className: &quot;block-editor-block-compare__heading&quot;,
        children: title
      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
        className: &quot;block-editor-block-compare__html&quot;,
        children: rawContent
      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
        className: &quot;block-editor-block-compare__preview edit-post-visual-editor&quot;,
        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_element_namespaceObject.RawHTML, {
          children: (0,external_wp_dom_namespaceObject.safeHTML)(renderedContent)
        })
      })]
    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
      className: &quot;block-editor-block-compare__action&quot;,
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
        __next40pxDefaultSize: true,
        variant: &quot;secondary&quot;,
        tabIndex: &quot;0&quot;,
        onClick: action,
        children: actionText
      })
    })]
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/block-compare/index.js
/**
 * External dependencies
 */

// diff doesn&#039;t tree-shake correctly, so we import from the individual
// module here, to avoid including too much of the library


/**
 * WordPress dependencies
 */



/**
 * Internal dependencies
 */


function BlockCompare({
  block,
  onKeep,
  onConvert,
  convertor,
  convertButtonText
}) {
  function getDifference(originalContent, newContent) {
    const difference = (0,character/* diffChars */.JJ)(originalContent, newContent);
    return difference.map((item, pos) =&gt; {
      const classes = dist_clsx({
        &#039;block-editor-block-compare__added&#039;: item.added,
        &#039;block-editor-block-compare__removed&#039;: item.removed
      });
      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;span&quot;, {
        className: classes,
        children: item.value
      }, pos);
    });
  }
  function getConvertedContent(convertedBlock) {
    // The convertor may return an array of items or a single item.
    const newBlocks = Array.isArray(convertedBlock) ? convertedBlock : [convertedBlock];

    // Get converted block details.
    const newContent = newBlocks.map(item =&gt; (0,external_wp_blocks_namespaceObject.getSaveContent)(item.name, item.attributes, item.innerBlocks));
    return newContent.join(&#039;&#039;);
  }
  const converted = getConvertedContent(convertor(block));
  const difference = getDifference(block.originalContent, converted);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;div&quot;, {
    className: &quot;block-editor-block-compare__wrapper&quot;,
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockView, {
      title: (0,external_wp_i18n_namespaceObject.__)(&#039;Current&#039;),
      className: &quot;block-editor-block-compare__current&quot;,
      action: onKeep,
      actionText: (0,external_wp_i18n_namespaceObject.__)(&#039;Convert to HTML&#039;),
      rawContent: block.originalContent,
      renderedContent: block.originalContent
    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockView, {
      title: (0,external_wp_i18n_namespaceObject.__)(&#039;After Conversion&#039;),
      className: &quot;block-editor-block-compare__converted&quot;,
      action: onConvert,
      actionText: convertButtonText,
      rawContent: difference,
      renderedContent: converted
    })]
  });
}
/* harmony default export */ const block_compare = (BlockCompare);

;// ./node_modules/@wordpress/block-editor/build-module/components/block-list/block-invalid-warning.js
/**
 * WordPress dependencies
 */






/**
 * Internal dependencies
 */




const blockToBlocks = block =&gt; (0,external_wp_blocks_namespaceObject.rawHandler)({
  HTML: block.originalContent
});
function BlockInvalidWarning({
  clientId
}) {
  const {
    block,
    canInsertHTMLBlock,
    canInsertClassicBlock
  } = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      canInsertBlockType,
      getBlock,
      getBlockRootClientId
    } = select(store);
    const rootClientId = getBlockRootClientId(clientId);
    return {
      block: getBlock(clientId),
      canInsertHTMLBlock: canInsertBlockType(&#039;core/html&#039;, rootClientId),
      canInsertClassicBlock: canInsertBlockType(&#039;core/freeform&#039;, rootClientId)
    };
  }, [clientId]);
  const {
    replaceBlock
  } = (0,external_wp_data_namespaceObject.useDispatch)(store);
  const [compare, setCompare] = (0,external_wp_element_namespaceObject.useState)(false);
  const onCompareClose = (0,external_wp_element_namespaceObject.useCallback)(() =&gt; setCompare(false), []);
  const convert = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; ({
    toClassic() {
      const classicBlock = (0,external_wp_blocks_namespaceObject.createBlock)(&#039;core/freeform&#039;, {
        content: block.originalContent
      });
      return replaceBlock(block.clientId, classicBlock);
    },
    toHTML() {
      const htmlBlock = (0,external_wp_blocks_namespaceObject.createBlock)(&#039;core/html&#039;, {
        content: block.originalContent
      });
      return replaceBlock(block.clientId, htmlBlock);
    },
    toBlocks() {
      const newBlocks = blockToBlocks(block);
      return replaceBlock(block.clientId, newBlocks);
    },
    toRecoveredBlock() {
      const recoveredBlock = (0,external_wp_blocks_namespaceObject.createBlock)(block.name, block.attributes, block.innerBlocks);
      return replaceBlock(block.clientId, recoveredBlock);
    }
  }), [block, replaceBlock]);
  const secondaryActions = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; [{
    // translators: Button to fix block content
    title: (0,external_wp_i18n_namespaceObject._x)(&#039;Resolve&#039;, &#039;imperative verb&#039;),
    onClick: () =&gt; setCompare(true)
  }, canInsertHTMLBlock &amp;&amp; {
    title: (0,external_wp_i18n_namespaceObject.__)(&#039;Convert to HTML&#039;),
    onClick: convert.toHTML
  }, canInsertClassicBlock &amp;&amp; {
    title: (0,external_wp_i18n_namespaceObject.__)(&#039;Convert to Classic Block&#039;),
    onClick: convert.toClassic
  }].filter(Boolean), [canInsertHTMLBlock, canInsertClassicBlock, convert]);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(warning, {
      actions: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
        __next40pxDefaultSize: true,
        onClick: convert.toRecoveredBlock,
        variant: &quot;primary&quot;,
        children: (0,external_wp_i18n_namespaceObject.__)(&#039;Attempt recovery&#039;)
      }, &quot;recover&quot;)],
      secondaryActions: secondaryActions,
      children: (0,external_wp_i18n_namespaceObject.__)(&#039;Block contains unexpected or invalid content.&#039;)
    }), compare &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Modal, {
      title:
      // translators: Dialog title to fix block content
      (0,external_wp_i18n_namespaceObject.__)(&#039;Resolve Block&#039;),
      onRequestClose: onCompareClose,
      className: &quot;block-editor-block-compare&quot;,
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_compare, {
        block: block,
        onKeep: convert.toHTML,
        onConvert: convert.toBlocks,
        convertor: blockToBlocks,
        convertButtonText: (0,external_wp_i18n_namespaceObject.__)(&#039;Convert to Blocks&#039;)
      })
    })]
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/block-list/block-crash-warning.js
/**
 * WordPress dependencies
 */


/**
 * Internal dependencies
 */


const block_crash_warning_warning = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(warning, {
  className: &quot;block-editor-block-list__block-crash-warning&quot;,
  children: (0,external_wp_i18n_namespaceObject.__)(&#039;This block has encountered an error and cannot be previewed.&#039;)
});
/* harmony default export */ const block_crash_warning = (() =&gt; block_crash_warning_warning);

;// ./node_modules/@wordpress/block-editor/build-module/components/block-list/block-crash-boundary.js
/**
 * WordPress dependencies
 */

class BlockCrashBoundary extends external_wp_element_namespaceObject.Component {
  constructor() {
    super(...arguments);
    this.state = {
      hasError: false
    };
  }
  componentDidCatch() {
    this.setState({
      hasError: true
    });
  }
  render() {
    if (this.state.hasError) {
      return this.props.fallback;
    }
    return this.props.children;
  }
}
/* harmony default export */ const block_crash_boundary = (BlockCrashBoundary);

// EXTERNAL MODULE: ./node_modules/react-autosize-textarea/lib/index.js
var lib = __webpack_require__(4132);
;// ./node_modules/@wordpress/block-editor/build-module/components/block-list/block-html.js
/**
 * External dependencies
 */


/**
 * WordPress dependencies
 */




/**
 * Internal dependencies
 */


function BlockHTML({
  clientId
}) {
  const [html, setHtml] = (0,external_wp_element_namespaceObject.useState)(&#039;&#039;);
  const block = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; select(store).getBlock(clientId), [clientId]);
  const {
    updateBlock
  } = (0,external_wp_data_namespaceObject.useDispatch)(store);
  const onChange = () =&gt; {
    const blockType = (0,external_wp_blocks_namespaceObject.getBlockType)(block.name);
    if (!blockType) {
      return;
    }
    const attributes = (0,external_wp_blocks_namespaceObject.getBlockAttributes)(blockType, html, block.attributes);

    // If html is empty  we reset the block to the default HTML and mark it as valid to avoid triggering an error
    const content = html ? html : (0,external_wp_blocks_namespaceObject.getSaveContent)(blockType, attributes);
    const [isValid] = html ? (0,external_wp_blocks_namespaceObject.validateBlock)({
      ...block,
      attributes,
      originalContent: content
    }) : [true];
    updateBlock(clientId, {
      attributes,
      originalContent: content,
      isValid
    });

    // Ensure the state is updated if we reset so it displays the default content.
    if (!html) {
      setHtml(content);
    }
  };
  (0,external_wp_element_namespaceObject.useEffect)(() =&gt; {
    setHtml((0,external_wp_blocks_namespaceObject.getBlockContent)(block));
  }, [block]);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(lib/* default */.A, {
    className: &quot;block-editor-block-list__block-html-textarea&quot;,
    value: html,
    onBlur: onChange,
    onChange: event =&gt; setHtml(event.target.value)
  });
}
/* harmony default export */ const block_html = (BlockHTML);

;// ./node_modules/@react-spring/rafz/dist/esm/index.js
var esm_f=esm_l(),esm_n=e=&gt;esm_c(e,esm_f),esm_m=esm_l();esm_n.write=e=&gt;esm_c(e,esm_m);var esm_d=esm_l();esm_n.onStart=e=&gt;esm_c(e,esm_d);var esm_h=esm_l();esm_n.onFrame=e=&gt;esm_c(e,esm_h);var esm_p=esm_l();esm_n.onFinish=e=&gt;esm_c(e,esm_p);var esm_i=[];esm_n.setTimeout=(e,t)=&gt;{let a=esm_n.now()+t,o=()=&gt;{let F=esm_i.findIndex(z=&gt;z.cancel==o);~F&amp;&amp;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=&gt;~(~esm_i.findIndex(t=&gt;t.time&gt;e)||~esm_i.length);esm_n.cancel=e=&gt;{esm_d.delete(e),esm_h.delete(e),esm_p.delete(e),esm_f.delete(e),esm_m.delete(e)};esm_n.sync=e=&gt;{T=!0,esm_n.batchedUpdates(e),T=!1};esm_n.throttle=e=&gt;{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=()=&gt;{esm_d.delete(a),t=null},o};var esm_y=typeof window&lt;&quot;u&quot;?window.requestAnimationFrame:()=&gt;{};esm_n.use=e=&gt;esm_y=e;esm_n.now=typeof performance&lt;&quot;u&quot;?()=&gt;performance.now():Date.now;esm_n.batchedUpdates=e=&gt;e();esm_n.catch=console.error;esm_n.frameLoop=&quot;always&quot;;esm_n.advance=()=&gt;{esm_n.frameLoop!==&quot;demand&quot;?console.warn(&quot;Cannot call the manual advancement of rafz whilst frameLoop is not set as demand&quot;):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&lt;0&amp;&amp;(esm_r=0,esm_n.frameLoop!==&quot;demand&quot;&amp;&amp;esm_y(esm_b))}function esm_R(){esm_r=-1}function esm_b(){~esm_r&amp;&amp;(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&amp;&amp;(Q(esm_i.splice(0,t),a=&gt;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&amp;&amp;!e.has(a)?1:0,e.add(a)},delete(a){return esm_u-=t==e&amp;&amp;e.has(a)?1:0,e.delete(a)},flush(a){t.size&amp;&amp;(e=new Set,esm_u-=t.size,Q(t,o=&gt;o(a)&amp;&amp;e.add(o)),esm_u+=e.size,t=e)}}}function Q(e,t){e.forEach(a=&gt;{try{t(a)}catch(o){esm_n.catch(o)}})}var esm_S={count(){return esm_u},isRunning(){return esm_r&gt;=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}};

;// ./node_modules/@react-spring/shared/dist/esm/index.js
var ze=Object.defineProperty;var Le=(e,t)=&gt;{for(var r in t)ze(e,r,{get:t[r],enumerable:!0})};var dist_esm_p={};Le(dist_esm_p,{assign:()=&gt;U,colors:()=&gt;dist_esm_c,createStringInterpolator:()=&gt;esm_k,skipAnimation:()=&gt;ee,to:()=&gt;J,willAdvance:()=&gt;dist_esm_S});function Y(){}var mt=(e,t,r)=&gt;Object.defineProperty(e,t,{value:r,writable:!0,configurable:!0}),dist_esm_l={arr:Array.isArray,obj:e=&gt;!!e&amp;&amp;e.constructor.name===&quot;Object&quot;,fun:e=&gt;typeof e==&quot;function&quot;,str:e=&gt;typeof e==&quot;string&quot;,num:e=&gt;typeof e==&quot;number&quot;,und:e=&gt;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&lt;e.length;r++)if(e[r]!==t[r])return!1;return!0}return e===t}var esm_Ve=(e,t)=&gt;e.forEach(t);function xt(e,t,r){if(dist_esm_l.arr(e)){for(let n=0;n&lt;e.length;n++)t.call(r,e[n],`${n}`);return}for(let n in e)e.hasOwnProperty(n)&amp;&amp;t.call(r,e[n],n)}var ht=e=&gt;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)=&gt;Pe(e,r=&gt;r(...t)),dist_esm_h=()=&gt;typeof window&gt;&quot;u&quot;||!window.navigator||/ServerSideRendering|^Deno\//.test(window.navigator.userAgent);var esm_k,J,dist_esm_c=null,ee=!1,dist_esm_S=Y,U=e=&gt;{e.to&amp;&amp;(J=e.to),e.now&amp;&amp;(esm_n.now=e.now),e.colors!==void 0&amp;&amp;(dist_esm_c=e.colors),e.skipAnimation!=null&amp;&amp;(ee=e.skipAnimation),e.createStringInterpolator&amp;&amp;(esm_k=e.createStringInterpolator),e.requestAnimationFrame&amp;&amp;esm_n.use(e.requestAnimationFrame),e.batchedUpdates&amp;&amp;(esm_n.batchedUpdates=e.batchedUpdates),e.willAdvance&amp;&amp;(dist_esm_S=e.willAdvance),e.frameLoop&amp;&amp;(esm_n.frameLoop=e.frameLoop)};var esm_E=new Set,dist_esm_u=[],esm_H=[],A=0,qe={get idle(){return!esm_E.size&amp;&amp;!dist_esm_u.length},start(e){A&gt;e.priority?(esm_E.add(e),esm_n.onStart($e)):(te(e),esm_n(B))},advance:B,sort(e){if(A)esm_n.onFrame(()=&gt;qe.sort(e));else{let t=dist_esm_u.indexOf(e);~t&amp;&amp;(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=&gt;t.priority&gt;e.priority),0,e)}function B(e){let t=esm_H;for(let r=0;r&lt;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&gt;0}function Ge(e,t){let r=e.findIndex(t);return r&lt;0?e.length:r}var ne=(e,t,r)=&gt;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=&quot;[-+]?\\d*\\.?\\d+&quot;,esm_M=dist_esm_d+&quot;%&quot;;function C(...e){return&quot;\\(\\s*(&quot;+e.join(&quot;)\\s*,\\s*(&quot;)+&quot;)\\s*\\)&quot;}var oe=new RegExp(&quot;rgb&quot;+C(dist_esm_d,dist_esm_d,dist_esm_d)),fe=new RegExp(&quot;rgba&quot;+C(dist_esm_d,dist_esm_d,dist_esm_d,dist_esm_d)),ae=new RegExp(&quot;hsl&quot;+C(dist_esm_d,esm_M,esm_M)),ie=new RegExp(&quot;hsla&quot;+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==&quot;number&quot;?e&gt;&gt;&gt;0===e&amp;&amp;e&gt;=0&amp;&amp;e&lt;=4294967295?e:null:(t=le.exec(e))?parseInt(t[1]+&quot;ff&quot;,16)&gt;&gt;&gt;0:dist_esm_c&amp;&amp;dist_esm_c[e]!==void 0?dist_esm_c[e]:(t=oe.exec(e))?(dist_esm_y(t[1])&lt;&lt;24|dist_esm_y(t[2])&lt;&lt;16|dist_esm_y(t[3])&lt;&lt;8|255)&gt;&gt;&gt;0:(t=fe.exec(e))?(dist_esm_y(t[1])&lt;&lt;24|dist_esm_y(t[2])&lt;&lt;16|dist_esm_y(t[3])&lt;&lt;8|me(t[4]))&gt;&gt;&gt;0:(t=se.exec(e))?parseInt(t[1]+t[1]+t[2]+t[2]+t[3]+t[3]+&quot;ff&quot;,16)&gt;&gt;&gt;0:(t=esm_ce.exec(e))?parseInt(t[1],16)&gt;&gt;&gt;0:(t=ue.exec(e))?parseInt(t[1]+t[1]+t[2]+t[2]+t[3]+t[3]+t[4]+t[4],16)&gt;&gt;&gt;0:(t=ae.exec(e))?(de(esm_pe(t[1]),esm_z(t[2]),esm_z(t[3]))|255)&gt;&gt;&gt;0:(t=ie.exec(e))?(de(esm_pe(t[1]),esm_z(t[2]),esm_z(t[3]))|me(t[4]))&gt;&gt;&gt;0:null}function esm_j(e,t,r){return r&lt;0&amp;&amp;(r+=1),r&gt;1&amp;&amp;(r-=1),r&lt;1/6?e+(t-e)*6*r:r&lt;1/2?t:r&lt;2/3?e+(t-e)*(2/3-r)*6:e}function de(e,t,r){let n=r&lt;.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)&lt;&lt;24|Math.round(i*255)&lt;&lt;16|Math.round(s*255)&lt;&lt;8}function dist_esm_y(e){let t=parseInt(e,10);return t&lt;0?0:t&gt;255?255:t}function esm_pe(e){return(parseFloat(e)%360+360)%360/360}function me(e){let t=parseFloat(e);return t&lt;0?0:t&gt;1?255:Math.round(t*255)}function esm_z(e){let t=parseFloat(e);return t&lt;0?0:t&gt;100?1:t/100}function D(e){let t=be(e);if(t===null)return e;t=t||0;let r=(t&amp;4278190080)&gt;&gt;&gt;24,n=(t&amp;16711680)&gt;&gt;&gt;16,f=(t&amp;65280)&gt;&gt;&gt;8,o=(t&amp;255)/255;return`rgba(${r}, ${n}, ${f}, ${o})`}var W=(e,t,r)=&gt;{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||&quot;extend&quot;,s=n.extrapolateRight||n.extrapolate||&quot;extend&quot;,x=n.easing||(a=&gt;a);return a=&gt;{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&lt;t){if(i===&quot;identity&quot;)return a;i===&quot;clamp&quot;&amp;&amp;(a=t)}if(a&gt;r){if(s===&quot;identity&quot;)return a;s===&quot;clamp&quot;&amp;&amp;(a=r)}return n===f?n:t===r?e&lt;=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&lt;t.length-1&amp;&amp;!(t[r]&gt;=e);++r);return r-1}var Be=(e,t=&quot;end&quot;)=&gt;r=&gt;{r=t===&quot;end&quot;?Math.min(r,.999):Math.max(r,.001);let n=r*e,f=t===&quot;end&quot;?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=&gt;e&lt;1/2.75?7.5625*e*e:e&lt;2/2.75?7.5625*(e-=1.5/2.75)*e+.75:e&lt;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=&gt;e,easeInQuad:e=&gt;e*e,easeOutQuad:e=&gt;1-(1-e)*(1-e),easeInOutQuad:e=&gt;e&lt;.5?2*e*e:1-Math.pow(-2*e+2,2)/2,easeInCubic:e=&gt;e*e*e,easeOutCubic:e=&gt;1-Math.pow(1-e,3),easeInOutCubic:e=&gt;e&lt;.5?4*e*e*e:1-Math.pow(-2*e+2,3)/2,easeInQuart:e=&gt;e*e*e*e,easeOutQuart:e=&gt;1-Math.pow(1-e,4),easeInOutQuart:e=&gt;e&lt;.5?8*e*e*e*e:1-Math.pow(-2*e+2,4)/2,easeInQuint:e=&gt;e*e*e*e*e,easeOutQuint:e=&gt;1-Math.pow(1-e,5),easeInOutQuint:e=&gt;e&lt;.5?16*e*e*e*e*e:1-Math.pow(-2*e+2,5)/2,easeInSine:e=&gt;1-Math.cos(e*Math.PI/2),easeOutSine:e=&gt;Math.sin(e*Math.PI/2),easeInOutSine:e=&gt;-(Math.cos(Math.PI*e)-1)/2,easeInExpo:e=&gt;e===0?0:Math.pow(2,10*e-10),easeOutExpo:e=&gt;e===1?1:1-Math.pow(2,-10*e),easeInOutExpo:e=&gt;e===0?0:e===1?1:e&lt;.5?Math.pow(2,20*e-10)/2:(2-Math.pow(2,-20*e+10))/2,easeInCirc:e=&gt;1-Math.sqrt(1-Math.pow(e,2)),easeOutCirc:e=&gt;Math.sqrt(1-Math.pow(e-1,2)),easeInOutCirc:e=&gt;e&lt;.5?(1-Math.sqrt(1-Math.pow(2*e,2)))/2:(Math.sqrt(1-Math.pow(-2*e+2,2))+1)/2,easeInBack:e=&gt;xe*e*e*e-P*e*e,easeOutBack:e=&gt;1+xe*Math.pow(e-1,3)+P*Math.pow(e-1,2),easeInOutBack:e=&gt;e&lt;.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=&gt;e===0?0:e===1?1:-Math.pow(2,10*e-10)*Math.sin((e*10-10.75)*he),easeOutElastic:e=&gt;e===0?0:e===1?1:Math.pow(2,-10*e)*Math.sin((e*10-.75)*he)+1,easeInOutElastic:e=&gt;e===0?0:e===1?1:e&lt;.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=&gt;1-V(1-e),easeOutBounce:V,easeInOutBounce:e=&gt;e&lt;.5?(1-V(1-2*e))/2:(1+V(2*e-1))/2,steps:Be};var esm_g=Symbol.for(&quot;FluidValue.get&quot;),dist_esm_m=Symbol.for(&quot;FluidValue.observers&quot;);var Pt=e=&gt;Boolean(e&amp;&amp;e[esm_g]),ve=e=&gt;e&amp;&amp;e[esm_g]?e[esm_g]():e,esm_qt=e=&gt;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&amp;&amp;r.forEach(n=&gt;{je(n,t)})}var esm_ge=class{[esm_g];[dist_esm_m];constructor(t){if(!t&amp;&amp;!(t=this.get))throw Error(&quot;Unknown getter&quot;);De(this,t)}},De=(e,t)=&gt;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&amp;&amp;e.observerAdded(r.size,t))}return t}function Qt(e,t){let r=e[dist_esm_m];if(r&amp;&amp;r.has(t)){let n=r.size-1;n?r.delete(t):e[dist_esm_m]=null,e.observerRemoved&amp;&amp;e.observerRemoved(n,t)}}var Ee=(e,t,r)=&gt;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]+)`,&quot;i&quot;),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=&gt;{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&amp;&amp;r.startsWith(&quot;--&quot;)){let f=window.getComputedStyle(document.documentElement).getPropertyValue(r);return f||e}else{if(r&amp;&amp;dist_esm_b.test(r))return esm_N(r);if(r)return r}return e},We=e=&gt;{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)=&gt;`rgba(${Math.round(t)}, ${Math.round(r)}, ${Math.round(n)}, ${f})`,Xt=e=&gt;{_||(_=dist_esm_c?new RegExp(`(${Object.keys(dist_esm_c).join(&quot;|&quot;)})(?!\\w)`,&quot;g&quot;):/^\b$/);let t=e.output.map(o=&gt;ve(o).replace(dist_esm_b,esm_N).replace(esm_Oe,D).replace(_,D)),r=t.map(o=&gt;o.match(O).map(Number)),f=r[0].map((o,i)=&gt;r.map(s=&gt;{if(!(i in s))throw Error(&#039;The arity of each &quot;output&quot; value must be equal&#039;);return s[i]})).map(o=&gt;W({...e,output:o}));return o=&gt;{let i=!K.test(t[0])&amp;&amp;t.find(x=&gt;K.test(x))?.replace(O,&quot;&quot;),s=0;return t[0].replace(O,()=&gt;`${f[s++](o)}${i||&quot;&quot;}`).replace(we,esm_Ke)}};var Z=&quot;react-spring: &quot;,Te=e=&gt;{let t=e,r=!1;if(typeof t!=&quot;function&quot;)throw new TypeError(`${Z}once requires a function parameter`);return(...n)=&gt;{r||(t(...n),r=!0)}},Ne=Te(console.warn);function Jt(){Ne(`${Z}The &quot;interpolate&quot; function is deprecated in v9 (use &quot;to&quot; instead)`)}var _e=Te(console.warn);function er(){_e(`${Z}Directly calling start instead of using the api object is deprecated in v9 (use &quot;.start&quot; instead), this will be removed in later 0.X.0 versions`)}function esm_or(e){return dist_esm_l.str(e)&amp;&amp;(e[0]==&quot;#&quot;||/\d/.test(e)||!dist_esm_h()&amp;&amp;dist_esm_b.test(e)||e in(dist_esm_c||{}))}var dist_esm_v,q=new WeakMap,Ze=e=&gt;e.forEach(({target:t,contentRect:r})=&gt;q.get(t)?.forEach(n=&gt;n(r)));function Fe(e,t){dist_esm_v||typeof ResizeObserver&lt;&quot;u&quot;&amp;&amp;(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&amp;&amp;dist_esm_v.observe(t),()=&gt;{let n=q.get(t);!n||(n.delete(e),!n.size&amp;&amp;dist_esm_v&amp;&amp;dist_esm_v.unobserve(t))}}var esm_$=new Set,dist_esm_w,esm_Xe=()=&gt;{let e=()=&gt;{esm_$.forEach(t=&gt;t({width:window.innerWidth,height:window.innerHeight}))};return window.addEventListener(&quot;resize&quot;,e),()=&gt;{window.removeEventListener(&quot;resize&quot;,e)}},Ie=e=&gt;(esm_$.add(e),dist_esm_w||(dist_esm_w=esm_Xe()),()=&gt;{esm_$.delete(e),!esm_$.size&amp;&amp;dist_esm_w&amp;&amp;(dist_esm_w(),dist_esm_w=void 0)});var ke=(e,{container:t=document.documentElement}={})=&gt;t===document.documentElement?Ie(e):Fe(e,t);var Se=(e,t,r)=&gt;t-e===0?1:(r-e)/(t-e);var esm_Ye={x:{length:&quot;Width&quot;,position:&quot;Left&quot;},y:{length:&quot;Height&quot;,position:&quot;Top&quot;}},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=()=&gt;({current:0,progress:0,scrollLength:0});updateAxis=t=&gt;{let r=this.info[t],{length:n,position:f}=esm_Ye[t];r.current=this.container[`scroll${f}`],r.scrollLength=this.container[&quot;scroll&quot;+n]-this.container[&quot;client&quot;+n],r.progress=Se(0,r.scrollLength,r.current)};update=()=&gt;{this.updateAxis(&quot;x&quot;),this.updateAxis(&quot;y&quot;)};sendEvent=()=&gt;{this.callback(this.info)};advance=()=&gt;{this.update(),this.sendEvent()}};var esm_T=new WeakMap,Ae=new WeakMap,X=new WeakMap,Me=e=&gt;e===document.documentElement?window:e,yr=(e,{container:t=document.documentElement}={})=&gt;{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=()=&gt;(r?.forEach(s=&gt;s.advance()),!0);esm_T.set(t,o);let i=Me(t);window.addEventListener(&quot;resize&quot;,o,{passive:!0}),t!==document.documentElement&amp;&amp;Ae.set(t,ke(o,{container:t})),i.addEventListener(&quot;scroll&quot;,o,{passive:!0})}let f=esm_T.get(t);return Re(f),()=&gt;{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&amp;&amp;(Me(t).removeEventListener(&quot;scroll&quot;,i),window.removeEventListener(&quot;resize&quot;,i),Ae.get(t)?.())}};function Er(e){let t=Je(null);return t.current===null&amp;&amp;(t.current=e()),t.current}var esm_Q=dist_esm_h()?external_React_.useEffect:external_React_.useLayoutEffect;var Ce=()=&gt;{let e=(0,external_React_.useRef)(!1);return esm_Q(()=&gt;(e.current=!0,()=&gt;{e.current=!1}),[]),e};function Mr(){let e=(0,external_React_.useState)()[1],t=Ce();return()=&gt;{t.current&amp;&amp;e(Math.random())}}function Lr(e,t){let[r]=(0,external_React_.useState)(()=&gt;({inputs:t,result:e()})),n=(0,external_React_.useRef)(),f=n.current,o=f;return o?Boolean(t&amp;&amp;o.inputs&amp;&amp;it(t,o.inputs))||(o={inputs:t,result:e()}):o=r,(0,external_React_.useEffect)(()=&gt;{n.current=o,f==r&amp;&amp;(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&lt;e.length;r++)if(e[r]!==t[r])return!1;return!0}var $r=e=&gt;(0,external_React_.useEffect)(e,ut),ut=[];function Ur(e){let t=ct();return lt(()=&gt;{t.current=e}),t.current}var Wr=()=&gt;{let[e,t]=dt(null);return esm_Q(()=&gt;{let r=window.matchMedia(&quot;(prefers-reduced-motion)&quot;),n=f=&gt;{t(f.matches),U({skipAnimation:f.matches})};return n(r),r.addEventListener(&quot;change&quot;,n),()=&gt;{r.removeEventListener(&quot;change&quot;,n)}},[]),e};

;// ./node_modules/@react-spring/animated/dist/esm/index.js
var animated_dist_esm_h=Symbol.for(&quot;Animated:node&quot;),animated_dist_esm_v=e=&gt;!!e&amp;&amp;e[animated_dist_esm_h]===e,dist_esm_k=e=&gt;e&amp;&amp;e[animated_dist_esm_h],esm_D=(e,t)=&gt;mt(e,animated_dist_esm_h,t),F=e=&gt;e&amp;&amp;e[animated_dist_esm_h]&amp;&amp;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)&amp;&amp;(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)&amp;&amp;(this.lastPosition=r,n&amp;&amp;(r=Math.round(r/n)*n,this.done&amp;&amp;(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)&amp;&amp;(this.elapsedTime=0,this.durationProgress=0,this.lastPosition=this._value,r&amp;&amp;(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&amp;&amp;(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)=&gt;{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&amp;&amp;esm_Ve(this.payload,r=&gt;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&amp;&amp;Pt(r)&amp;&amp;dist_esm_f.dependencies.add(r);let n=F(r);n&amp;&amp;esm_Ve(n,a=&gt;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=&gt;t.getValue())}setValue(t){let r=this.getPayload();return t.length==r.length?r.map((n,a)=&gt;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)=&gt;{let r=!dist_esm_l.fun(e)||e.prototype&amp;&amp;e.prototype.isReactComponent;return (0,external_React_.forwardRef)((n,a)=&gt;{let i=(0,external_React_.useRef)(null),o=r&amp;&amp;(0,external_React_.useCallback)(s=&gt;{i.current=esm_ae(a,s)},[a]),[m,T]=esm_ne(n,t),W=Mr(),P=()=&gt;{let s=i.current;if(r&amp;&amp;!s)return;(s?t.applyAnimatedValues(s,m.getValue(!0)):!1)===!1&amp;&amp;W()},_=new animated_dist_esm_b(P,T),p=(0,external_React_.useRef)();esm_Q(()=&gt;(p.current=_,esm_Ve(T,s=&gt;Gt(s,_)),()=&gt;{p.current&amp;&amp;(esm_Ve(p.current.deps,s=&gt;Qt(s,p.current)),esm_n.cancel(p.current.update))})),(0,external_React_.useEffect)(P,[]),$r(()=&gt;()=&gt;{let s=p.current;esm_Ve(s.deps,S=&gt;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==&quot;change&quot;&amp;&amp;esm_n.write(this.update)}};function esm_ne(e,t){let r=new Set;return dist_esm_f.dependencies=r,e.style&amp;&amp;(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&amp;&amp;(dist_esm_l.fun(e)?e(t):e.current=t),t}var dist_esm_j=Symbol.for(&quot;AnimatedComponent&quot;),dist_esm_Ke=(e,{applyAnimatedValues:t=()=&gt;!1,createAnimatedStyle:r=a=&gt;new animated_dist_esm_u(a),getComponentProps:n=a=&gt;a}={})=&gt;{let a={applyAnimatedValues:t,createAnimatedStyle:r,getComponentProps:n},i=o=&gt;{let m=esm_I(o)||&quot;Anonymous&quot;;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)=&gt;{dist_esm_l.arr(e)&amp;&amp;(m=esm_I(o)),i[m]=i(o)}),{animated:i}},esm_I=e=&gt;dist_esm_l.str(e)?e:e&amp;&amp;dist_esm_l.str(e.displayName)?e.displayName:dist_esm_l.fun(e)&amp;&amp;e.name||null;

;// ./node_modules/@react-spring/core/dist/esm/index.js
function dist_esm_I(t,...e){return dist_esm_l.fun(t)?t(...e):t}var esm_te=(t,e)=&gt;t===!0||!!(e&amp;&amp;t&amp;&amp;(dist_esm_l.fun(t)?t(e):ht(t).includes(e))),et=(t,e)=&gt;dist_esm_l.obj(t)?e&amp;&amp;t[e]:t;var esm_ke=(t,e)=&gt;t.default===!0?t[e]:t.default?t.default[e]:void 0,nn=t=&gt;t,dist_esm_ne=(t,e=nn)=&gt;{let n=rn;t.default&amp;&amp;t.default!==!0&amp;&amp;(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=[&quot;config&quot;,&quot;onProps&quot;,&quot;onStart&quot;,&quot;onChange&quot;,&quot;onPause&quot;,&quot;onResume&quot;,&quot;onRest&quot;],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)=&gt;{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)=&gt;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)&amp;&amp;dist_esm_l.obj(t[0])}function esm_xe(t,e){t.ref?.delete(t),e?.delete(t)}function esm_he(t,e){e&amp;&amp;t.ref!==e&amp;&amp;(t.ref?.delete(t),e.add(t),t.ref=e)}function wr(t,e,n=1e3){an(()=&gt;{if(e){let r=0;ge(t,(o,s)=&gt;{let a=o.current;if(a.length){let i=n*e[s];isNaN(i)?i=r:r=i,ge(a,u=&gt;{ge(u.queue,p=&gt;{let f=p.delay;p.delay=d=&gt;i+dist_esm_I(f||0,d)})}),o.start()}})}else{let r=Promise.resolve();ge(t,o=&gt;{let s=o.current;if(s.length){let a=s.map(i=&gt;{let u=i.queue;return i.queue=[],u});r=r.then(()=&gt;(ge(s,(i,u)=&gt;ge(a[u]||[],p=&gt;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&amp;&amp;(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&amp;&amp;(t[a]=tt[a]);let{mass:r,frequency:o,damping:s}=t;return dist_esm_l.und(o)||(o&lt;.01&amp;&amp;(o=.01),s&lt;0&amp;&amp;(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))&amp;&amp;(t.duration=void 0,t.decay=void 0),n&amp;&amp;(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)=&gt;{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&amp;&amp;(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&gt;0&amp;&amp;!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&amp;&amp;(o.delayed=!1),o.pauseQueue.delete(d),o.timeouts.delete(p),t&lt;=(o.cancelId||0)&amp;&amp;(f=!0);try{s.start({...n,callId:t,cancel:f},a)}catch(c){i(c)}}})}var esm_be=(t,e)=&gt;e.length==1?e[0]:e.some(n=&gt;n.cancelled)?esm_q(t.get()):e.every(n=&gt;n.noop)?nt(t.get()):dist_esm_E(t.get(),e.every(n=&gt;n.finished)),nt=t=&gt;({value:t,noop:!0,finished:!0,cancelled:!1}),dist_esm_E=(t,e,n=!1)=&gt;({value:t,finished:e,cancelled:n}),esm_q=t=&gt;({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&amp;&amp;t===i&amp;&amp;!e.reset?u:n.promise=(async()=&gt;{n.asyncId=o,n.asyncTo=t;let p=dist_esm_ne(e,(l,h)=&gt;h===&quot;onRest&quot;?void 0:l),f,d,m=new Promise((l,h)=&gt;(f=l,d=h)),b=l=&gt;{let h=o&lt;=(n.cancelId||0)&amp;&amp;esm_q(r)||o!==n.asyncId&amp;&amp;dist_esm_E(r,!1);if(h)throw l.result=h,d(l),l},c=(l,h)=&gt;{let g=new esm_Ae,x=new esm_Ne;return(async()=&gt;{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,_)=&gt;{dist_esm_l.und(S[_])&amp;&amp;(S[_]=V)});let A=await r.start(S);return b(g),n.paused&amp;&amp;await new Promise(V=&gt;{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=&gt;{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&amp;&amp;(n.asyncId=s,n.asyncTo=s?i:void 0,n.promise=s?u:void 0)}return dist_esm_l.fun(a)&amp;&amp;esm_n.batchedUpdates(()=&gt;{a(P,r,r.item)}),P})()}function esm_oe(t,e){Pe(t.timeouts,n=&gt;n.cancel()),t.pauseQueue.clear(),t.resumeQueue.clear(),t.asyncId=t.asyncTo=t.promise=void 0,e&amp;&amp;(t.cancelId=e)}var esm_Ae=class extends Error{result;constructor(){super(&quot;An async animation has been interrupted. You see this error because you forgot to use `await` or `.catch(...)` on its returned promise.&quot;)}},esm_Ne=class extends Error{result;constructor(){super(&quot;SkipAnimationSignal&quot;)}};var esm_Re=t=&gt;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&amp;&amp;(this._priority=e,this._onPriorityChange(e))}get(){let e=dist_esm_k(this);return e&amp;&amp;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&amp;&amp;this._attach()}observerRemoved(e){e==0&amp;&amp;this._detach()}_attach(){}_detach(){}_onChange(e,n=!1){$t(this,{type:&quot;change&quot;,parent:this,value:e,idle:n})}_onPriorityChange(e){this.idle||qe.sort(this),$t(this,{type:&quot;priority&quot;,parent:this,priority:e})}};var esm_se=Symbol.for(&quot;SpringPhase&quot;),esm_bt=1,rt=2,ot=4,esm_qe=t=&gt;(t[esm_se]&amp;esm_bt)&gt;0,dist_esm_Q=t=&gt;(t[esm_se]&amp;rt)&gt;0,esm_ye=t=&gt;(t[esm_se]&amp;ot)&gt;0,st=(t,e)=&gt;e?t[esm_se]|=rt|esm_bt:t[esm_se]&amp;=~rt,esm_it=(t,e)=&gt;e?t[esm_se]|=ot:t[esm_se]&amp;=~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)&amp;&amp;(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=&gt;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&amp;&amp;Pt(o.to)&amp;&amp;(a=ht(ve(o.to))),o.values.forEach((f,d)=&gt;{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&lt;=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)&lt;=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&gt;0:l&lt;m,v,w=!1,C=1,$=Math.ceil(e/C);for(let L=0;L&lt;$&amp;&amp;(v=Math.abs(g)&gt;S,!(!v&amp;&amp;(b=Math.abs(m-c)&lt;=x,b)));++L){V&amp;&amp;(w=c==m||c&gt;m==_,w&amp;&amp;(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&gt;0&amp;&amp;(this._memoizedDuration!==s.duration&amp;&amp;(this._memoizedDuration=s.duration,f.durationProgress&gt;0&amp;&amp;(f.elapsedTime=s.duration*f.durationProgress,P=f.elapsedTime+=e)),S=(s.progress||0)+P/this._memoizedDuration,S=S&gt;1?1:S&lt;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)&amp;&amp;(console.warn(&quot;Got NaN while animating:&quot;,this),b=!0)}i&amp;&amp;!i[d].done&amp;&amp;(b=!1),b?f.done=!0:n=!1,f.setValue(c,s.round)&amp;&amp;(r=!0)});let u=dist_esm_k(this),p=u.getValue();if(n){let f=ve(o.to);(p!==f||r)&amp;&amp;!s.decay?(u.setValue(f),this._onChange(f)):r&amp;&amp;s.decay&amp;&amp;this._onChange(p),this._stop()}else r&amp;&amp;this._onChange(p)}set(e){return esm_n.batchedUpdates(()=&gt;{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(()=&gt;{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=&gt;this._update(o))).then(o=&gt;esm_be(this,o))}stop(e){let{to:n}=this.animation;return this._focus(this.get()),esm_oe(this._state,e&amp;&amp;this._lastCallId),esm_n.batchedUpdates(()=&gt;this._stop(n,e)),this}reset(){this._update({reset:!0})}eventObserved(e){e.type==&quot;change&quot;?this._start():e.type==&quot;priority&quot;&amp;&amp;(this.priority=e.priority+1)}_prepareNode(e){let n=this.key||&quot;&quot;,{to:r,from:o}=e;r=dist_esm_l.obj(r)?r[n]:r,(r==null||esm_Ee(r))&amp;&amp;(r=void 0),o=dist_esm_l.obj(o)?o[n]:o,o==null&amp;&amp;(o=void 0);let s={to:r,from:o};return esm_qe(this)||(e.reverse&amp;&amp;([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&amp;&amp;Object.assign(o,dist_esm_ne(e,(i,u)=&gt;/^on/.test(u)?et(i,r):i)),_t(this,e,&quot;onProps&quot;),esm_Ie(this,&quot;onProps&quot;,e,this);let s=this._prepareNode(e);if(Object.isFrozen(this))throw Error(&quot;Cannot animate a `SpringValue` object that is frozen. Did you forget to pass your component to `animated(...)` before animating its props?&quot;);let a=this._state;return esm_Me(++this._lastCallId,{key:r,props:e,defaultProps:o,state:a,actions:{pause:()=&gt;{esm_ye(this)||(esm_it(this,!0),yt(a.pauseQueue),esm_Ie(this,&quot;onPause&quot;,dist_esm_E(this,esm_Ce(this,this.animation.to)),this))},resume:()=&gt;{esm_ye(this)&amp;&amp;(esm_it(this,!1),dist_esm_Q(this)&amp;&amp;this._resume(),yt(a.resumeQueue),esm_Ie(this,&quot;onResume&quot;,dist_esm_E(this,esm_Ce(this,this.animation.to)),this))},start:this._merge.bind(this,s)}}).then(i=&gt;{if(e.loop&amp;&amp;i.finished&amp;&amp;!(n&amp;&amp;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&gt;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&amp;&amp;!o&amp;&amp;(!n.default||dist_esm_l.und(d))&amp;&amp;(d=m),n.reverse&amp;&amp;([d,m]=[m,d]);let b=!bt(m,f);b&amp;&amp;(u.from=m),m=ve(m);let c=!bt(d,p);c&amp;&amp;this._focus(d);let P=esm_Ee(n.to),{config:l}=u,{decay:h,velocity:g}=l;(o||s)&amp;&amp;(l.velocity=0),n.config&amp;&amp;!P&amp;&amp;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&amp;&amp;!n.default:!dist_esm_l.und(m)&amp;&amp;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&amp;&amp;(!_||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 &quot;to&quot; prop suggests`)}let w=x.constructor,C=Pt(d),$=!1;if(!C){let L=S||!esm_qe(this)&amp;&amp;b;(c||L)&amp;&amp;($=bt(esm_me(A),V),C=!$),(!bt(u.immediate,v)&amp;&amp;!v||!bt(l.decay,h)||!bt(l.velocity,g))&amp;&amp;(C=!0)}if($&amp;&amp;dist_esm_Q(this)&amp;&amp;(u.changed&amp;&amp;!S?C=!0:C||this._stop(p)),!P&amp;&amp;((C||Pt(p))&amp;&amp;(u.values=x.getPayload(),u.toValues=Pt(d)?null:w==animated_dist_esm_d?[1]:ht(V)),u.immediate!=v&amp;&amp;(u.immediate=v,!v&amp;&amp;!S&amp;&amp;this._set(p)),C)){let{onRest:L}=u;esm_Ve(_n,y=&gt;_t(this,n,y));let N=dist_esm_E(this,esm_Ce(this,p));yt(this._pendingCalls,N),this._pendingCalls.add(r),u.changed&amp;&amp;esm_n.batchedUpdates(()=&gt;{u.changed=!S,L?.(N,this),S?dist_esm_I(i.onRest,N):u.onStart?.(N,this)})}S&amp;&amp;this._set(A),P?r(esm_De(n.to,n,this._state,this)):C?this._start():dist_esm_Q(this)&amp;&amp;!c?this._pendingCalls.add(r):r(nt(A))}_focus(e){let n=this.animation;e!==n.to&amp;&amp;(esm_qt(this)&amp;&amp;this._detach(),n.to=e,esm_qt(this)&amp;&amp;this._attach())}_attach(){let e=0,{to:n}=this.animation;Pt(n)&amp;&amp;(Gt(n,this),esm_Re(n)&amp;&amp;(e=n.priority+1)),this.priority=e}_detach(){let{to:e}=this.animation;Pt(e)&amp;&amp;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&amp;&amp;esm_n.batchedUpdates(()=&gt;{this._onChange(r,n)})}}return dist_esm_k(this)}_onStart(){let e=this.animation;e.changed||(e.changed=!0,esm_Ie(this,&quot;onStart&quot;,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=&gt;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=&gt;{s.done=!0}),r.toValues&amp;&amp;(r.onChange=r.onPause=r.onResume=void 0),$t(this,{type:&quot;idle&quot;,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&amp;&amp;(r.changed=!1,esm_Ie(this,&quot;onRest&quot;,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&amp;&amp;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)&amp;&amp;Vt(e,r),dist_esm_l.obj(n)&amp;&amp;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)&amp;&amp;(e.default=dist_esm_ne(e)),e}function Vt(t,e){xt(t,(n,r)=&gt;n!=null&amp;&amp;e.add(r))}var _n=[&quot;onStart&quot;,&quot;onRest&quot;,&quot;onChange&quot;,&quot;onPause&quot;,&quot;onResume&quot;];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=[&quot;onStart&quot;,&quot;onChange&quot;,&quot;onRest&quot;],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&amp;&amp;(this._flush=n),e&amp;&amp;this.start({default:!0,...e})}get idle(){return!this._state.asyncTo&amp;&amp;Object.values(this.springs).every(e=&gt;e.idle&amp;&amp;!e.isDelayed&amp;&amp;!e.isPaused)}get item(){return this._item}set item(e){this._item=e}get(){let e={};return this.each((n,r)=&gt;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&amp;&amp;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&amp;&amp;(n=e),n){let r=this.springs;esm_Ve(ht(n),o=&gt;r[o].stop(!!e))}else esm_oe(this._state,this._lastAsyncId),this.each(r=&gt;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=&gt;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=&gt;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&gt;0,s=this._changed.size&gt;0;(o&amp;&amp;!this._started||s&amp;&amp;!this._started)&amp;&amp;(this._started=!0,Pe(e,([u,p])=&gt;{p.value=this.get(),u(p,this,this._item)}));let a=!o&amp;&amp;this._started,i=s||a&amp;&amp;r.size?this.get():null;s&amp;&amp;n.size&amp;&amp;Pe(n,([u,p])=&gt;{p.value=i,u(p,this,this._item)}),a&amp;&amp;(this._started=!1,Pe(r,([u,p])=&gt;{p.value=i,u(p,this,this._item)}))}eventObserved(e){if(e.type==&quot;change&quot;)this._changed.add(e.parent),e.idle||this._active.add(e.parent);else if(e.type==&quot;idle&quot;)this._active.delete(e.parent);else return;esm_n.onFrame(this._onFrame)}};function esm_ze(t,e){return Promise.all(e.map(n=&gt;wt(t,n))).then(n=&gt;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)&amp;&amp;e.default;a&amp;&amp;(e.loop=!1),o===!1&amp;&amp;(e.to=null),s===!1&amp;&amp;(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&amp;&amp;(p.onRest=void 0)):esm_Ve(Fn,P=&gt;{let l=e[P];if(dist_esm_l.fun(l)){let h=t._events[P];e[P]=({finished:g,cancelled:x})=&gt;{let S=h.get(l);S?(g||(S.finished=!1),x&amp;&amp;(S.cancelled=!0)):h.set(l,{value:null,finished:g||!1,cancelled:x||!1})},p&amp;&amp;(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&amp;&amp;(e.pause=!0);let m=(r||Object.keys(t.springs)).map(P=&gt;t.springs[P].start(e)),b=e.cancel===!0||esm_ke(e,&quot;cancel&quot;)===!0;(f||b&amp;&amp;d.asyncId)&amp;&amp;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&amp;&amp;await new Promise(P=&gt;{d.resumeQueue.add(P)});let c=esm_be(t,await Promise.all(m));if(a&amp;&amp;c.finished&amp;&amp;!(n&amp;&amp;c.noop)){let P=at(e,a,o);if(P)return jt(t,[P]),wt(t,P,!0)}return u&amp;&amp;esm_n.batchedUpdates(()=&gt;u(c,t,t.item)),c}function esm_e(t,e){let n={...t.springs};return e&amp;&amp;pe(Ve(e),r=&gt;{z.und(r.keys)&amp;&amp;(r=esm_Pe(r)),z.obj(r.to)||(r={...r,to:void 0}),Mt(n,r,o=&gt;esm_Lt(o))}),pt(t,n),n}function pt(t,e){Ut(e,(n,r)=&gt;{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&amp;&amp;Gt(n,e),n}function Mt(t,e,n){e.keys&amp;&amp;esm_Ve(e.keys,r=&gt;{(t[r]||(t[r]=n(r)))._prepareNode(e)})}function jt(t,e){esm_Ve(e,n=&gt;{Mt(t.springs,n,r=&gt;esm_Lt(r,t))})}var dist_esm_H=({children:t,...e})=&gt;{let n=(0,external_React_.useContext)(esm_Ge),r=e.pause||!!n.pause,o=e.immediate||!!n.immediate;e=Lr(()=&gt;({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=()=&gt;{let t=[],e=function(r){Ln();let o=[];return ce(t,(s,a)=&gt;{if(Ke.und(r))o.push(s.start());else{let i=n(r,s,a);i&amp;&amp;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&amp;&amp;t.splice(o,1)},e.pause=function(){return ce(t,r=&gt;r.pause(...arguments)),this},e.resume=function(){return ce(t,r=&gt;r.resume(...arguments)),this},e.set=function(r){ce(t,(o,s)=&gt;{let a=Ke.fun(r)?r(s,o):r;a&amp;&amp;o.set(a)})},e.start=function(r){let o=[];return ce(t,(s,a)=&gt;{if(Ke.und(r))o.push(s.start());else{let i=this._getProps(r,s,a);i&amp;&amp;o.push(s.start(i))}}),o},e.stop=function(){return ce(t,r=&gt;r.stop(...arguments)),this},e.update=function(r){return ce(t,(o,s)=&gt;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)&amp;&amp;e;r&amp;&amp;!n&amp;&amp;(n=[]);let o=Xe(()=&gt;r||arguments.length==3?esm_fe():void 0,[]),s=Nt(0),a=Dn(),i=Xe(()=&gt;({ctrls:[],queue:[],flush(h,g){let x=esm_e(h,g);return s.current&gt;0&amp;&amp;!i.queue.length&amp;&amp;!Object.keys(x).some(A=&gt;!h.springs[A])?esm_ze(h,g):new Promise(A=&gt;{pt(h,x),i.queue.push(()=&gt;{A(esm_ze(h,g))}),a()})}}),[]),u=Nt([...i.ctrls]),p=[],f=Dt(t)||0;Xe(()=&gt;{Ye(u.current.slice(t,f),h=&gt;{esm_xe(h,o),h.stop(!0)}),u.current.length=t,d(f,t)},[t]),Xe(()=&gt;{d(0,Math.min(f,t))},n);function d(h,g){for(let x=h;x&lt;g;x++){let S=u.current[x]||(u.current[x]=new esm_le(null,i.flush)),A=r?r(x,S):e[x];A&amp;&amp;(p[x]=Ot(A))}}let m=u.current.map((h,g)=&gt;esm_e(h,p[g])),b=Mn(dist_esm_H),c=Dt(b),P=b!==c&amp;&amp;esm_Ue(b);qn(()=&gt;{s.current++,i.ctrls=u.current;let{queue:h}=i;h.length&amp;&amp;(i.queue=[],Ye(h,g=&gt;g())),Ye(u.current,(g,x)=&gt;{o?.add(g),P&amp;&amp;g.start({default:b});let S=p[x];S&amp;&amp;(esm_he(g,S.ref),g.ref?g.queue.push(S):g.start(S))})}),Nn(()=&gt;()=&gt;{Ye(i.ctrls,h=&gt;h.stop(!0))});let l=m.map(h=&gt;({...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=()=&gt;esm_fe(),Xo=()=&gt;zn(Gn)[0];var Wo=(t,e)=&gt;{let n=Bn(()=&gt;new esm_ue(t,e));return Kn(()=&gt;()=&gt;{n.stop()}),n};function esm_Qt(t,e,n){let r=qt.fun(e)&amp;&amp;e;r&amp;&amp;!n&amp;&amp;(n=[]);let o=!0,s,a=esm_He(t,(i,u)=&gt;{let p=r?r(i,u):e;return s=p.ref,o=o&amp;&amp;p.reverse,p},n||[{}]);if(Yn(()=&gt;{Xn(a[1].current,(i,u)=&gt;{let p=a[1].current[u+(o?1:-1)];if(esm_he(i,s),i.ref){p&amp;&amp;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)=&gt;{let d=qt.fun(u)?u(f,p):u;if(d){let m=i.current[f+(d.reverse?1:-1)];return m&amp;&amp;(d.to=m.springs),d}},a}return a[0]}function esm_Gt(t,e,n){let r=G.fun(e)&amp;&amp;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(()=&gt;r||arguments.length==3?esm_fe():void 0,[]),b=zt(t),c=[],P=lt(null),l=o?null:P.current;Je(()=&gt;{P.current=c}),$n(()=&gt;(j(c,y=&gt;{m?.add(y.ctrl),y.ctrl.ref=m}),()=&gt;{j(P.current,y=&gt;{y.expired&amp;&amp;clearTimeout(y.expirationId),esm_xe(y.ctrl,m),y.ctrl.stop(!0)})}));let h=tr(b,r?r():e,l),g=o&amp;&amp;P.current||[];Je(()=&gt;j(g,({ctrl:y,item:T,key:F})=&gt;{esm_xe(y,m),dist_esm_I(p,T,F)}));let x=[];if(l&amp;&amp;j(l,(y,T)=&gt;{y.expired?(clearTimeout(y.expirationId),g.push(y)):(T=x[T]=h.indexOf(y.key),~T&amp;&amp;(c[T]=y))}),j(b,(y,T)=&gt;{c[T]||(c[T]={key:h[T],item:y,phase:&quot;mount&quot;,ctrl:new esm_le},c[T].ctrl.item=y)}),x.length){let y=-1,{leave:T}=r?r():e;j(x,(F,k)=&gt;{let O=l[k];~F?(y=c.indexOf(O),c[y]={...O,item:b[F]}):T&amp;&amp;c.splice(++y,0,O)})}G.fun(s)&amp;&amp;c.sort((y,T)=&gt;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)=&gt;{let F=y.key,k=y.phase,O=r?r():e,U,D,Jt=dist_esm_I(O.delay||0,F);if(k==&quot;mount&quot;)U=O.enter,D=&quot;enter&quot;;else{let M=h.indexOf(F)&lt;0;if(k!=&quot;leave&quot;)if(M)U=O.leave,D=&quot;leave&quot;;else if(U=O.update)D=&quot;update&quot;;else return;else if(!M)U=O.enter,D=&quot;enter&quot;;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==&quot;enter&quot;&amp;&amp;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=&gt;{dist_esm_I(Wt,M);let Te=P.current,B=Te.find(Fe=&gt;Fe.key===F);if(!!B&amp;&amp;!(M.cancelled&amp;&amp;B.phase!=&quot;update&quot;)&amp;&amp;B.ctrl.idle){let Fe=Te.every(ee=&gt;ee.ctrl.idle);if(B.phase==&quot;leave&quot;){let ee=dist_esm_I(i,B.item);if(ee!==!1){let Ze=ee===!0?0:ee;if(B.expired=!0,!Fe&amp;&amp;Ze&gt;0){Ze&lt;=2147483647&amp;&amp;(B.expirationId=setTimeout(A,Ze));return}}}Fe&amp;&amp;Te.some(ee=&gt;ee.expired)&amp;&amp;(v.current.delete(B),u&amp;&amp;(w.current=!0),A())}};let ft=esm_e(y.ctrl,Z);D===&quot;leave&quot;&amp;&amp;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!==$&amp;&amp;esm_Ue(C);Je(()=&gt;{L&amp;&amp;j(c,y=&gt;{y.ctrl.start({default:C})})},[C]),j(_,(y,T)=&gt;{if(v.current.size){let F=c.findIndex(k=&gt;k.key===T.key);c.splice(F,1)}}),Je(()=&gt;{j(v.current.size?v.current:_,({phase:y,payload:T},F)=&gt;{let{ctrl:k}=F;F.phase=y,m?.add(k),L&amp;&amp;y==&quot;enter&quot;&amp;&amp;k.start({default:C}),T&amp;&amp;(esm_he(k,T.ref),(k.ref||m)&amp;&amp;!w.current?k.update(T):(k.start(T),w.current&amp;&amp;(w.current=!1)))})},o?void 0:n);let N=y=&gt;Oe.createElement(Oe.Fragment,null,c.map((T,F)=&gt;{let{springs:k}=_.get(T)||T.ctrl,O=y({...k},T.item,T,F);return O&amp;&amp;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=&gt;{let a=r&amp;&amp;r.find(i=&gt;i.item===s&amp;&amp;i.phase!==&quot;leave&quot;&amp;&amp;!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}={})=&gt;{let[n,r]=esm_J(()=&gt;({scrollX:0,scrollY:0,scrollXProgress:0,scrollYProgress:0,...e}),[]);return or(()=&gt;{let o=rr(({x:s,y:a})=&gt;{r.start({scrollX:s.current,scrollXProgress:s.progress,scrollY:a.current,scrollYProgress:a.progress})},{container:t?.current||void 0});return()=&gt;{nr(Object.values(n),s=&gt;s.stop()),o()}},[]),n};var Ps=({container:t,...e})=&gt;{let[n,r]=esm_J(()=&gt;({width:0,height:0,...e}),[]);return ar(()=&gt;{let o=sr(({width:s,height:a})=&gt;{r.start({width:s,height:a,immediate:n.width.get()===0||n.height.get()===0})},{container:t?.current||void 0});return()=&gt;{ir(Object.values(n),s=&gt;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)&amp;&amp;t,a=s?s():{},{to:i={},from:u={},...p}=a,f=s?e:t,[d,m]=esm_J(()=&gt;({from:u,...p}),[]);return lr(()=&gt;{let b=o.current,{root:c,once:P,amount:l=&quot;any&quot;,...h}=f??{};if(!b||P&amp;&amp;n||typeof IntersectionObserver&gt;&quot;u&quot;)return;let g=new WeakMap,x=()=&gt;(i&amp;&amp;m.start(i),r(!0),P?void 0:()=&gt;{u&amp;&amp;m.start(u),r(!1)}),S=V=&gt;{V.forEach(_=&gt;{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&amp;&amp;(v(),g.delete(_.target))})},A=new IntersectionObserver(S,{root:c&amp;&amp;c.current||void 0,threshold:typeof l==&quot;number&quot;||Array.isArray(l)?l:cr[l],...h});return A.observe(b),()=&gt;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)=&gt;{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&amp;&amp;Yt(this._active)&amp;&amp;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&amp;&amp;!Yt(this._active)&amp;&amp;(this.idle=!1,esm_Ve(F(this),n=&gt;{n.done=!1}),dist_esm_p.skipAnimation?(esm_n.batchedUpdates(()=&gt;this.advance()),esm_ct(this)):qe.start(this))}_attach(){let n=1;esm_Ve(ht(this.source),r=&gt;{Pt(r)&amp;&amp;Gt(r,this),esm_Re(r)&amp;&amp;(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=&gt;{Pt(n)&amp;&amp;Qt(n,this)}),this._active.clear(),esm_ct(this)}eventObserved(n){n.type==&quot;change&quot;?n.idle?this.advance():(this._active.add(n.parent),this._start()):n.type==&quot;idle&quot;?this._active.delete(n.parent):n.type==&quot;priority&quot;&amp;&amp;(this.priority=ht(this.source).reduce((r,o)=&gt;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=&gt;{e.done=!0}),$t(t,{type:&quot;idle&quot;,parent:t}))}var esm_ui=(t,...e)=&gt;new esm_W(t,e),pi=(t,...e)=&gt;(Cr(),new esm_W(t,e));dist_esm_p.assign({createStringInterpolator:Xt,to:(t,e)=&gt;new esm_W(t,e)});var di=qe.advance;

;// external &quot;ReactDOM&quot;
const external_ReactDOM_namespaceObject = window[&quot;ReactDOM&quot;];
;// ./node_modules/@react-spring/web/dist/esm/index.js
var web_dist_esm_k=/^--/;function web_dist_esm_I(t,e){return e==null||typeof e==&quot;boolean&quot;||e===&quot;&quot;?&quot;&quot;:typeof e==&quot;number&quot;&amp;&amp;e!==0&amp;&amp;!web_dist_esm_k.test(t)&amp;&amp;!(web_dist_esm_c.hasOwnProperty(t)&amp;&amp;web_dist_esm_c[t])?e+&quot;px&quot;:(&quot;&quot;+e).trim()}var web_dist_esm_v={};function esm_V(t,e){if(!t.nodeType||!t.setAttribute)return!1;let r=t.nodeName===&quot;filter&quot;||t.parentNode&amp;&amp;t.parentNode.nodeName===&quot;filter&quot;,{style:i,children:s,scrollTop:u,scrollLeft:l,viewBox:a,...n}=e,d=Object.values(n),m=Object.keys(n).map(o=&gt;r||t.hasAttribute(o)?o:web_dist_esm_v[o]||(web_dist_esm_v[o]=o.replace(/([A-Z])/g,p=&gt;&quot;-&quot;+p.toLowerCase())));s!==void 0&amp;&amp;(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)=&gt;{t.setAttribute(o,d[p])}),u!==void 0&amp;&amp;(t.scrollTop=u),l!==void 0&amp;&amp;(t.scrollLeft=l),a!==void 0&amp;&amp;t.setAttribute(&quot;viewBox&quot;,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)=&gt;t+e.charAt(0).toUpperCase()+e.substring(1),esm_L=[&quot;Webkit&quot;,&quot;Ms&quot;,&quot;Moz&quot;,&quot;O&quot;];web_dist_esm_c=Object.keys(web_dist_esm_c).reduce((t,e)=&gt;(esm_L.forEach(r=&gt;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)=&gt;dist_esm_l.num(t)&amp;&amp;t!==0?t+e:t,web_dist_esm_h=(t,e)=&gt;dist_esm_l.arr(t)?t.every(r=&gt;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)&amp;&amp;(u.push([e||0,r||0,i||0]),l.push(a=&gt;[`translate3d(${a.map(n=&gt;web_dist_esm_y(n,&quot;px&quot;)).join(&quot;,&quot;)})`,web_dist_esm_h(a,0)])),xt(s,(a,n)=&gt;{if(n===&quot;transform&quot;)u.push([a||&quot;&quot;]),l.push(d=&gt;[d,d===&quot;&quot;]);else if(esm_.test(n)){if(delete s[n],dist_esm_l.und(a))return;let d=dist_esm_$.test(n)?&quot;px&quot;:dist_esm_G.test(n)?&quot;deg&quot;:&quot;&quot;;u.push(ht(a)),l.push(n===&quot;rotate3d&quot;?([m,o,p,O])=&gt;[`rotate3d(${m},${o},${p},${web_dist_esm_y(O,d)})`,web_dist_esm_h(O,0)]:m=&gt;[`${n}(${m.map(o=&gt;web_dist_esm_y(o,d)).join(&quot;,&quot;)})`,web_dist_esm_h(m,n.startsWith(&quot;scale&quot;)?1:0)])}}),u.length&amp;&amp;(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=&quot;&quot;,i=!0;return esm_Ve(this.inputs,(s,u)=&gt;{let l=ve(s[0]),[a,n]=this.transforms[u](dist_esm_l.arr(l)?l:s.map(ve));r+=&quot; &quot;+a,i=i&amp;&amp;n}),i?&quot;none&quot;:r}observerAdded(r){r==1&amp;&amp;esm_Ve(this.inputs,i=&gt;esm_Ve(i,s=&gt;Pt(s)&amp;&amp;Gt(s,this)))}observerRemoved(r){r==0&amp;&amp;esm_Ve(this.inputs,i=&gt;esm_Ve(i,s=&gt;Pt(s)&amp;&amp;Qt(s,this)))}eventObserved(r){r.type==&quot;change&quot;&amp;&amp;(this._value=null),$t(this,r)}};var esm_C=[&quot;a&quot;,&quot;abbr&quot;,&quot;address&quot;,&quot;area&quot;,&quot;article&quot;,&quot;aside&quot;,&quot;audio&quot;,&quot;b&quot;,&quot;base&quot;,&quot;bdi&quot;,&quot;bdo&quot;,&quot;big&quot;,&quot;blockquote&quot;,&quot;body&quot;,&quot;br&quot;,&quot;button&quot;,&quot;canvas&quot;,&quot;caption&quot;,&quot;cite&quot;,&quot;code&quot;,&quot;col&quot;,&quot;colgroup&quot;,&quot;data&quot;,&quot;datalist&quot;,&quot;dd&quot;,&quot;del&quot;,&quot;details&quot;,&quot;dfn&quot;,&quot;dialog&quot;,&quot;div&quot;,&quot;dl&quot;,&quot;dt&quot;,&quot;em&quot;,&quot;embed&quot;,&quot;fieldset&quot;,&quot;figcaption&quot;,&quot;figure&quot;,&quot;footer&quot;,&quot;form&quot;,&quot;h1&quot;,&quot;h2&quot;,&quot;h3&quot;,&quot;h4&quot;,&quot;h5&quot;,&quot;h6&quot;,&quot;head&quot;,&quot;header&quot;,&quot;hgroup&quot;,&quot;hr&quot;,&quot;html&quot;,&quot;i&quot;,&quot;iframe&quot;,&quot;img&quot;,&quot;input&quot;,&quot;ins&quot;,&quot;kbd&quot;,&quot;keygen&quot;,&quot;label&quot;,&quot;legend&quot;,&quot;li&quot;,&quot;link&quot;,&quot;main&quot;,&quot;map&quot;,&quot;mark&quot;,&quot;menu&quot;,&quot;menuitem&quot;,&quot;meta&quot;,&quot;meter&quot;,&quot;nav&quot;,&quot;noscript&quot;,&quot;object&quot;,&quot;ol&quot;,&quot;optgroup&quot;,&quot;option&quot;,&quot;output&quot;,&quot;p&quot;,&quot;param&quot;,&quot;picture&quot;,&quot;pre&quot;,&quot;progress&quot;,&quot;q&quot;,&quot;rp&quot;,&quot;rt&quot;,&quot;ruby&quot;,&quot;s&quot;,&quot;samp&quot;,&quot;script&quot;,&quot;section&quot;,&quot;select&quot;,&quot;small&quot;,&quot;source&quot;,&quot;span&quot;,&quot;strong&quot;,&quot;style&quot;,&quot;sub&quot;,&quot;summary&quot;,&quot;sup&quot;,&quot;table&quot;,&quot;tbody&quot;,&quot;td&quot;,&quot;textarea&quot;,&quot;tfoot&quot;,&quot;th&quot;,&quot;thead&quot;,&quot;time&quot;,&quot;title&quot;,&quot;tr&quot;,&quot;track&quot;,&quot;u&quot;,&quot;ul&quot;,&quot;var&quot;,&quot;video&quot;,&quot;wbr&quot;,&quot;circle&quot;,&quot;clipPath&quot;,&quot;defs&quot;,&quot;ellipse&quot;,&quot;foreignObject&quot;,&quot;g&quot;,&quot;image&quot;,&quot;line&quot;,&quot;linearGradient&quot;,&quot;mask&quot;,&quot;path&quot;,&quot;pattern&quot;,&quot;polygon&quot;,&quot;polyline&quot;,&quot;radialGradient&quot;,&quot;rect&quot;,&quot;stop&quot;,&quot;svg&quot;,&quot;text&quot;,&quot;tspan&quot;];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=&gt;new dist_esm_g(t),getComponentProps:({scrollTop:t,scrollLeft:e,...r})=&gt;r}),dist_esm_it=dist_esm_q.animated;

;// ./node_modules/@wordpress/block-editor/build-module/components/use-moving-animation/index.js
/**
 * External dependencies
 */


/**
 * WordPress dependencies
 */




/**
 * Internal dependencies
 */


/**
 * If the block count exceeds the threshold, we disable the reordering animation
 * to avoid laginess.
 */
const BLOCK_ANIMATION_THRESHOLD = 200;
function getAbsolutePosition(element) {
  return {
    top: element.offsetTop,
    left: element.offsetLeft
  };
}

/**
 * Hook used to compute the styles required to move a div into a new position.
 *
 * The way this animation works is the following:
 *  - It first renders the element as if there was no animation.
 *  - It takes a snapshot of the position of the block to use it
 *    as a destination point for the animation.
 *  - It restores the element to the previous position using a CSS transform
 *  - It uses the &quot;resetAnimation&quot; flag to reset the animation
 *    from the beginning in order to animate to the new destination point.
 *
 * @param {Object} $1                          Options
 * @param {*}      $1.triggerAnimationOnChange Variable used to trigger the animation if it changes.
 * @param {string} $1.clientId
 */
function useMovingAnimation({
  triggerAnimationOnChange,
  clientId
}) {
  const ref = (0,external_wp_element_namespaceObject.useRef)();
  const {
    isTyping,
    getGlobalBlockCount,
    isBlockSelected,
    isFirstMultiSelectedBlock,
    isBlockMultiSelected,
    isAncestorMultiSelected,
    isDraggingBlocks
  } = (0,external_wp_data_namespaceObject.useSelect)(store);

  // Whenever the trigger changes, we need to take a snapshot of the current
  // position of the block to use it as a destination point for the animation.
  const {
    previous,
    prevRect
  } = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; ({
    previous: ref.current &amp;&amp; getAbsolutePosition(ref.current),
    prevRect: ref.current &amp;&amp; ref.current.getBoundingClientRect()
  }), [triggerAnimationOnChange]);
  (0,external_wp_element_namespaceObject.useLayoutEffect)(() =&gt; {
    if (!previous || !ref.current) {
      return;
    }
    const scrollContainer = (0,external_wp_dom_namespaceObject.getScrollContainer)(ref.current);
    const isSelected = isBlockSelected(clientId);
    const adjustScrolling = isSelected || isFirstMultiSelectedBlock(clientId);
    const isDragging = isDraggingBlocks();
    function preserveScrollPosition() {
      // The user already scrolled when dragging blocks.
      if (isDragging) {
        return;
      }
      if (adjustScrolling &amp;&amp; prevRect) {
        const blockRect = ref.current.getBoundingClientRect();
        const diff = blockRect.top - prevRect.top;
        if (diff) {
          scrollContainer.scrollTop += diff;
        }
      }
    }

    // We disable the animation if the user has a preference for reduced
    // motion, if the user is typing (insertion by Enter), or if the block
    // count exceeds the threshold (insertion caused all the blocks that
    // follow to animate).
    // To do: consider enabling the _moving_ animation even for large
    // posts, while only disabling the _insertion_ animation?
    const disableAnimation = window.matchMedia(&#039;(prefers-reduced-motion: reduce)&#039;).matches || isTyping() || getGlobalBlockCount() &gt; BLOCK_ANIMATION_THRESHOLD;
    if (disableAnimation) {
      // If the animation is disabled and the scroll needs to be adjusted,
      // just move directly to the final scroll position.
      preserveScrollPosition();
      return;
    }
    const isPartOfSelection = isSelected || isBlockMultiSelected(clientId) || isAncestorMultiSelected(clientId);

    // The user already dragged the blocks to the new position, so don&#039;t
    // animate the dragged blocks.
    if (isPartOfSelection &amp;&amp; isDragging) {
      return;
    }

    // Make sure the other blocks move under the selected block(s).
    const zIndex = isPartOfSelection ? &#039;1&#039; : &#039;&#039;;
    const controller = new esm_le({
      x: 0,
      y: 0,
      config: {
        mass: 5,
        tension: 2000,
        friction: 200
      },
      onChange({
        value
      }) {
        if (!ref.current) {
          return;
        }
        let {
          x,
          y
        } = value;
        x = Math.round(x);
        y = Math.round(y);
        const finishedMoving = x === 0 &amp;&amp; y === 0;
        ref.current.style.transformOrigin = &#039;center center&#039;;
        ref.current.style.transform = finishedMoving ? null // Set to `null` to explicitly remove the transform.
        : `translate3d(${x}px,${y}px,0)`;
        ref.current.style.zIndex = zIndex;
        preserveScrollPosition();
      }
    });
    ref.current.style.transform = undefined;
    const destination = getAbsolutePosition(ref.current);
    const x = Math.round(previous.left - destination.left);
    const y = Math.round(previous.top - destination.top);
    controller.start({
      x: 0,
      y: 0,
      from: {
        x,
        y
      }
    });
    return () =&gt; {
      controller.stop();
      controller.set({
        x: 0,
        y: 0
      });
    };
  }, [previous, prevRect, clientId, isTyping, getGlobalBlockCount, isBlockSelected, isFirstMultiSelectedBlock, isBlockMultiSelected, isAncestorMultiSelected, isDraggingBlocks]);
  return ref;
}
/* harmony default export */ const use_moving_animation = (useMovingAnimation);

;// ./node_modules/@wordpress/block-editor/build-module/components/block-list/use-block-props/use-focus-first-element.js
/**
 * WordPress dependencies
 */




/**
 * Internal dependencies
 */




/** @typedef {import(&#039;@wordpress/element&#039;).RefObject} RefObject */

/**
 * Transitions focus to the block or inner tabbable when the block becomes
 * selected and an initial position is set.
 *
 * @param {string} clientId Block client ID.
 *
 * @return {RefObject} React ref with the block element.
 */
function useFocusFirstElement({
  clientId,
  initialPosition
}) {
  const ref = (0,external_wp_element_namespaceObject.useRef)();
  const {
    isBlockSelected,
    isMultiSelecting,
    isZoomOut
  } = unlock((0,external_wp_data_namespaceObject.useSelect)(store));
  (0,external_wp_element_namespaceObject.useEffect)(() =&gt; {
    // Check if the block is still selected at the time this effect runs.
    if (!isBlockSelected(clientId) || isMultiSelecting() || isZoomOut()) {
      return;
    }
    if (initialPosition === undefined || initialPosition === null) {
      return;
    }
    if (!ref.current) {
      return;
    }
    const {
      ownerDocument
    } = ref.current;

    // Do not focus the block if it already contains the active element.
    if (isInsideRootBlock(ref.current, ownerDocument.activeElement)) {
      return;
    }

    // Find all tabbables within node.
    const textInputs = external_wp_dom_namespaceObject.focus.tabbable.find(ref.current).filter(node =&gt; (0,external_wp_dom_namespaceObject.isTextField)(node));

    // If reversed (e.g. merge via backspace), use the last in the set of
    // tabbables.
    const isReverse = -1 === initialPosition;
    const target = textInputs[isReverse ? textInputs.length - 1 : 0] || ref.current;
    if (!isInsideRootBlock(ref.current, target)) {
      ref.current.focus();
      return;
    }

    // Check to see if element is focussable before a generic caret insert.
    if (!ref.current.getAttribute(&#039;contenteditable&#039;)) {
      const focusElement = external_wp_dom_namespaceObject.focus.tabbable.findNext(ref.current);
      // Make sure focusElement is valid, contained in the same block, and a form field.
      if (focusElement &amp;&amp; isInsideRootBlock(ref.current, focusElement) &amp;&amp; (0,external_wp_dom_namespaceObject.isFormElement)(focusElement)) {
        focusElement.focus();
        return;
      }
    }
    (0,external_wp_dom_namespaceObject.placeCaretAtHorizontalEdge)(target, isReverse);
  }, [initialPosition, clientId]);
  return ref;
}

;// ./node_modules/@wordpress/block-editor/build-module/components/block-list/use-block-props/use-is-hovered.js
/**
 * WordPress dependencies
 */



/**
 * Internal dependencies
 */


/*
 * Adds `is-hovered` class when the block is hovered and in navigation or
 * outline mode.
 */
function useIsHovered({
  clientId
}) {
  const {
    hoverBlock
  } = (0,external_wp_data_namespaceObject.useDispatch)(store);
  function listener(event) {
    if (event.defaultPrevented) {
      return;
    }
    const action = event.type === &#039;mouseover&#039; ? &#039;add&#039; : &#039;remove&#039;;
    event.preventDefault();
    event.currentTarget.classList[action](&#039;is-hovered&#039;);
    if (action === &#039;add&#039;) {
      hoverBlock(clientId);
    } else {
      hoverBlock(null);
    }
  }
  return (0,external_wp_compose_namespaceObject.useRefEffect)(node =&gt; {
    node.addEventListener(&#039;mouseout&#039;, listener);
    node.addEventListener(&#039;mouseover&#039;, listener);
    return () =&gt; {
      node.removeEventListener(&#039;mouseout&#039;, listener);
      node.removeEventListener(&#039;mouseover&#039;, listener);

      // Remove class in case it lingers.
      node.classList.remove(&#039;is-hovered&#039;);
      hoverBlock(null);
    };
  }, []);
}

;// ./node_modules/@wordpress/block-editor/build-module/components/block-list/use-block-props/use-focus-handler.js
/**
 * WordPress dependencies
 */



/**
 * Internal dependencies
 */



/**
 * Selects the block if it receives focus.
 *
 * @param {string} clientId Block client ID.
 */
function useFocusHandler(clientId) {
  const {
    isBlockSelected
  } = (0,external_wp_data_namespaceObject.useSelect)(store);
  const {
    selectBlock,
    selectionChange
  } = (0,external_wp_data_namespaceObject.useDispatch)(store);
  return (0,external_wp_compose_namespaceObject.useRefEffect)(node =&gt; {
    /**
     * Marks the block as selected when focused and not already
     * selected. This specifically handles the case where block does not
     * set focus on its own (via `setFocus`), typically if there is no
     * focusable input in the block.
     *
     * @param {FocusEvent} event Focus event.
     */
    function onFocus(event) {
      // When the whole editor is editable, let writing flow handle
      // selection.
      if (node.parentElement.closest(&#039;[contenteditable=&quot;true&quot;]&#039;)) {
        return;
      }

      // Check synchronously because a non-selected block might be
      // getting data through `useSelect` asynchronously.
      if (isBlockSelected(clientId)) {
        // Potentially change selection away from rich text.
        if (!event.target.isContentEditable) {
          selectionChange(clientId);
        }
        return;
      }

      // If an inner block is focussed, that block is responsible for
      // setting the selected block.
      if (!isInsideRootBlock(node, event.target)) {
        return;
      }
      selectBlock(clientId);
    }
    node.addEventListener(&#039;focusin&#039;, onFocus);
    return () =&gt; {
      node.removeEventListener(&#039;focusin&#039;, onFocus);
    };
  }, [isBlockSelected, selectBlock]);
}

;// ./node_modules/@wordpress/icons/build-module/library/drag-handle.js
/**
 * WordPress dependencies
 */


const dragHandle = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  width: &quot;24&quot;,
  height: &quot;24&quot;,
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;M8 7h2V5H8v2zm0 6h2v-2H8v2zm0 6h2v-2H8v2zm6-14v2h2V5h-2zm0 8h2v-2h-2v2zm0 6h2v-2h-2v2z&quot;
  })
});
/* harmony default export */ const drag_handle = (dragHandle);

;// ./node_modules/@wordpress/block-editor/build-module/components/block-draggable/draggable-chip.js
/**
 * WordPress dependencies
 */




/**
 * Internal dependencies
 */


function BlockDraggableChip({
  count,
  icon,
  isPattern,
  fadeWhenDisabled
}) {
  const patternLabel = isPattern &amp;&amp; (0,external_wp_i18n_namespaceObject.__)(&#039;Pattern&#039;);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
    className: &quot;block-editor-block-draggable-chip-wrapper&quot;,
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
      className: &quot;block-editor-block-draggable-chip&quot;,
      &quot;data-testid&quot;: &quot;block-draggable-chip&quot;,
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.Flex, {
        justify: &quot;center&quot;,
        className: &quot;block-editor-block-draggable-chip__content&quot;,
        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FlexItem, {
          children: icon ? /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_icon, {
            icon: icon
          }) : patternLabel || (0,external_wp_i18n_namespaceObject.sprintf)(/* translators: %d: Number of blocks. */
          (0,external_wp_i18n_namespaceObject._n)(&#039;%d block&#039;, &#039;%d blocks&#039;, count), count)
        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FlexItem, {
          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_icon, {
            icon: drag_handle
          })
        }), fadeWhenDisabled &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FlexItem, {
          className: &quot;block-editor-block-draggable-chip__disabled&quot;,
          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;span&quot;, {
            className: &quot;block-editor-block-draggable-chip__disabled-icon&quot;
          })
        })]
      })
    })
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/block-list/use-block-props/use-selected-block-event-handlers.js
/**
 * WordPress dependencies
 */







/**
 * Internal dependencies
 */




/**
 * Adds block behaviour:
 *   - Removes the block on BACKSPACE.
 *   - Inserts a default block on ENTER.
 *   - Disables dragging of block contents.
 *
 * @param {string} clientId Block client ID.
 */

function useEventHandlers({
  clientId,
  isSelected
}) {
  const {
    getBlockType
  } = (0,external_wp_data_namespaceObject.useSelect)(external_wp_blocks_namespaceObject.store);
  const {
    getBlockRootClientId,
    isZoomOut,
    hasMultiSelection,
    getBlockName
  } = unlock((0,external_wp_data_namespaceObject.useSelect)(store));
  const {
    insertAfterBlock,
    removeBlock,
    resetZoomLevel,
    startDraggingBlocks,
    stopDraggingBlocks
  } = unlock((0,external_wp_data_namespaceObject.useDispatch)(store));
  return (0,external_wp_compose_namespaceObject.useRefEffect)(node =&gt; {
    if (!isSelected) {
      return;
    }

    /**
     * Interprets keydown event intent to remove or insert after block if
     * key event occurs on wrapper node. This can occur when the block has
     * no text fields of its own, particularly after initial insertion, to
     * allow for easy deletion and continuous writing flow to add additional
     * content.
     *
     * @param {KeyboardEvent} event Keydown event.
     */
    function onKeyDown(event) {
      const {
        keyCode,
        target
      } = event;
      if (keyCode !== external_wp_keycodes_namespaceObject.ENTER &amp;&amp; keyCode !== external_wp_keycodes_namespaceObject.BACKSPACE &amp;&amp; keyCode !== external_wp_keycodes_namespaceObject.DELETE) {
        return;
      }
      if (target !== node || (0,external_wp_dom_namespaceObject.isTextField)(target)) {
        return;
      }
      event.preventDefault();
      if (keyCode === external_wp_keycodes_namespaceObject.ENTER &amp;&amp; isZoomOut()) {
        resetZoomLevel();
      } else if (keyCode === external_wp_keycodes_namespaceObject.ENTER) {
        insertAfterBlock(clientId);
      } else {
        removeBlock(clientId);
      }
    }

    /**
     * Prevents default dragging behavior within a block. To do: we must
     * handle this in the future and clean up the drag target.
     *
     * @param {DragEvent} event Drag event.
     */
    function onDragStart(event) {
      if (node !== event.target || node.isContentEditable || node.ownerDocument.activeElement !== node || hasMultiSelection()) {
        event.preventDefault();
        return;
      }
      const data = JSON.stringify({
        type: &#039;block&#039;,
        srcClientIds: [clientId],
        srcRootClientId: getBlockRootClientId(clientId)
      });
      event.dataTransfer.effectAllowed = &#039;move&#039;; // remove &quot;+&quot; cursor
      event.dataTransfer.clearData();
      event.dataTransfer.setData(&#039;wp-blocks&#039;, data);
      const {
        ownerDocument
      } = node;
      const {
        defaultView
      } = ownerDocument;
      const selection = defaultView.getSelection();
      selection.removeAllRanges();
      const domNode = document.createElement(&#039;div&#039;);
      const root = (0,external_wp_element_namespaceObject.createRoot)(domNode);
      root.render(/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockDraggableChip, {
        icon: getBlockType(getBlockName(clientId)).icon
      }));
      document.body.appendChild(domNode);
      domNode.style.position = &#039;absolute&#039;;
      domNode.style.top = &#039;0&#039;;
      domNode.style.left = &#039;0&#039;;
      domNode.style.zIndex = &#039;1000&#039;;
      domNode.style.pointerEvents = &#039;none&#039;;

      // Setting the drag chip as the drag image actually works, but
      // the behaviour is slightly different in every browser. In
      // Safari, it animates, in Firefox it&#039;s slightly transparent...
      // So we set a fake drag image and have to reposition it
      // ourselves.
      const dragElement = ownerDocument.createElement(&#039;div&#039;);
      // Chrome will show a globe icon if the drag element does not
      // have dimensions.
      dragElement.style.width = &#039;1px&#039;;
      dragElement.style.height = &#039;1px&#039;;
      dragElement.style.position = &#039;fixed&#039;;
      dragElement.style.visibility = &#039;hidden&#039;;
      ownerDocument.body.appendChild(dragElement);
      event.dataTransfer.setDragImage(dragElement, 0, 0);
      let offset = {
        x: 0,
        y: 0
      };
      if (document !== ownerDocument) {
        const frame = defaultView.frameElement;
        if (frame) {
          const rect = frame.getBoundingClientRect();
          offset = {
            x: rect.left,
            y: rect.top
          };
        }
      }

      // chip handle offset
      offset.x -= 58;
      function over(e) {
        domNode.style.transform = `translate( ${e.clientX + offset.x}px, ${e.clientY + offset.y}px )`;
      }
      over(event);
      function end() {
        ownerDocument.removeEventListener(&#039;dragover&#039;, over);
        ownerDocument.removeEventListener(&#039;dragend&#039;, end);
        domNode.remove();
        dragElement.remove();
        stopDraggingBlocks();
        document.body.classList.remove(&#039;is-dragging-components-draggable&#039;);
        ownerDocument.documentElement.classList.remove(&#039;is-dragging&#039;);
      }
      ownerDocument.addEventListener(&#039;dragover&#039;, over);
      ownerDocument.addEventListener(&#039;dragend&#039;, end);
      ownerDocument.addEventListener(&#039;drop&#039;, end);
      startDraggingBlocks([clientId]);
      // Important because it hides the block toolbar.
      document.body.classList.add(&#039;is-dragging-components-draggable&#039;);
      ownerDocument.documentElement.classList.add(&#039;is-dragging&#039;);
    }
    node.addEventListener(&#039;keydown&#039;, onKeyDown);
    node.addEventListener(&#039;dragstart&#039;, onDragStart);
    return () =&gt; {
      node.removeEventListener(&#039;keydown&#039;, onKeyDown);
      node.removeEventListener(&#039;dragstart&#039;, onDragStart);
    };
  }, [clientId, isSelected, getBlockRootClientId, insertAfterBlock, removeBlock, isZoomOut, resetZoomLevel, hasMultiSelection, startDraggingBlocks, stopDraggingBlocks]);
}

;// ./node_modules/@wordpress/block-editor/build-module/components/block-list/use-block-props/use-intersection-observer.js
/**
 * WordPress dependencies
 */



/**
 * Internal dependencies
 */

function useIntersectionObserver() {
  const observer = (0,external_wp_element_namespaceObject.useContext)(block_list_IntersectionObserver);
  return (0,external_wp_compose_namespaceObject.useRefEffect)(node =&gt; {
    if (observer) {
      observer.observe(node);
      return () =&gt; {
        observer.unobserve(node);
      };
    }
  }, [observer]);
}

;// ./node_modules/@wordpress/block-editor/build-module/components/block-list/use-block-props/use-scroll-into-view.js
/**
 * WordPress dependencies
 */

function useScrollIntoView({
  isSelected
}) {
  const prefersReducedMotion = (0,external_wp_compose_namespaceObject.useReducedMotion)();
  return (0,external_wp_compose_namespaceObject.useRefEffect)(node =&gt; {
    if (isSelected) {
      const {
        ownerDocument
      } = node;
      const {
        defaultView
      } = ownerDocument;
      if (!defaultView.IntersectionObserver) {
        return;
      }
      const observer = new defaultView.IntersectionObserver(entries =&gt; {
        // Once observing starts, we always get an initial
        // entry with the intersecting state.
        if (!entries[0].isIntersecting) {
          node.scrollIntoView({
            behavior: prefersReducedMotion ? &#039;instant&#039; : &#039;smooth&#039;
          });
        }
        observer.disconnect();
      });
      observer.observe(node);
      return () =&gt; {
        observer.disconnect();
      };
    }
  }, [isSelected]);
}

;// ./node_modules/@wordpress/block-editor/build-module/components/use-flash-editable-blocks/index.js
/**
 * WordPress dependencies
 */



/**
 * Internal dependencies
 */


function useFlashEditableBlocks({
  clientId = &#039;&#039;,
  isEnabled = true
} = {}) {
  const {
    getEnabledClientIdsTree
  } = unlock((0,external_wp_data_namespaceObject.useSelect)(store));
  return (0,external_wp_compose_namespaceObject.useRefEffect)(element =&gt; {
    if (!isEnabled) {
      return;
    }
    const flashEditableBlocks = () =&gt; {
      getEnabledClientIdsTree(clientId).forEach(({
        clientId: id
      }) =&gt; {
        const block = element.querySelector(`[data-block=&quot;${id}&quot;]`);
        if (!block) {
          return;
        }
        block.classList.remove(&#039;has-editable-outline&#039;);
        // Force reflow to trigger the animation.
        // eslint-disable-next-line no-unused-expressions
        block.offsetWidth;
        block.classList.add(&#039;has-editable-outline&#039;);
      });
    };
    const handleClick = event =&gt; {
      const shouldFlash = event.target === element || event.target.classList.contains(&#039;is-root-container&#039;);
      if (!shouldFlash) {
        return;
      }
      if (event.defaultPrevented) {
        return;
      }
      event.preventDefault();
      flashEditableBlocks();
    };
    element.addEventListener(&#039;click&#039;, handleClick);
    return () =&gt; element.removeEventListener(&#039;click&#039;, handleClick);
  }, [isEnabled]);
}

;// ./node_modules/@wordpress/block-editor/build-module/components/block-list/use-block-props/use-firefox-draggable-compatibility.js
/**
 * WordPress dependencies
 */

const nodesByDocument = new Map();
function add(doc, node) {
  let set = nodesByDocument.get(doc);
  if (!set) {
    set = new Set();
    nodesByDocument.set(doc, set);
    doc.addEventListener(&#039;pointerdown&#039;, down);
  }
  set.add(node);
}
function remove(doc, node) {
  const set = nodesByDocument.get(doc);
  if (set) {
    set.delete(node);
    restore(node);
    if (set.size === 0) {
      nodesByDocument.delete(doc);
      doc.removeEventListener(&#039;pointerdown&#039;, down);
    }
  }
}
function restore(node) {
  const prevDraggable = node.getAttribute(&#039;data-draggable&#039;);
  if (prevDraggable) {
    node.removeAttribute(&#039;data-draggable&#039;);
    // Only restore if `draggable` is still removed. It could have been
    // changed by React in the meantime.
    if (prevDraggable === &#039;true&#039; &amp;&amp; !node.getAttribute(&#039;draggable&#039;)) {
      node.setAttribute(&#039;draggable&#039;, &#039;true&#039;);
    }
  }
}
function down(event) {
  const {
    target
  } = event;
  const {
    ownerDocument,
    isContentEditable,
    tagName
  } = target;
  const isInputOrTextArea = [&#039;INPUT&#039;, &#039;TEXTAREA&#039;].includes(tagName);
  const nodes = nodesByDocument.get(ownerDocument);
  if (isContentEditable || isInputOrTextArea) {
    // Whenever an editable element or an input or textarea is clicked,
    // check which draggable blocks contain this element, and temporarily
    // disable draggability.
    for (const node of nodes) {
      if (node.getAttribute(&#039;draggable&#039;) === &#039;true&#039; &amp;&amp; node.contains(target)) {
        node.removeAttribute(&#039;draggable&#039;);
        node.setAttribute(&#039;data-draggable&#039;, &#039;true&#039;);
      }
    }
  } else {
    // Whenever a non-editable element or an input or textarea is clicked,
    // re-enable draggability for any blocks that were previously disabled.
    for (const node of nodes) {
      restore(node);
    }
  }
}

/**
 * In Firefox, the `draggable` and `contenteditable` or `input` or `textarea`
 * elements don&#039;t play well together. When these elements are within a
 * `draggable` element, selection doesn&#039;t get set in the right place. The only
 * solution is to temporarily remove the `draggable` attribute clicking inside
 * these elements.
 * @return {Function} Cleanup function.
 */
function useFirefoxDraggableCompatibility() {
  return (0,external_wp_compose_namespaceObject.useRefEffect)(node =&gt; {
    add(node.ownerDocument, node);
    return () =&gt; {
      remove(node.ownerDocument, node);
    };
  }, []);
}

;// ./node_modules/@wordpress/block-editor/build-module/components/block-list/use-block-props/index.js
/**
 * External dependencies
 */


/**
 * WordPress dependencies
 */






/**
 * Internal dependencies
 */














/**
 * This hook is used to lightly mark an element as a block element. The element
 * should be the outermost element of a block. Call this hook and pass the
 * returned props to the element to mark as a block. If you define a ref for the
 * element, it is important to pass the ref to this hook, which the hook in turn
 * will pass to the component through the props it returns. Optionally, you can
 * also pass any other props through this hook, and they will be merged and
 * returned.
 *
 * Use of this hook on the outermost element of a block is required if using API &gt;= v2.
 *
 * @example
 * ```js
 * import { useBlockProps } from &#039;@wordpress/block-editor&#039;;
 *
 * export default function Edit() {
 *
 *   const blockProps = useBlockProps( {
 *     className: &#039;my-custom-class&#039;,
 *     style: {
 *       color: &#039;#222222&#039;,
 *       backgroundColor: &#039;#eeeeee&#039;
 *     }
 *   } )
 *
 *   return (
 *	    &lt;div { ...blockProps }&gt;
 *
 *     &lt;/div&gt;
 *   )
 * }
 *
 * ```
 *
 *
 * @param {Object}  props                    Optional. Props to pass to the element. Must contain
 *                                           the ref if one is defined.
 * @param {Object}  options                  Options for internal use only.
 * @param {boolean} options.__unstableIsHtml
 *
 * @return {Object} Props to pass to the element to mark as a block.
 */
function use_block_props_useBlockProps(props = {}, {
  __unstableIsHtml
} = {}) {
  const {
    clientId,
    className,
    wrapperProps = {},
    isAligned,
    index,
    mode,
    name,
    blockApiVersion,
    blockTitle,
    isSelected,
    isSubtreeDisabled,
    hasOverlay,
    initialPosition,
    blockEditingMode,
    isHighlighted,
    isMultiSelected,
    isPartiallySelected,
    isReusable,
    isDragging,
    hasChildSelected,
    isEditingDisabled,
    hasEditableOutline,
    isTemporarilyEditingAsBlocks,
    defaultClassName,
    isSectionBlock,
    canMove
  } = (0,external_wp_element_namespaceObject.useContext)(PrivateBlockContext);

  // translators: %s: Type of block (i.e. Text, Image etc)
  const blockLabel = (0,external_wp_i18n_namespaceObject.sprintf)((0,external_wp_i18n_namespaceObject.__)(&#039;Block: %s&#039;), blockTitle);
  const htmlSuffix = mode === &#039;html&#039; &amp;&amp; !__unstableIsHtml ? &#039;-visual&#039; : &#039;&#039;;
  const ffDragRef = useFirefoxDraggableCompatibility();
  const mergedRefs = (0,external_wp_compose_namespaceObject.useMergeRefs)([props.ref, useFocusFirstElement({
    clientId,
    initialPosition
  }), useBlockRefProvider(clientId), useFocusHandler(clientId), useEventHandlers({
    clientId,
    isSelected
  }), useIsHovered({
    clientId
  }), useIntersectionObserver(), use_moving_animation({
    triggerAnimationOnChange: index,
    clientId
  }), (0,external_wp_compose_namespaceObject.useDisabled)({
    isDisabled: !hasOverlay
  }), useFlashEditableBlocks({
    clientId,
    isEnabled: isSectionBlock
  }), useScrollIntoView({
    isSelected
  }), canMove ? ffDragRef : undefined]);
  const blockEditContext = useBlockEditContext();
  const hasBlockBindings = !!blockEditContext[blockBindingsKey];
  const bindingsStyle = hasBlockBindings &amp;&amp; canBindBlock(name) ? {
    &#039;--wp-admin-theme-color&#039;: &#039;var(--wp-block-synced-color)&#039;,
    &#039;--wp-admin-theme-color--rgb&#039;: &#039;var(--wp-block-synced-color--rgb)&#039;
  } : {};

  // Ensures it warns only inside the `edit` implementation for the block.
  if (blockApiVersion &lt; 2 &amp;&amp; clientId === blockEditContext.clientId) {
     true ? external_wp_warning_default()(`Block type &quot;${name}&quot; must support API version 2 or higher to work correctly with &quot;useBlockProps&quot; method.`) : 0;
  }
  let hasNegativeMargin = false;
  if (wrapperProps?.style?.marginTop?.charAt(0) === &#039;-&#039; || wrapperProps?.style?.marginBottom?.charAt(0) === &#039;-&#039; || wrapperProps?.style?.marginLeft?.charAt(0) === &#039;-&#039; || wrapperProps?.style?.marginRight?.charAt(0) === &#039;-&#039;) {
    hasNegativeMargin = true;
  }
  return {
    tabIndex: blockEditingMode === &#039;disabled&#039; ? -1 : 0,
    draggable: canMove &amp;&amp; !hasChildSelected ? true : undefined,
    ...wrapperProps,
    ...props,
    ref: mergedRefs,
    id: `block-${clientId}${htmlSuffix}`,
    role: &#039;document&#039;,
    &#039;aria-label&#039;: blockLabel,
    &#039;data-block&#039;: clientId,
    &#039;data-type&#039;: name,
    &#039;data-title&#039;: blockTitle,
    inert: isSubtreeDisabled ? &#039;true&#039; : undefined,
    className: dist_clsx(&#039;block-editor-block-list__block&#039;, {
      // The wp-block className is important for editor styles.
      &#039;wp-block&#039;: !isAligned,
      &#039;has-block-overlay&#039;: hasOverlay,
      &#039;is-selected&#039;: isSelected,
      &#039;is-highlighted&#039;: isHighlighted,
      &#039;is-multi-selected&#039;: isMultiSelected,
      &#039;is-partially-selected&#039;: isPartiallySelected,
      &#039;is-reusable&#039;: isReusable,
      &#039;is-dragging&#039;: isDragging,
      &#039;has-child-selected&#039;: hasChildSelected,
      &#039;is-editing-disabled&#039;: isEditingDisabled,
      &#039;has-editable-outline&#039;: hasEditableOutline,
      &#039;has-negative-margin&#039;: hasNegativeMargin,
      &#039;is-content-locked-temporarily-editing-as-blocks&#039;: isTemporarilyEditingAsBlocks
    }, className, props.className, wrapperProps.className, defaultClassName),
    style: {
      ...wrapperProps.style,
      ...props.style,
      ...bindingsStyle
    }
  };
}

/**
 * Call within a save function to get the props for the block wrapper.
 *
 * @param {Object} props Optional. Props to pass to the element.
 */
use_block_props_useBlockProps.save = external_wp_blocks_namespaceObject.__unstableGetBlockProps;

;// ./node_modules/@wordpress/block-editor/build-module/components/block-list/block.js
/**
 * External dependencies
 */


/**
 * WordPress dependencies
 */







/**
 * Internal dependencies
 */











/**
 * Merges wrapper props with special handling for classNames and styles.
 *
 * @param {Object} propsA
 * @param {Object} propsB
 *
 * @return {Object} Merged props.
 */

function mergeWrapperProps(propsA, propsB) {
  const newProps = {
    ...propsA,
    ...propsB
  };

  // May be set to undefined, so check if the property is set!
  if (propsA?.hasOwnProperty(&#039;className&#039;) &amp;&amp; propsB?.hasOwnProperty(&#039;className&#039;)) {
    newProps.className = dist_clsx(propsA.className, propsB.className);
  }
  if (propsA?.hasOwnProperty(&#039;style&#039;) &amp;&amp; propsB?.hasOwnProperty(&#039;style&#039;)) {
    newProps.style = {
      ...propsA.style,
      ...propsB.style
    };
  }
  return newProps;
}
function Block({
  children,
  isHtml,
  ...props
}) {
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
    ...use_block_props_useBlockProps(props, {
      __unstableIsHtml: isHtml
    }),
    children: children
  });
}
function BlockListBlock({
  block: {
    __unstableBlockSource
  },
  mode,
  isLocked,
  canRemove,
  clientId,
  isSelected,
  isSelectionEnabled,
  className,
  __unstableLayoutClassNames: layoutClassNames,
  name,
  isValid,
  attributes,
  wrapperProps,
  setAttributes,
  onReplace,
  onRemove,
  onInsertBlocksAfter,
  onMerge,
  toggleSelection
}) {
  var _wrapperProps;
  const {
    mayDisplayControls,
    mayDisplayParentControls,
    themeSupportsLayout,
    ...context
  } = (0,external_wp_element_namespaceObject.useContext)(PrivateBlockContext);
  const parentLayout = useLayout() || {};

  // We wrap the BlockEdit component in a div that hides it when editing in
  // HTML mode. This allows us to render all of the ancillary pieces
  // (InspectorControls, etc.) which are inside `BlockEdit` but not
  // `BlockHTML`, even in HTML mode.
  let blockEdit = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockEdit, {
    name: name,
    isSelected: isSelected,
    attributes: attributes,
    setAttributes: setAttributes,
    insertBlocksAfter: isLocked ? undefined : onInsertBlocksAfter,
    onReplace: canRemove ? onReplace : undefined,
    onRemove: canRemove ? onRemove : undefined,
    mergeBlocks: canRemove ? onMerge : undefined,
    clientId: clientId,
    isSelectionEnabled: isSelectionEnabled,
    toggleSelection: toggleSelection,
    __unstableLayoutClassNames: layoutClassNames,
    __unstableParentLayout: Object.keys(parentLayout).length ? parentLayout : undefined,
    mayDisplayControls: mayDisplayControls,
    mayDisplayParentControls: mayDisplayParentControls,
    blockEditingMode: context.blockEditingMode,
    isPreviewMode: context.isPreviewMode
  });
  const blockType = (0,external_wp_blocks_namespaceObject.getBlockType)(name);

  // Determine whether the block has props to apply to the wrapper.
  if (blockType?.getEditWrapperProps) {
    wrapperProps = mergeWrapperProps(wrapperProps, blockType.getEditWrapperProps(attributes));
  }
  const isAligned = wrapperProps &amp;&amp; !!wrapperProps[&#039;data-align&#039;] &amp;&amp; !themeSupportsLayout;

  // Support for sticky position in classic themes with alignment wrappers.

  const isSticky = className?.includes(&#039;is-position-sticky&#039;);

  // For aligned blocks, provide a wrapper element so the block can be
  // positioned relative to the block column.
  // This is only kept for classic themes that don&#039;t support layout
  // Historically we used to rely on extra divs and data-align to
  // provide the alignments styles in the editor.
  // Due to the differences between frontend and backend, we migrated
  // to the layout feature, and we&#039;re now aligning the markup of frontend
  // and backend.
  if (isAligned) {
    blockEdit = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
      className: dist_clsx(&#039;wp-block&#039;, isSticky &amp;&amp; className),
      &quot;data-align&quot;: wrapperProps[&#039;data-align&#039;],
      children: blockEdit
    });
  }
  let block;
  if (!isValid) {
    const saveContent = __unstableBlockSource ? (0,external_wp_blocks_namespaceObject.serializeRawBlock)(__unstableBlockSource) : (0,external_wp_blocks_namespaceObject.getSaveContent)(blockType, attributes);
    block = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(Block, {
      className: &quot;has-warning&quot;,
      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockInvalidWarning, {
        clientId: clientId
      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_element_namespaceObject.RawHTML, {
        children: (0,external_wp_dom_namespaceObject.safeHTML)(saveContent)
      })]
    });
  } else if (mode === &#039;html&#039;) {
    // Render blockEdit so the inspector controls don&#039;t disappear.
    // See #8969.
    block = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
        style: {
          display: &#039;none&#039;
        },
        children: blockEdit
      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Block, {
        isHtml: true,
        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_html, {
          clientId: clientId
        })
      })]
    });
  } else if (blockType?.apiVersion &gt; 1) {
    block = blockEdit;
  } else {
    block = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Block, {
      children: blockEdit
    });
  }
  const {
    &#039;data-align&#039;: dataAlign,
    ...restWrapperProps
  } = (_wrapperProps = wrapperProps) !== null &amp;&amp; _wrapperProps !== void 0 ? _wrapperProps : {};
  const updatedWrapperProps = {
    ...restWrapperProps,
    className: dist_clsx(restWrapperProps.className, dataAlign &amp;&amp; themeSupportsLayout &amp;&amp; `align${dataAlign}`, !(dataAlign &amp;&amp; isSticky) &amp;&amp; className)
  };

  // We set a new context with the adjusted and filtered wrapperProps (through
  // `editor.BlockListBlock`), which the `BlockListBlockProvider` did not have
  // access to.
  // Note that the context value doesn&#039;t have to be memoized in this case
  // because when it changes, this component will be re-rendered anyway, and
  // none of the consumers (BlockListBlock and useBlockProps) are memoized or
  // &quot;pure&quot;. This is different from the public BlockEditContext, where
  // consumers might be memoized or &quot;pure&quot;.
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PrivateBlockContext.Provider, {
    value: {
      wrapperProps: updatedWrapperProps,
      isAligned,
      ...context
    },
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_crash_boundary, {
      fallback: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Block, {
        className: &quot;has-warning&quot;,
        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_crash_warning, {})
      }),
      children: block
    })
  });
}
const applyWithDispatch = (0,external_wp_data_namespaceObject.withDispatch)((dispatch, ownProps, registry) =&gt; {
  const {
    updateBlockAttributes,
    insertBlocks,
    mergeBlocks,
    replaceBlocks,
    toggleSelection,
    __unstableMarkLastChangeAsPersistent,
    moveBlocksToPosition,
    removeBlock,
    selectBlock
  } = dispatch(store);

  // Do not add new properties here, use `useDispatch` instead to avoid
  // leaking new props to the public API (editor.BlockListBlock filter).
  return {
    setAttributes(newAttributes) {
      const {
        getMultiSelectedBlockClientIds
      } = registry.select(store);
      const multiSelectedBlockClientIds = getMultiSelectedBlockClientIds();
      const {
        clientId
      } = ownProps;
      const clientIds = multiSelectedBlockClientIds.length ? multiSelectedBlockClientIds : [clientId];
      updateBlockAttributes(clientIds, newAttributes);
    },
    onInsertBlocks(blocks, index) {
      const {
        rootClientId
      } = ownProps;
      insertBlocks(blocks, index, rootClientId);
    },
    onInsertBlocksAfter(blocks) {
      const {
        clientId,
        rootClientId
      } = ownProps;
      const {
        getBlockIndex
      } = registry.select(store);
      const index = getBlockIndex(clientId);
      insertBlocks(blocks, index + 1, rootClientId);
    },
    onMerge(forward) {
      const {
        clientId,
        rootClientId
      } = ownProps;
      const {
        getPreviousBlockClientId,
        getNextBlockClientId,
        getBlock,
        getBlockAttributes,
        getBlockName,
        getBlockOrder,
        getBlockIndex,
        getBlockRootClientId,
        canInsertBlockType
      } = registry.select(store);
      function switchToDefaultOrRemove() {
        const block = getBlock(clientId);
        const defaultBlockName = (0,external_wp_blocks_namespaceObject.getDefaultBlockName)();
        const defaultBlockType = (0,external_wp_blocks_namespaceObject.getBlockType)(defaultBlockName);
        if (getBlockName(clientId) !== defaultBlockName) {
          const replacement = (0,external_wp_blocks_namespaceObject.switchToBlockType)(block, defaultBlockName);
          if (replacement &amp;&amp; replacement.length) {
            replaceBlocks(clientId, replacement);
          }
        } else if ((0,external_wp_blocks_namespaceObject.isUnmodifiedDefaultBlock)(block)) {
          const nextBlockClientId = getNextBlockClientId(clientId);
          if (nextBlockClientId) {
            registry.batch(() =&gt; {
              removeBlock(clientId);
              selectBlock(nextBlockClientId);
            });
          }
        } else if (defaultBlockType.merge) {
          const attributes = defaultBlockType.merge({}, block.attributes);
          replaceBlocks([clientId], [(0,external_wp_blocks_namespaceObject.createBlock)(defaultBlockName, attributes)]);
        }
      }

      /**
       * Moves the block with clientId up one level. If the block type
       * cannot be inserted at the new location, it will be attempted to
       * convert to the default block type.
       *
       * @param {string}  _clientId       The block to move.
       * @param {boolean} changeSelection Whether to change the selection
       *                                  to the moved block.
       */
      function moveFirstItemUp(_clientId, changeSelection = true) {
        const wrapperBlockName = getBlockName(_clientId);
        const wrapperBlockType = (0,external_wp_blocks_namespaceObject.getBlockType)(wrapperBlockName);
        const isTextualWrapper = wrapperBlockType.category === &#039;text&#039;;
        const targetRootClientId = getBlockRootClientId(_clientId);
        const blockOrder = getBlockOrder(_clientId);
        const [firstClientId] = blockOrder;
        if (blockOrder.length === 1 &amp;&amp; (0,external_wp_blocks_namespaceObject.isUnmodifiedBlock)(getBlock(firstClientId))) {
          removeBlock(_clientId);
        } else if (isTextualWrapper) {
          registry.batch(() =&gt; {
            if (canInsertBlockType(getBlockName(firstClientId), targetRootClientId)) {
              moveBlocksToPosition([firstClientId], _clientId, targetRootClientId, getBlockIndex(_clientId));
            } else {
              const replacement = (0,external_wp_blocks_namespaceObject.switchToBlockType)(getBlock(firstClientId), (0,external_wp_blocks_namespaceObject.getDefaultBlockName)());
              if (replacement &amp;&amp; replacement.length &amp;&amp; replacement.every(block =&gt; canInsertBlockType(block.name, targetRootClientId))) {
                insertBlocks(replacement, getBlockIndex(_clientId), targetRootClientId, changeSelection);
                removeBlock(firstClientId, false);
              } else {
                switchToDefaultOrRemove();
              }
            }
            if (!getBlockOrder(_clientId).length &amp;&amp; (0,external_wp_blocks_namespaceObject.isUnmodifiedBlock)(getBlock(_clientId))) {
              removeBlock(_clientId, false);
            }
          });
        } else {
          switchToDefaultOrRemove();
        }
      }

      // For `Delete` or forward merge, we should do the exact same thing
      // as `Backspace`, but from the other block.
      if (forward) {
        if (rootClientId) {
          const nextRootClientId = getNextBlockClientId(rootClientId);
          if (nextRootClientId) {
            // If there is a block that follows with the same parent
            // block name and the same attributes, merge the inner
            // blocks.
            if (getBlockName(rootClientId) === getBlockName(nextRootClientId)) {
              const rootAttributes = getBlockAttributes(rootClientId);
              const previousRootAttributes = getBlockAttributes(nextRootClientId);
              if (Object.keys(rootAttributes).every(key =&gt; rootAttributes[key] === previousRootAttributes[key])) {
                registry.batch(() =&gt; {
                  moveBlocksToPosition(getBlockOrder(nextRootClientId), nextRootClientId, rootClientId);
                  removeBlock(nextRootClientId, false);
                });
                return;
              }
            } else {
              mergeBlocks(rootClientId, nextRootClientId);
              return;
            }
          }
        }
        const nextBlockClientId = getNextBlockClientId(clientId);
        if (!nextBlockClientId) {
          return;
        }
        if (getBlockOrder(nextBlockClientId).length) {
          moveFirstItemUp(nextBlockClientId, false);
        } else {
          mergeBlocks(clientId, nextBlockClientId);
        }
      } else {
        const previousBlockClientId = getPreviousBlockClientId(clientId);
        if (previousBlockClientId) {
          mergeBlocks(previousBlockClientId, clientId);
        } else if (rootClientId) {
          const previousRootClientId = getPreviousBlockClientId(rootClientId);

          // If there is a preceding block with the same parent block
          // name and the same attributes, merge the inner blocks.
          if (previousRootClientId &amp;&amp; getBlockName(rootClientId) === getBlockName(previousRootClientId)) {
            const rootAttributes = getBlockAttributes(rootClientId);
            const previousRootAttributes = getBlockAttributes(previousRootClientId);
            if (Object.keys(rootAttributes).every(key =&gt; rootAttributes[key] === previousRootAttributes[key])) {
              registry.batch(() =&gt; {
                moveBlocksToPosition(getBlockOrder(rootClientId), rootClientId, previousRootClientId);
                removeBlock(rootClientId, false);
              });
              return;
            }
          }
          moveFirstItemUp(rootClientId);
        } else {
          switchToDefaultOrRemove();
        }
      }
    },
    onReplace(blocks, indexToSelect, initialPosition) {
      if (blocks.length &amp;&amp; !(0,external_wp_blocks_namespaceObject.isUnmodifiedDefaultBlock)(blocks[blocks.length - 1])) {
        __unstableMarkLastChangeAsPersistent();
      }
      //Unsynced patterns are nested in an array so we need to flatten them.
      const replacementBlocks = blocks?.length === 1 &amp;&amp; Array.isArray(blocks[0]) ? blocks[0] : blocks;
      replaceBlocks([ownProps.clientId], replacementBlocks, indexToSelect, initialPosition);
    },
    onRemove() {
      removeBlock(ownProps.clientId);
    },
    toggleSelection(selectionEnabled) {
      toggleSelection(selectionEnabled);
    }
  };
});

// This component is used by the BlockListBlockProvider component below. It will
// add the props necessary for the `editor.BlockListBlock` filters.
BlockListBlock = (0,external_wp_compose_namespaceObject.compose)(applyWithDispatch, (0,external_wp_components_namespaceObject.withFilters)(&#039;editor.BlockListBlock&#039;))(BlockListBlock);

// This component provides all the information we need through a single store
// subscription (useSelect mapping). Only the necessary props are passed down
// to the BlockListBlock component, which is a filtered component, so these
// props are public API. To avoid adding to the public API, we use a private
// context to pass the rest of the information to the filtered BlockListBlock
// component, and useBlockProps.
function BlockListBlockProvider(props) {
  const {
    clientId,
    rootClientId
  } = props;
  const selectedProps = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      isBlockSelected,
      getBlockMode,
      isSelectionEnabled,
      getTemplateLock,
      isSectionBlock: _isSectionBlock,
      getBlockWithoutAttributes,
      getBlockAttributes,
      canRemoveBlock,
      canMoveBlock,
      getSettings,
      getTemporarilyEditingAsBlocks,
      getBlockEditingMode,
      getBlockName,
      isFirstMultiSelectedBlock,
      getMultiSelectedBlockClientIds,
      hasSelectedInnerBlock,
      getBlocksByName,
      getBlockIndex,
      isBlockMultiSelected,
      isBlockSubtreeDisabled,
      isBlockHighlighted,
      __unstableIsFullySelected,
      __unstableSelectionHasUnmergeableBlock,
      isBlockBeingDragged,
      isDragging,
      __unstableHasActiveBlockOverlayActive,
      getSelectedBlocksInitialCaretPosition
    } = unlock(select(store));
    const blockWithoutAttributes = getBlockWithoutAttributes(clientId);

    // This is a temporary fix.
    // This function should never be called when a block is not
    // present in the state. It happens now because the order in
    // withSelect rendering is not correct.
    if (!blockWithoutAttributes) {
      return;
    }
    const {
      hasBlockSupport: _hasBlockSupport,
      getActiveBlockVariation
    } = select(external_wp_blocks_namespaceObject.store);
    const attributes = getBlockAttributes(clientId);
    const {
      name: blockName,
      isValid
    } = blockWithoutAttributes;
    const blockType = (0,external_wp_blocks_namespaceObject.getBlockType)(blockName);
    const {
      supportsLayout,
      isPreviewMode
    } = getSettings();
    const hasLightBlockWrapper = blockType?.apiVersion &gt; 1;
    const previewContext = {
      isPreviewMode,
      blockWithoutAttributes,
      name: blockName,
      attributes,
      isValid,
      themeSupportsLayout: supportsLayout,
      index: getBlockIndex(clientId),
      isReusable: (0,external_wp_blocks_namespaceObject.isReusableBlock)(blockType),
      className: hasLightBlockWrapper ? attributes.className : undefined,
      defaultClassName: hasLightBlockWrapper ? (0,external_wp_blocks_namespaceObject.getBlockDefaultClassName)(blockName) : undefined,
      blockTitle: blockType?.title
    };

    // When in preview mode, we can avoid a lot of selection and
    // editing related selectors.
    if (isPreviewMode) {
      return previewContext;
    }
    const _isSelected = isBlockSelected(clientId);
    const canRemove = canRemoveBlock(clientId);
    const canMove = canMoveBlock(clientId);
    const match = getActiveBlockVariation(blockName, attributes);
    const isMultiSelected = isBlockMultiSelected(clientId);
    const checkDeep = true;
    const isAncestorOfSelectedBlock = hasSelectedInnerBlock(clientId, checkDeep);
    const blockEditingMode = getBlockEditingMode(clientId);
    const multiple = (0,external_wp_blocks_namespaceObject.hasBlockSupport)(blockName, &#039;multiple&#039;, true);

    // For block types with `multiple` support, there is no &quot;original
    // block&quot; to be found in the content, as the block itself is valid.
    const blocksWithSameName = multiple ? [] : getBlocksByName(blockName);
    const isInvalid = blocksWithSameName.length &amp;&amp; blocksWithSameName[0] !== clientId;
    return {
      ...previewContext,
      mode: getBlockMode(clientId),
      isSelectionEnabled: isSelectionEnabled(),
      isLocked: !!getTemplateLock(rootClientId),
      isSectionBlock: _isSectionBlock(clientId),
      canRemove,
      canMove,
      isSelected: _isSelected,
      isTemporarilyEditingAsBlocks: getTemporarilyEditingAsBlocks() === clientId,
      blockEditingMode,
      mayDisplayControls: _isSelected || isFirstMultiSelectedBlock(clientId) &amp;&amp; getMultiSelectedBlockClientIds().every(id =&gt; getBlockName(id) === blockName),
      mayDisplayParentControls: _hasBlockSupport(getBlockName(clientId), &#039;__experimentalExposeControlsToChildren&#039;, false) &amp;&amp; hasSelectedInnerBlock(clientId),
      blockApiVersion: blockType?.apiVersion || 1,
      blockTitle: match?.title || blockType?.title,
      isSubtreeDisabled: blockEditingMode === &#039;disabled&#039; &amp;&amp; isBlockSubtreeDisabled(clientId),
      hasOverlay: __unstableHasActiveBlockOverlayActive(clientId) &amp;&amp; !isDragging(),
      initialPosition: _isSelected ? getSelectedBlocksInitialCaretPosition() : undefined,
      isHighlighted: isBlockHighlighted(clientId),
      isMultiSelected,
      isPartiallySelected: isMultiSelected &amp;&amp; !__unstableIsFullySelected() &amp;&amp; !__unstableSelectionHasUnmergeableBlock(),
      isDragging: isBlockBeingDragged(clientId),
      hasChildSelected: isAncestorOfSelectedBlock,
      isEditingDisabled: blockEditingMode === &#039;disabled&#039;,
      hasEditableOutline: blockEditingMode !== &#039;disabled&#039; &amp;&amp; getBlockEditingMode(rootClientId) === &#039;disabled&#039;,
      originalBlockClientId: isInvalid ? blocksWithSameName[0] : false
    };
  }, [clientId, rootClientId]);
  const {
    isPreviewMode,
    // Fill values that end up as a public API and may not be defined in
    // preview mode.
    mode = &#039;visual&#039;,
    isSelectionEnabled = false,
    isLocked = false,
    canRemove = false,
    canMove = false,
    blockWithoutAttributes,
    name,
    attributes,
    isValid,
    isSelected = false,
    themeSupportsLayout,
    isTemporarilyEditingAsBlocks,
    blockEditingMode,
    mayDisplayControls,
    mayDisplayParentControls,
    index,
    blockApiVersion,
    blockTitle,
    isSubtreeDisabled,
    hasOverlay,
    initialPosition,
    isHighlighted,
    isMultiSelected,
    isPartiallySelected,
    isReusable,
    isDragging,
    hasChildSelected,
    isSectionBlock,
    isEditingDisabled,
    hasEditableOutline,
    className,
    defaultClassName,
    originalBlockClientId
  } = selectedProps;

  // Users of the editor.BlockListBlock filter used to be able to
  // access the block prop.
  // Ideally these blocks would rely on the clientId prop only.
  // This is kept for backward compatibility reasons.
  const block = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; ({
    ...blockWithoutAttributes,
    attributes
  }), [blockWithoutAttributes, attributes]);

  // Block is sometimes not mounted at the right time, causing it be
  // undefined see issue for more info
  // https://github.com/WordPress/gutenberg/issues/17013
  if (!selectedProps) {
    return null;
  }
  const privateContext = {
    isPreviewMode,
    clientId,
    className,
    index,
    mode,
    name,
    blockApiVersion,
    blockTitle,
    isSelected,
    isSubtreeDisabled,
    hasOverlay,
    initialPosition,
    blockEditingMode,
    isHighlighted,
    isMultiSelected,
    isPartiallySelected,
    isReusable,
    isDragging,
    hasChildSelected,
    isSectionBlock,
    isEditingDisabled,
    hasEditableOutline,
    isTemporarilyEditingAsBlocks,
    defaultClassName,
    mayDisplayControls,
    mayDisplayParentControls,
    originalBlockClientId,
    themeSupportsLayout,
    canMove
  };

  // Here we separate between the props passed to BlockListBlock and any other
  // information we selected for internal use. BlockListBlock is a filtered
  // component and thus ALL the props are PUBLIC API.

  // Note that the context value doesn&#039;t have to be memoized in this case
  // because when it changes, this component will be re-rendered anyway, and
  // none of the consumers (BlockListBlock and useBlockProps) are memoized or
  // &quot;pure&quot;. This is different from the public BlockEditContext, where
  // consumers might be memoized or &quot;pure&quot;.
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PrivateBlockContext.Provider, {
    value: privateContext,
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockListBlock, {
      ...props,
      mode,
      isSelectionEnabled,
      isLocked,
      canRemove,
      canMove,
      // Users of the editor.BlockListBlock filter used to be able
      // to access the block prop. Ideally these blocks would rely
      // on the clientId prop only. This is kept for backward
      // compatibility reasons.
      block,
      name,
      attributes,
      isValid,
      isSelected
    })
  });
}
/* harmony default export */ const block = ((0,external_wp_element_namespaceObject.memo)(BlockListBlockProvider));

;// external [&quot;wp&quot;,&quot;htmlEntities&quot;]
const external_wp_htmlEntities_namespaceObject = window[&quot;wp&quot;][&quot;htmlEntities&quot;];
;// ./node_modules/@wordpress/block-editor/build-module/components/default-block-appender/index.js
/**
 * External dependencies
 */


/**
 * WordPress dependencies
 */





/**
 * Internal dependencies
 */



/**
 * Zero width non-breaking space, used as padding for the paragraph when it is
 * empty.
 */

const ZWNBSP = &#039;\ufeff&#039;;
function DefaultBlockAppender({
  rootClientId
}) {
  const {
    showPrompt,
    isLocked,
    placeholder,
    isManualGrid
  } = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      getBlockCount,
      getSettings,
      getTemplateLock,
      getBlockAttributes
    } = select(store);
    const isEmpty = !getBlockCount(rootClientId);
    const {
      bodyPlaceholder
    } = getSettings();
    return {
      showPrompt: isEmpty,
      isLocked: !!getTemplateLock(rootClientId),
      placeholder: bodyPlaceholder,
      isManualGrid: getBlockAttributes(rootClientId)?.layout?.isManualPlacement
    };
  }, [rootClientId]);
  const {
    insertDefaultBlock,
    startTyping
  } = (0,external_wp_data_namespaceObject.useDispatch)(store);
  if (isLocked || isManualGrid) {
    return null;
  }
  const value = (0,external_wp_htmlEntities_namespaceObject.decodeEntities)(placeholder) || (0,external_wp_i18n_namespaceObject.__)(&#039;Type / to choose a block&#039;);
  const onAppend = () =&gt; {
    insertDefaultBlock(undefined, rootClientId);
    startTyping();
  };
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;div&quot;, {
    &quot;data-root-client-id&quot;: rootClientId || &#039;&#039;,
    className: dist_clsx(&#039;block-editor-default-block-appender&#039;, {
      &#039;has-visible-prompt&#039;: showPrompt
    }),
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;p&quot;, {
      tabIndex: &quot;0&quot;
      // We want this element to be styled as a paragraph by themes.
      // eslint-disable-next-line jsx-a11y/no-noninteractive-element-to-interactive-role
      ,
      role: &quot;button&quot;,
      &quot;aria-label&quot;: (0,external_wp_i18n_namespaceObject.__)(&#039;Add default block&#039;)
      // A wrapping container for this one already has the wp-block className.
      ,
      className: &quot;block-editor-default-block-appender__content&quot;,
      onKeyDown: event =&gt; {
        if (external_wp_keycodes_namespaceObject.ENTER === event.keyCode || external_wp_keycodes_namespaceObject.SPACE === event.keyCode) {
          onAppend();
        }
      },
      onClick: () =&gt; onAppend(),
      onFocus: () =&gt; {
        if (showPrompt) {
          onAppend();
        }
      },
      children: showPrompt ? value : ZWNBSP
    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inserter, {
      rootClientId: rootClientId,
      position: &quot;bottom right&quot;,
      isAppender: true,
      __experimentalIsQuick: true
    })]
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/block-list-appender/index.js
/**
 * External dependencies
 */


/**
 * WordPress dependencies
 */



/**
 * Internal dependencies
 */




function DefaultAppender({
  rootClientId
}) {
  const canInsertDefaultBlock = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; select(store).canInsertBlockType((0,external_wp_blocks_namespaceObject.getDefaultBlockName)(), rootClientId));
  if (canInsertDefaultBlock) {
    // Render the default block appender if the context supports use
    // of the default appender.
    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(DefaultBlockAppender, {
      rootClientId: rootClientId
    });
  }

  // Fallback in case the default block can&#039;t be inserted.
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(button_block_appender, {
    rootClientId: rootClientId,
    className: &quot;block-list-appender__toggle&quot;
  });
}
function BlockListAppender({
  rootClientId,
  CustomAppender,
  className,
  tagName: TagName = &#039;div&#039;
}) {
  const isDragOver = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      getBlockInsertionPoint,
      isBlockInsertionPointVisible,
      getBlockCount
    } = select(store);
    const insertionPoint = getBlockInsertionPoint();
    // Ideally we should also check for `isDragging` but currently it
    // requires a lot more setup. We can revisit this once we refactor
    // the DnD utility hooks.
    return isBlockInsertionPointVisible() &amp;&amp; rootClientId === insertionPoint?.rootClientId &amp;&amp; getBlockCount(rootClientId) === 0;
  }, [rootClientId]);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(TagName
  // A `tabIndex` is used on the wrapping `div` element in order to
  // force a focus event to occur when an appender `button` element
  // is clicked. In some browsers (Firefox, Safari), button clicks do
  // not emit a focus event, which could cause this event to propagate
  // unexpectedly. The `tabIndex` ensures that the interaction is
  // captured as a focus, without also adding an extra tab stop.
  //
  // See: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/button#Clicking_and_focus
  , {
    tabIndex: -1,
    className: dist_clsx(&#039;block-list-appender wp-block&#039;, className, {
      &#039;is-drag-over&#039;: isDragOver
    })
    // Needed in case the whole editor is content editable (for multi
    // selection). It fixes an edge case where ArrowDown and ArrowRight
    // should collapse the selection to the end of that selection and
    // not into the appender.
    ,
    contentEditable: false
    // The appender exists to let you add the first Paragraph before
    // any is inserted. To that end, this appender should visually be
    // presented as a block. That means theme CSS should style it as if
    // it were an empty paragraph block. That means a `wp-block` class to
    // ensure the width is correct, and a [data-block] attribute to ensure
    // the correct margin is applied, especially for classic themes which
    // have commonly targeted that attribute for margins.
    ,
    &quot;data-block&quot;: true,
    children: CustomAppender ? /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(CustomAppender, {}) : /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(DefaultAppender, {
      rootClientId: rootClientId
    })
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/block-popover/inbetween.js
/**
 * External dependencies
 */


/**
 * WordPress dependencies
 */





/**
 * Internal dependencies
 */




const inbetween_MAX_POPOVER_RECOMPUTE_COUNTER = Number.MAX_SAFE_INTEGER;
const InsertionPointOpenRef = (0,external_wp_element_namespaceObject.createContext)();
function BlockPopoverInbetween({
  previousClientId,
  nextClientId,
  children,
  __unstablePopoverSlot,
  __unstableContentRef,
  operation = &#039;insert&#039;,
  nearestSide = &#039;right&#039;,
  ...props
}) {
  // This is a temporary hack to get the inbetween inserter to recompute properly.
  const [popoverRecomputeCounter, forcePopoverRecompute] = (0,external_wp_element_namespaceObject.useReducer)(
  // Module is there to make sure that the counter doesn&#039;t overflow.
  s =&gt; (s + 1) % inbetween_MAX_POPOVER_RECOMPUTE_COUNTER, 0);
  const {
    orientation,
    rootClientId,
    isVisible
  } = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      getBlockListSettings,
      getBlockRootClientId,
      isBlockVisible
    } = select(store);
    const _rootClientId = getBlockRootClientId(previousClientId !== null &amp;&amp; previousClientId !== void 0 ? previousClientId : nextClientId);
    return {
      orientation: getBlockListSettings(_rootClientId)?.orientation || &#039;vertical&#039;,
      rootClientId: _rootClientId,
      isVisible: isBlockVisible(previousClientId) &amp;&amp; isBlockVisible(nextClientId)
    };
  }, [previousClientId, nextClientId]);
  const previousElement = useBlockElement(previousClientId);
  const nextElement = useBlockElement(nextClientId);
  const isVertical = orientation === &#039;vertical&#039;;
  const popoverAnchor = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; {
    if (
    // popoverRecomputeCounter is by definition always equal or greater than 0.
    // This check is only there to satisfy the correctness of the
    // exhaustive-deps rule for the `useMemo` hook.
    popoverRecomputeCounter &lt; 0 || !previousElement &amp;&amp; !nextElement || !isVisible) {
      return undefined;
    }
    const contextElement = operation === &#039;group&#039; ? nextElement || previousElement : previousElement || nextElement;
    return {
      contextElement,
      getBoundingClientRect() {
        const previousRect = previousElement ? previousElement.getBoundingClientRect() : null;
        const nextRect = nextElement ? nextElement.getBoundingClientRect() : null;
        let left = 0;
        let top = 0;
        let width = 0;
        let height = 0;
        if (operation === &#039;group&#039;) {
          const targetRect = nextRect || previousRect;
          top = targetRect.top;
          // No spacing is likely around blocks in this operation.
          // So width of the inserter containing rect is set to 0.
          width = 0;
          height = targetRect.bottom - targetRect.top;
          // Popover calculates its distance from mid-block so some
          // adjustments are needed to make it appear in the right place.
          left = nearestSide === &#039;left&#039; ? targetRect.left - 2 : targetRect.right - 2;
        } else if (isVertical) {
          // vertical
          top = previousRect ? previousRect.bottom : nextRect.top;
          width = previousRect ? previousRect.width : nextRect.width;
          height = nextRect &amp;&amp; previousRect ? nextRect.top - previousRect.bottom : 0;
          left = previousRect ? previousRect.left : nextRect.left;
        } else {
          top = previousRect ? previousRect.top : nextRect.top;
          height = previousRect ? previousRect.height : nextRect.height;
          if ((0,external_wp_i18n_namespaceObject.isRTL)()) {
            // non vertical, rtl
            left = nextRect ? nextRect.right : previousRect.left;
            width = previousRect &amp;&amp; nextRect ? previousRect.left - nextRect.right : 0;
          } else {
            // non vertical, ltr
            left = previousRect ? previousRect.right : nextRect.left;
            width = previousRect &amp;&amp; nextRect ? nextRect.left - previousRect.right : 0;
          }

          // Avoid a negative width which happens when the next rect
          // is on the next line.
          width = Math.max(width, 0);
        }
        return new window.DOMRect(left, top, width, height);
      }
    };
  }, [previousElement, nextElement, popoverRecomputeCounter, isVertical, isVisible, operation, nearestSide]);
  const popoverScrollRef = use_popover_scroll(__unstableContentRef);

  // This is only needed for a smooth transition when moving blocks.
  // When blocks are moved up/down, their position can be set by
  // updating the `transform` property manually (i.e. without using CSS
  // transitions or animations). The animation, which can also scroll the block
  // editor, can sometimes cause the position of the Popover to get out of sync.
  // A MutationObserver is therefore used to make sure that changes to the
  // selectedElement&#039;s attribute (i.e. `transform`) can be tracked and used to
  // trigger the Popover to rerender.
  (0,external_wp_element_namespaceObject.useLayoutEffect)(() =&gt; {
    if (!previousElement) {
      return;
    }
    const observer = new window.MutationObserver(forcePopoverRecompute);
    observer.observe(previousElement, {
      attributes: true
    });
    return () =&gt; {
      observer.disconnect();
    };
  }, [previousElement]);
  (0,external_wp_element_namespaceObject.useLayoutEffect)(() =&gt; {
    if (!nextElement) {
      return;
    }
    const observer = new window.MutationObserver(forcePopoverRecompute);
    observer.observe(nextElement, {
      attributes: true
    });
    return () =&gt; {
      observer.disconnect();
    };
  }, [nextElement]);
  (0,external_wp_element_namespaceObject.useLayoutEffect)(() =&gt; {
    if (!previousElement) {
      return;
    }
    previousElement.ownerDocument.defaultView.addEventListener(&#039;resize&#039;, forcePopoverRecompute);
    return () =&gt; {
      previousElement.ownerDocument.defaultView?.removeEventListener(&#039;resize&#039;, forcePopoverRecompute);
    };
  }, [previousElement]);

  // If there&#039;s either a previous or a next element, show the inbetween popover.
  // Note that drag and drop uses the inbetween popover to show the drop indicator
  // before the first block and after the last block.
  if (!previousElement &amp;&amp; !nextElement || !isVisible) {
    return null;
  }

  /* eslint-disable jsx-a11y/no-static-element-interactions, jsx-a11y/click-events-have-key-events */
  // While ideally it would be enough to capture the
  // bubbling focus event from the Inserter, due to the
  // characteristics of click focusing of `button`s in
  // Firefox and Safari, it is not reliable.
  //
  // See: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/button#Clicking_and_focus
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Popover, {
    ref: popoverScrollRef,
    animate: false,
    anchor: popoverAnchor,
    focusOnMount: false
    // Render in the old slot if needed for backward compatibility,
    // otherwise render in place (not in the default popover slot).
    ,
    __unstableSlotName: __unstablePopoverSlot,
    inline: !__unstablePopoverSlot
    // Forces a remount of the popover when its position changes
    // This makes sure the popover doesn&#039;t animate from its previous position.
    ,
    ...props,
    className: dist_clsx(&#039;block-editor-block-popover&#039;, &#039;block-editor-block-popover__inbetween&#039;, props.className),
    resize: false,
    flip: false,
    placement: &quot;overlay&quot;,
    variant: &quot;unstyled&quot;,
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
      className: &quot;block-editor-block-popover__inbetween-container&quot;,
      children: children
    })
  }, nextClientId + &#039;--&#039; + rootClientId);
  /* eslint-enable jsx-a11y/no-static-element-interactions, jsx-a11y/click-events-have-key-events */
}
/* harmony default export */ const inbetween = (BlockPopoverInbetween);

;// ./node_modules/@wordpress/block-editor/build-module/components/block-popover/drop-zone.js
/**
 * WordPress dependencies
 */




/**
 * Internal dependencies
 */



const animateVariants = {
  hide: {
    opacity: 0,
    scaleY: 0.75
  },
  show: {
    opacity: 1,
    scaleY: 1
  },
  exit: {
    opacity: 0,
    scaleY: 0.9
  }
};
function BlockDropZonePopover({
  __unstablePopoverSlot,
  __unstableContentRef
}) {
  const {
    clientId
  } = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      getBlockOrder,
      getBlockInsertionPoint
    } = select(store);
    const insertionPoint = getBlockInsertionPoint();
    const order = getBlockOrder(insertionPoint.rootClientId);
    if (!order.length) {
      return {};
    }
    return {
      clientId: order[insertionPoint.index]
    };
  }, []);
  const reducedMotion = (0,external_wp_compose_namespaceObject.useReducedMotion)();
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(cover, {
    clientId: clientId,
    __unstablePopoverSlot: __unstablePopoverSlot,
    __unstableContentRef: __unstableContentRef,
    className: &quot;block-editor-block-popover__drop-zone&quot;,
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__unstableMotion.div, {
      &quot;data-testid&quot;: &quot;block-popover-drop-zone&quot;,
      initial: reducedMotion ? animateVariants.show : animateVariants.hide,
      animate: animateVariants.show,
      exit: reducedMotion ? animateVariants.show : animateVariants.exit,
      className: &quot;block-editor-block-popover__drop-zone-foreground&quot;
    })
  });
}
/* harmony default export */ const drop_zone = (BlockDropZonePopover);

;// ./node_modules/@wordpress/block-editor/build-module/components/block-tools/insertion-point.js
/**
 * External dependencies
 */


/**
 * WordPress dependencies
 */





/**
 * Internal dependencies
 */






const insertion_point_InsertionPointOpenRef = (0,external_wp_element_namespaceObject.createContext)();
function InbetweenInsertionPointPopover({
  __unstablePopoverSlot,
  __unstableContentRef,
  operation = &#039;insert&#039;,
  nearestSide = &#039;right&#039;
}) {
  const {
    selectBlock,
    hideInsertionPoint
  } = (0,external_wp_data_namespaceObject.useDispatch)(store);
  const openRef = (0,external_wp_element_namespaceObject.useContext)(insertion_point_InsertionPointOpenRef);
  const ref = (0,external_wp_element_namespaceObject.useRef)();
  const {
    orientation,
    previousClientId,
    nextClientId,
    rootClientId,
    isInserterShown,
    isDistractionFree,
    isZoomOutMode
  } = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      getBlockOrder,
      getBlockListSettings,
      getBlockInsertionPoint,
      isBlockBeingDragged,
      getPreviousBlockClientId,
      getNextBlockClientId,
      getSettings,
      isZoomOut
    } = unlock(select(store));
    const insertionPoint = getBlockInsertionPoint();
    const order = getBlockOrder(insertionPoint.rootClientId);
    if (!order.length) {
      return {};
    }
    let _previousClientId = order[insertionPoint.index - 1];
    let _nextClientId = order[insertionPoint.index];
    while (isBlockBeingDragged(_previousClientId)) {
      _previousClientId = getPreviousBlockClientId(_previousClientId);
    }
    while (isBlockBeingDragged(_nextClientId)) {
      _nextClientId = getNextBlockClientId(_nextClientId);
    }
    const settings = getSettings();
    return {
      previousClientId: _previousClientId,
      nextClientId: _nextClientId,
      orientation: getBlockListSettings(insertionPoint.rootClientId)?.orientation || &#039;vertical&#039;,
      rootClientId: insertionPoint.rootClientId,
      isDistractionFree: settings.isDistractionFree,
      isInserterShown: insertionPoint?.__unstableWithInserter,
      isZoomOutMode: isZoomOut()
    };
  }, []);
  const {
    getBlockEditingMode
  } = (0,external_wp_data_namespaceObject.useSelect)(store);
  const disableMotion = (0,external_wp_compose_namespaceObject.useReducedMotion)();
  function onClick(event) {
    if (event.target === ref.current &amp;&amp; nextClientId &amp;&amp; getBlockEditingMode(nextClientId) !== &#039;disabled&#039;) {
      selectBlock(nextClientId, -1);
    }
  }
  function maybeHideInserterPoint(event) {
    // Only hide the inserter if it&#039;s triggered on the wrapper,
    // and the inserter is not open.
    if (event.target === ref.current &amp;&amp; !openRef.current) {
      hideInsertionPoint();
    }
  }
  function onFocus(event) {
    // Only handle click on the wrapper specifically, and not an event
    // bubbled from the inserter itself.
    if (event.target !== ref.current) {
      openRef.current = true;
    }
  }
  const lineVariants = {
    // Initial position starts from the center and invisible.
    start: {
      opacity: 0,
      scale: 0
    },
    // The line expands to fill the container. If the inserter is visible it
    // is delayed so it appears orchestrated.
    rest: {
      opacity: 1,
      scale: 1,
      transition: {
        delay: isInserterShown ? 0.5 : 0,
        type: &#039;tween&#039;
      }
    },
    hover: {
      opacity: 1,
      scale: 1,
      transition: {
        delay: 0.5,
        type: &#039;tween&#039;
      }
    }
  };
  const inserterVariants = {
    start: {
      scale: disableMotion ? 1 : 0
    },
    rest: {
      scale: 1,
      transition: {
        delay: 0.4,
        type: &#039;tween&#039;
      }
    }
  };
  if (isDistractionFree) {
    return null;
  }

  // Zoom out mode should only show the insertion point for the insert operation.
  // Other operations such as &quot;group&quot; are when the editor tries to create a row
  // block by grouping the block being dragged with the block it&#039;s being dropped
  // onto.
  if (isZoomOutMode &amp;&amp; operation !== &#039;insert&#039;) {
    return null;
  }
  const orientationClassname = orientation === &#039;horizontal&#039; || operation === &#039;group&#039; ? &#039;is-horizontal&#039; : &#039;is-vertical&#039;;
  const className = dist_clsx(&#039;block-editor-block-list__insertion-point&#039;, orientationClassname);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inbetween, {
    previousClientId: previousClientId,
    nextClientId: nextClientId,
    __unstablePopoverSlot: __unstablePopoverSlot,
    __unstableContentRef: __unstableContentRef,
    operation: operation,
    nearestSide: nearestSide,
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__unstableMotion.div, {
      layout: !disableMotion,
      initial: disableMotion ? &#039;rest&#039; : &#039;start&#039;,
      animate: &quot;rest&quot;,
      whileHover: &quot;hover&quot;,
      whileTap: &quot;pressed&quot;,
      exit: &quot;start&quot;,
      ref: ref,
      tabIndex: -1,
      onClick: onClick,
      onFocus: onFocus,
      className: dist_clsx(className, {
        &#039;is-with-inserter&#039;: isInserterShown
      }),
      onHoverEnd: maybeHideInserterPoint,
      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__unstableMotion.div, {
        variants: lineVariants,
        className: &quot;block-editor-block-list__insertion-point-indicator&quot;,
        &quot;data-testid&quot;: &quot;block-list-insertion-point-indicator&quot;
      }), isInserterShown &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__unstableMotion.div, {
        variants: inserterVariants,
        className: dist_clsx(&#039;block-editor-block-list__insertion-point-inserter&#039;),
        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inserter, {
          position: &quot;bottom center&quot;,
          clientId: nextClientId,
          rootClientId: rootClientId,
          __experimentalIsQuick: true,
          onToggle: isOpen =&gt; {
            openRef.current = isOpen;
          },
          onSelectOrClose: () =&gt; {
            openRef.current = false;
          }
        })
      })]
    })
  });
}
function InsertionPoint(props) {
  const {
    insertionPoint,
    isVisible,
    isBlockListEmpty
  } = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      getBlockInsertionPoint,
      isBlockInsertionPointVisible,
      getBlockCount
    } = select(store);
    const blockInsertionPoint = getBlockInsertionPoint();
    return {
      insertionPoint: blockInsertionPoint,
      isVisible: isBlockInsertionPointVisible(),
      isBlockListEmpty: getBlockCount(blockInsertionPoint?.rootClientId) === 0
    };
  }, []);
  if (!isVisible ||
  // Don&#039;t render the insertion point if the block list is empty.
  // The insertion point will be represented by the appender instead.
  isBlockListEmpty) {
    return null;
  }

  /**
   * Render a popover that overlays the block when the desired operation is to replace it.
   * Otherwise, render a popover in between blocks for the indication of inserting between them.
   */
  return insertionPoint.operation === &#039;replace&#039; ? /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(drop_zone
  // Force remount to trigger the animation.
  , {
    ...props
  }, `${insertionPoint.rootClientId}-${insertionPoint.index}`) : /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(InbetweenInsertionPointPopover, {
    operation: insertionPoint.operation,
    nearestSide: insertionPoint.nearestSide,
    ...props
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/block-list/use-in-between-inserter.js
/**
 * WordPress dependencies
 */





/**
 * Internal dependencies
 */



function useInBetweenInserter() {
  const openRef = (0,external_wp_element_namespaceObject.useContext)(insertion_point_InsertionPointOpenRef);
  const isInBetweenInserterDisabled = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; select(store).getSettings().isDistractionFree || unlock(select(store)).isZoomOut(), []);
  const {
    getBlockListSettings,
    getBlockIndex,
    isMultiSelecting,
    getSelectedBlockClientIds,
    getSettings,
    getTemplateLock,
    __unstableIsWithinBlockOverlay,
    getBlockEditingMode,
    getBlockName,
    getBlockAttributes,
    getParentSectionBlock
  } = unlock((0,external_wp_data_namespaceObject.useSelect)(store));
  const {
    showInsertionPoint,
    hideInsertionPoint
  } = (0,external_wp_data_namespaceObject.useDispatch)(store);
  return (0,external_wp_compose_namespaceObject.useRefEffect)(node =&gt; {
    if (isInBetweenInserterDisabled) {
      return;
    }
    function onMouseMove(event) {
      // openRef is the reference to the insertion point between blocks.
      // If the reference is not set or the insertion point is already open, return.
      if (openRef === undefined || openRef.current) {
        return;
      }

      // Ignore text nodes sometimes detected in FireFox.
      if (event.target.nodeType === event.target.TEXT_NODE) {
        return;
      }
      if (isMultiSelecting()) {
        return;
      }
      if (!event.target.classList.contains(&#039;block-editor-block-list__layout&#039;)) {
        hideInsertionPoint();
        return;
      }
      let rootClientId;
      if (!event.target.classList.contains(&#039;is-root-container&#039;)) {
        const blockElement = !!event.target.getAttribute(&#039;data-block&#039;) ? event.target : event.target.closest(&#039;[data-block]&#039;);
        rootClientId = blockElement.getAttribute(&#039;data-block&#039;);
      }
      if (getTemplateLock(rootClientId) || getBlockEditingMode(rootClientId) === &#039;disabled&#039; || getBlockName(rootClientId) === &#039;core/block&#039; || rootClientId &amp;&amp; getBlockAttributes(rootClientId).layout?.isManualPlacement) {
        return;
      }
      const blockListSettings = getBlockListSettings(rootClientId);
      const orientation = blockListSettings?.orientation || &#039;vertical&#039;;
      const captureToolbars = !!blockListSettings?.__experimentalCaptureToolbars;
      const offsetTop = event.clientY;
      const offsetLeft = event.clientX;
      const children = Array.from(event.target.children);
      let element = children.find(blockEl =&gt; {
        const blockElRect = blockEl.getBoundingClientRect();
        return blockEl.classList.contains(&#039;wp-block&#039;) &amp;&amp; orientation === &#039;vertical&#039; &amp;&amp; blockElRect.top &gt; offsetTop || blockEl.classList.contains(&#039;wp-block&#039;) &amp;&amp; orientation === &#039;horizontal&#039; &amp;&amp; ((0,external_wp_i18n_namespaceObject.isRTL)() ? blockElRect.right &lt; offsetLeft : blockElRect.left &gt; offsetLeft);
      });
      if (!element) {
        hideInsertionPoint();
        return;
      }

      // The block may be in an alignment wrapper, so check the first direct
      // child if the element has no ID.
      if (!element.id) {
        element = element.firstElementChild;
        if (!element) {
          hideInsertionPoint();
          return;
        }
      }

      // Don&#039;t show the insertion point if a parent block has an &quot;overlay&quot;
      // See https://github.com/WordPress/gutenberg/pull/34012#pullrequestreview-727762337
      const clientId = element.id.slice(&#039;block-&#039;.length);
      if (!clientId || __unstableIsWithinBlockOverlay(clientId) || !!getParentSectionBlock(clientId)) {
        return;
      }

      // Don&#039;t show the inserter if the following conditions are met,
      // as it conflicts with the block toolbar:
      // 1. when hovering above or inside selected block(s)
      // 2. when the orientation is vertical
      // 3. when the __experimentalCaptureToolbars is not enabled
      // 4. when the Top Toolbar is not disabled
      if (getSelectedBlockClientIds().includes(clientId) &amp;&amp; orientation === &#039;vertical&#039; &amp;&amp; !captureToolbars &amp;&amp; !getSettings().hasFixedToolbar) {
        return;
      }
      const elementRect = element.getBoundingClientRect();
      if (orientation === &#039;horizontal&#039; &amp;&amp; (event.clientY &gt; elementRect.bottom || event.clientY &lt; elementRect.top) || orientation === &#039;vertical&#039; &amp;&amp; (event.clientX &gt; elementRect.right || event.clientX &lt; elementRect.left)) {
        hideInsertionPoint();
        return;
      }
      const index = getBlockIndex(clientId);

      // Don&#039;t show the in-between inserter before the first block in
      // the list (preserves the original behaviour).
      if (index === 0) {
        hideInsertionPoint();
        return;
      }
      showInsertionPoint(rootClientId, index, {
        __unstableWithInserter: true
      });
    }
    node.addEventListener(&#039;mousemove&#039;, onMouseMove);
    return () =&gt; {
      node.removeEventListener(&#039;mousemove&#039;, onMouseMove);
    };
  }, [openRef, getBlockListSettings, getBlockIndex, isMultiSelecting, showInsertionPoint, hideInsertionPoint, getSelectedBlockClientIds, isInBetweenInserterDisabled]);
}

;// ./node_modules/@wordpress/block-editor/build-module/components/block-selection-clearer/index.js
/**
 * WordPress dependencies
 */



/**
 * Internal dependencies
 */


/**
 * Pass the returned ref callback to an element that should clear block
 * selection. Selection will only be cleared if the element is clicked directly,
 * not if a child element is clicked.
 *
 * @return {import(&#039;react&#039;).RefCallback} Ref callback.
 */

function useBlockSelectionClearer() {
  const {
    getSettings,
    hasSelectedBlock,
    hasMultiSelection
  } = (0,external_wp_data_namespaceObject.useSelect)(store);
  const {
    clearSelectedBlock
  } = (0,external_wp_data_namespaceObject.useDispatch)(store);
  const {
    clearBlockSelection: isEnabled
  } = getSettings();
  return (0,external_wp_compose_namespaceObject.useRefEffect)(node =&gt; {
    if (!isEnabled) {
      return;
    }
    function onMouseDown(event) {
      if (!hasSelectedBlock() &amp;&amp; !hasMultiSelection()) {
        return;
      }

      // Only handle clicks on the element, not the children.
      if (event.target !== node) {
        return;
      }
      clearSelectedBlock();
    }
    node.addEventListener(&#039;mousedown&#039;, onMouseDown);
    return () =&gt; {
      node.removeEventListener(&#039;mousedown&#039;, onMouseDown);
    };
  }, [hasSelectedBlock, hasMultiSelection, clearSelectedBlock, isEnabled]);
}
function BlockSelectionClearer(props) {
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
    ref: useBlockSelectionClearer(),
    ...props
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/inner-blocks/button-block-appender.js
/**
 * External dependencies
 */


/**
 * Internal dependencies
 */



function ButtonBlockAppender({
  showSeparator,
  isFloating,
  onAddBlock,
  isToggle
}) {
  const {
    clientId
  } = useBlockEditContext();
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(button_block_appender, {
    className: dist_clsx({
      &#039;block-list-appender__toggle&#039;: isToggle
    }),
    rootClientId: clientId,
    showSeparator: showSeparator,
    isFloating: isFloating,
    onAddBlock: onAddBlock
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/inner-blocks/default-block-appender.js
/**
 * Internal dependencies
 */



function default_block_appender_DefaultBlockAppender() {
  const {
    clientId
  } = useBlockEditContext();
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(DefaultBlockAppender, {
    rootClientId: clientId
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/inner-blocks/use-nested-settings-update.js
/**
 * WordPress dependencies
 */





/**
 * Internal dependencies
 */



/** @typedef {import(&#039;../../selectors&#039;).WPDirectInsertBlock } WPDirectInsertBlock */

const pendingSettingsUpdates = new WeakMap();

// Creates a memoizing caching function that remembers the last value and keeps returning it
// as long as the new values are shallowly equal. Helps keep dependencies stable.
function createShallowMemo() {
  let value;
  return newValue =&gt; {
    if (value === undefined || !external_wp_isShallowEqual_default()(value, newValue)) {
      value = newValue;
    }
    return value;
  };
}
function useShallowMemo(value) {
  const [memo] = (0,external_wp_element_namespaceObject.useState)(createShallowMemo);
  return memo(value);
}

/**
 * This hook is a side effect which updates the block-editor store when changes
 * happen to inner block settings. The given props are transformed into a
 * settings object, and if that is different from the current settings object in
 * the block-editor store, then the store is updated with the new settings which
 * came from props.
 *
 * @param {string}               clientId                   The client ID of the block to update.
 * @param {string}               parentLock
 * @param {string[]}             allowedBlocks              An array of block names which are permitted
 *                                                          in inner blocks.
 * @param {string[]}             prioritizedInserterBlocks  Block names and/or block variations to be prioritized in the inserter, in the format {blockName}/{variationName}.
 * @param {?WPDirectInsertBlock} defaultBlock               The default block to insert: [ blockName, { blockAttributes } ].
 * @param {?boolean}             directInsert               If a default block should be inserted directly by the appender.
 *
 * @param {?WPDirectInsertBlock} __experimentalDefaultBlock A deprecated prop for the default block to insert: [ blockName, { blockAttributes } ]. Use `defaultBlock` instead.
 *
 * @param {?boolean}             __experimentalDirectInsert A deprecated prop for whether a default block should be inserted directly by the appender. Use `directInsert` instead.
 *
 * @param {string}               [templateLock]             The template lock specified for the inner
 *                                                          blocks component. (e.g. &quot;all&quot;)
 * @param {boolean}              captureToolbars            Whether or children toolbars should be shown
 *                                                          in the inner blocks component rather than on
 *                                                          the child block.
 * @param {string}               orientation                The direction in which the block
 *                                                          should face.
 * @param {Object}               layout                     The layout object for the block container.
 */
function useNestedSettingsUpdate(clientId, parentLock, allowedBlocks, prioritizedInserterBlocks, defaultBlock, directInsert, __experimentalDefaultBlock, __experimentalDirectInsert, templateLock, captureToolbars, orientation, layout) {
  // Instead of adding a useSelect mapping here, please add to the useSelect
  // mapping in InnerBlocks! Every subscription impacts performance.

  const registry = (0,external_wp_data_namespaceObject.useRegistry)();

  // Implementors often pass a new array on every render,
  // and the contents of the arrays are just strings, so the entire array
  // can be passed as dependencies but We need to include the length of the array,
  // otherwise if the arrays change length but the first elements are equal the comparison,
  // does not works as expected.
  const _allowedBlocks = useShallowMemo(allowedBlocks);
  const _prioritizedInserterBlocks = useShallowMemo(prioritizedInserterBlocks);
  const _templateLock = templateLock === undefined || parentLock === &#039;contentOnly&#039; ? parentLock : templateLock;
  (0,external_wp_element_namespaceObject.useLayoutEffect)(() =&gt; {
    const newSettings = {
      allowedBlocks: _allowedBlocks,
      prioritizedInserterBlocks: _prioritizedInserterBlocks,
      templateLock: _templateLock
    };

    // These values are not defined for RN, so only include them if they
    // are defined.
    if (captureToolbars !== undefined) {
      newSettings.__experimentalCaptureToolbars = captureToolbars;
    }

    // Orientation depends on layout,
    // ideally the separate orientation prop should be deprecated.
    if (orientation !== undefined) {
      newSettings.orientation = orientation;
    } else {
      const layoutType = getLayoutType(layout?.type);
      newSettings.orientation = layoutType.getOrientation(layout);
    }
    if (__experimentalDefaultBlock !== undefined) {
      external_wp_deprecated_default()(&#039;__experimentalDefaultBlock&#039;, {
        alternative: &#039;defaultBlock&#039;,
        since: &#039;6.3&#039;,
        version: &#039;6.4&#039;
      });
      newSettings.defaultBlock = __experimentalDefaultBlock;
    }
    if (defaultBlock !== undefined) {
      newSettings.defaultBlock = defaultBlock;
    }
    if (__experimentalDirectInsert !== undefined) {
      external_wp_deprecated_default()(&#039;__experimentalDirectInsert&#039;, {
        alternative: &#039;directInsert&#039;,
        since: &#039;6.3&#039;,
        version: &#039;6.4&#039;
      });
      newSettings.directInsert = __experimentalDirectInsert;
    }
    if (directInsert !== undefined) {
      newSettings.directInsert = directInsert;
    }
    if (newSettings.directInsert !== undefined &amp;&amp; typeof newSettings.directInsert !== &#039;boolean&#039;) {
      external_wp_deprecated_default()(&#039;Using `Function` as a `directInsert` argument&#039;, {
        alternative: &#039;`boolean` values&#039;,
        since: &#039;6.5&#039;
      });
    }

    // Batch updates to block list settings to avoid triggering cascading renders
    // for each container block included in a tree and optimize initial render.
    // To avoid triggering updateBlockListSettings for each container block
    // causing X re-renderings for X container blocks,
    // we batch all the updatedBlockListSettings in a single &quot;data&quot; batch
    // which results in a single re-render.
    if (!pendingSettingsUpdates.get(registry)) {
      pendingSettingsUpdates.set(registry, {});
    }
    pendingSettingsUpdates.get(registry)[clientId] = newSettings;
    window.queueMicrotask(() =&gt; {
      const settings = pendingSettingsUpdates.get(registry);
      if (Object.keys(settings).length) {
        const {
          updateBlockListSettings
        } = registry.dispatch(store);
        updateBlockListSettings(settings);
        pendingSettingsUpdates.set(registry, {});
      }
    });
  }, [clientId, _allowedBlocks, _prioritizedInserterBlocks, _templateLock, defaultBlock, directInsert, __experimentalDefaultBlock, __experimentalDirectInsert, captureToolbars, orientation, layout, registry]);
}

;// ./node_modules/@wordpress/block-editor/build-module/components/inner-blocks/use-inner-block-template-sync.js
/**
 * External dependencies
 */


/**
 * WordPress dependencies
 */




/**
 * Internal dependencies
 */


/**
 * This hook makes sure that a block&#039;s inner blocks stay in sync with the given
 * block &quot;template&quot;. The template is a block hierarchy to which inner blocks must
 * conform. If the blocks get &quot;out of sync&quot; with the template and the template
 * is meant to be locked (e.g. templateLock = &quot;all&quot; or templateLock = &quot;contentOnly&quot;),
 * then we replace the inner blocks with the correct value after synchronizing it with the template.
 *
 * @param {string}  clientId                       The block client ID.
 * @param {Object}  template                       The template to match.
 * @param {string}  templateLock                   The template lock state for the inner blocks. For
 *                                                 example, if the template lock is set to &quot;all&quot;,
 *                                                 then the inner blocks will stay in sync with the
 *                                                 template. If not defined or set to false, then
 *                                                 the inner blocks will not be synchronized with
 *                                                 the given template.
 * @param {boolean} templateInsertUpdatesSelection Whether or not to update the
 *                                                 block-editor selection state when inner blocks
 *                                                 are replaced after template synchronization.
 */
function useInnerBlockTemplateSync(clientId, template, templateLock, templateInsertUpdatesSelection) {
  // Instead of adding a useSelect mapping here, please add to the useSelect
  // mapping in InnerBlocks! Every subscription impacts performance.
  const registry = (0,external_wp_data_namespaceObject.useRegistry)();

  // Maintain a reference to the previous value so we can do a deep equality check.
  const existingTemplateRef = (0,external_wp_element_namespaceObject.useRef)(null);
  (0,external_wp_element_namespaceObject.useLayoutEffect)(() =&gt; {
    let isCancelled = false;
    const {
      getBlocks,
      getSelectedBlocksInitialCaretPosition,
      isBlockSelected
    } = registry.select(store);
    const {
      replaceInnerBlocks,
      __unstableMarkNextChangeAsNotPersistent
    } = registry.dispatch(store);

    // There&#039;s an implicit dependency between useInnerBlockTemplateSync and useNestedSettingsUpdate
    // The former needs to happen after the latter and since the latter is using microtasks to batch updates (performance optimization),
    // we need to schedule this one in a microtask as well.
    // Example: If you remove queueMicrotask here, ctrl + click to insert quote block won&#039;t close the inserter.
    window.queueMicrotask(() =&gt; {
      if (isCancelled) {
        return;
      }

      // Only synchronize innerBlocks with template if innerBlocks are empty
      // or a locking &quot;all&quot; or &quot;contentOnly&quot; exists directly on the block.
      const currentInnerBlocks = getBlocks(clientId);
      const shouldApplyTemplate = currentInnerBlocks.length === 0 || templateLock === &#039;all&#039; || templateLock === &#039;contentOnly&#039;;
      const hasTemplateChanged = !es6_default()(template, existingTemplateRef.current);
      if (!shouldApplyTemplate || !hasTemplateChanged) {
        return;
      }
      existingTemplateRef.current = template;
      const nextBlocks = (0,external_wp_blocks_namespaceObject.synchronizeBlocksWithTemplate)(currentInnerBlocks, template);
      if (!es6_default()(nextBlocks, currentInnerBlocks)) {
        __unstableMarkNextChangeAsNotPersistent();
        replaceInnerBlocks(clientId, nextBlocks, currentInnerBlocks.length === 0 &amp;&amp; templateInsertUpdatesSelection &amp;&amp; nextBlocks.length !== 0 &amp;&amp; isBlockSelected(clientId),
        // This ensures the &quot;initialPosition&quot; doesn&#039;t change when applying the template
        // If we&#039;re supposed to focus the block, we&#039;ll focus the first inner block
        // otherwise, we won&#039;t apply any auto-focus.
        // This ensures for instance that the focus stays in the inserter when inserting the &quot;buttons&quot; block.
        getSelectedBlocksInitialCaretPosition());
      }
    });
    return () =&gt; {
      isCancelled = true;
    };
  }, [template, templateLock, clientId, registry, templateInsertUpdatesSelection]);
}

;// ./node_modules/@wordpress/block-editor/build-module/components/inner-blocks/use-block-context.js
/**
 * WordPress dependencies
 */



/**
 * Internal dependencies
 */


/**
 * Returns a context object for a given block.
 *
 * @param {string} clientId The block client ID.
 *
 * @return {Record&lt;string,*&gt;} Context value.
 */
function useBlockContext(clientId) {
  return (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const block = select(store).getBlock(clientId);
    if (!block) {
      return undefined;
    }
    const blockType = select(external_wp_blocks_namespaceObject.store).getBlockType(block.name);
    if (!blockType) {
      return undefined;
    }
    if (Object.keys(blockType.providesContext).length === 0) {
      return undefined;
    }
    return Object.fromEntries(Object.entries(blockType.providesContext).map(([contextName, attributeName]) =&gt; [contextName, block.attributes[attributeName]]));
  }, [clientId]);
}

;// ./node_modules/@wordpress/block-editor/build-module/components/use-on-block-drop/index.js
/**
 * WordPress dependencies
 */





/**
 * Internal dependencies
 */


/** @typedef {import(&#039;react&#039;).SyntheticEvent} SyntheticEvent */
/** @typedef {import(&#039;./types&#039;).WPDropOperation} WPDropOperation */

/**
 * Retrieve the data for a block drop event.
 *
 * @param {SyntheticEvent} event The drop event.
 *
 * @return {Object} An object with block drag and drop data.
 */
function parseDropEvent(event) {
  let result = {
    srcRootClientId: null,
    srcClientIds: null,
    srcIndex: null,
    type: null,
    blocks: null
  };
  if (!event.dataTransfer) {
    return result;
  }
  try {
    result = Object.assign(result, JSON.parse(event.dataTransfer.getData(&#039;wp-blocks&#039;)));
  } catch (err) {
    return result;
  }
  return result;
}

/**
 * A function that returns an event handler function for block drop events.
 *
 * @param {string}   targetRootClientId        The root client id where the block(s) will be inserted.
 * @param {number}   targetBlockIndex          The index where the block(s) will be inserted.
 * @param {Function} getBlockIndex             A function that gets the index of a block.
 * @param {Function} getClientIdsOfDescendants A function that gets the client ids of descendant blocks.
 * @param {Function} moveBlocks                A function that moves blocks.
 * @param {Function} insertOrReplaceBlocks     A function that inserts or replaces blocks.
 * @param {Function} clearSelectedBlock        A function that clears block selection.
 * @param {string}   operation                 The type of operation to perform on drop. Could be `insert` or `replace` or `group`.
 * @param {Function} getBlock                  A function that returns a block given its client id.
 * @return {Function} The event handler for a block drop event.
 */
function onBlockDrop(targetRootClientId, targetBlockIndex, getBlockIndex, getClientIdsOfDescendants, moveBlocks, insertOrReplaceBlocks, clearSelectedBlock, operation, getBlock) {
  return event =&gt; {
    const {
      srcRootClientId: sourceRootClientId,
      srcClientIds: sourceClientIds,
      type: dropType,
      blocks
    } = parseDropEvent(event);

    // If the user is inserting a block.
    if (dropType === &#039;inserter&#039;) {
      clearSelectedBlock();
      const blocksToInsert = blocks.map(block =&gt; (0,external_wp_blocks_namespaceObject.cloneBlock)(block));
      insertOrReplaceBlocks(blocksToInsert, true, null);
    }

    // If the user is moving a block.
    if (dropType === &#039;block&#039;) {
      const sourceBlockIndex = getBlockIndex(sourceClientIds[0]);

      // If the user is dropping to the same position, return early.
      if (sourceRootClientId === targetRootClientId &amp;&amp; sourceBlockIndex === targetBlockIndex) {
        return;
      }

      // If the user is attempting to drop a block within its own
      // nested blocks, return early as this would create infinite
      // recursion.
      if (sourceClientIds.includes(targetRootClientId) || getClientIdsOfDescendants(sourceClientIds).some(id =&gt; id === targetRootClientId)) {
        return;
      }

      // If the user is dropping a block over another block, replace both blocks
      // with a group block containing them
      if (operation === &#039;group&#039;) {
        const blocksToInsert = sourceClientIds.map(clientId =&gt; getBlock(clientId));
        insertOrReplaceBlocks(blocksToInsert, true, null, sourceClientIds);
        return;
      }
      const isAtSameLevel = sourceRootClientId === targetRootClientId;
      const draggedBlockCount = sourceClientIds.length;

      // If the block is kept at the same level and moved downwards,
      // subtract to take into account that the blocks being dragged
      // were removed from the block list above the insertion point.
      const insertIndex = isAtSameLevel &amp;&amp; sourceBlockIndex &lt; targetBlockIndex ? targetBlockIndex - draggedBlockCount : targetBlockIndex;
      moveBlocks(sourceClientIds, sourceRootClientId, insertIndex);
    }
  };
}

/**
 * A function that returns an event handler function for block-related file drop events.
 *
 * @param {string}   targetRootClientId    The root client id where the block(s) will be inserted.
 * @param {Function} getSettings           A function that gets the block editor settings.
 * @param {Function} updateBlockAttributes A function that updates a block&#039;s attributes.
 * @param {Function} canInsertBlockType    A function that returns checks whether a block type can be inserted.
 * @param {Function} insertOrReplaceBlocks A function that inserts or replaces blocks.
 *
 * @return {Function} The event handler for a block-related file drop event.
 */
function onFilesDrop(targetRootClientId, getSettings, updateBlockAttributes, canInsertBlockType, insertOrReplaceBlocks) {
  return files =&gt; {
    if (!getSettings().mediaUpload) {
      return;
    }
    const transformation = (0,external_wp_blocks_namespaceObject.findTransform)((0,external_wp_blocks_namespaceObject.getBlockTransforms)(&#039;from&#039;), transform =&gt; transform.type === &#039;files&#039; &amp;&amp; canInsertBlockType(transform.blockName, targetRootClientId) &amp;&amp; transform.isMatch(files));
    if (transformation) {
      const blocks = transformation.transform(files, updateBlockAttributes);
      insertOrReplaceBlocks(blocks);
    }
  };
}

/**
 * A function that returns an event handler function for block-related HTML drop events.
 *
 * @param {Function} insertOrReplaceBlocks A function that inserts or replaces blocks.
 *
 * @return {Function} The event handler for a block-related HTML drop event.
 */
function onHTMLDrop(insertOrReplaceBlocks) {
  return HTML =&gt; {
    const blocks = (0,external_wp_blocks_namespaceObject.pasteHandler)({
      HTML,
      mode: &#039;BLOCKS&#039;
    });
    if (blocks.length) {
      insertOrReplaceBlocks(blocks);
    }
  };
}

/**
 * A React hook for handling block drop events.
 *
 * @param {string}          targetRootClientId  The root client id where the block(s) will be inserted.
 * @param {number}          targetBlockIndex    The index where the block(s) will be inserted.
 * @param {Object}          options             The optional options.
 * @param {WPDropOperation} [options.operation] The type of operation to perform on drop. Could be `insert` or `replace` for now.
 *
 * @return {Function} A function to be passed to the onDrop handler.
 */
function useOnBlockDrop(targetRootClientId, targetBlockIndex, options = {}) {
  const {
    operation = &#039;insert&#039;,
    nearestSide = &#039;right&#039;
  } = options;
  const {
    canInsertBlockType,
    getBlockIndex,
    getClientIdsOfDescendants,
    getBlockOrder,
    getBlocksByClientId,
    getSettings,
    getBlock
  } = (0,external_wp_data_namespaceObject.useSelect)(store);
  const {
    getGroupingBlockName
  } = (0,external_wp_data_namespaceObject.useSelect)(external_wp_blocks_namespaceObject.store);
  const {
    insertBlocks,
    moveBlocksToPosition,
    updateBlockAttributes,
    clearSelectedBlock,
    replaceBlocks,
    removeBlocks
  } = (0,external_wp_data_namespaceObject.useDispatch)(store);
  const registry = (0,external_wp_data_namespaceObject.useRegistry)();
  const insertOrReplaceBlocks = (0,external_wp_element_namespaceObject.useCallback)((blocks, updateSelection = true, initialPosition = 0, clientIdsToReplace = []) =&gt; {
    if (!Array.isArray(blocks)) {
      blocks = [blocks];
    }
    const clientIds = getBlockOrder(targetRootClientId);
    const clientId = clientIds[targetBlockIndex];
    if (operation === &#039;replace&#039;) {
      replaceBlocks(clientId, blocks, undefined, initialPosition);
    } else if (operation === &#039;group&#039;) {
      const targetBlock = getBlock(clientId);
      if (nearestSide === &#039;left&#039;) {
        blocks.push(targetBlock);
      } else {
        blocks.unshift(targetBlock);
      }
      const groupInnerBlocks = blocks.map(block =&gt; {
        return (0,external_wp_blocks_namespaceObject.createBlock)(block.name, block.attributes, block.innerBlocks);
      });
      const areAllImages = blocks.every(block =&gt; {
        return block.name === &#039;core/image&#039;;
      });
      const galleryBlock = canInsertBlockType(&#039;core/gallery&#039;, targetRootClientId);
      const wrappedBlocks = (0,external_wp_blocks_namespaceObject.createBlock)(areAllImages &amp;&amp; galleryBlock ? &#039;core/gallery&#039; : getGroupingBlockName(), {
        layout: {
          type: &#039;flex&#039;,
          flexWrap: areAllImages &amp;&amp; galleryBlock ? null : &#039;nowrap&#039;
        }
      }, groupInnerBlocks);
      // Need to make sure both the target block and the block being dragged are replaced
      // otherwise the dragged block will be duplicated.
      replaceBlocks([clientId, ...clientIdsToReplace], wrappedBlocks, undefined, initialPosition);
    } else {
      insertBlocks(blocks, targetBlockIndex, targetRootClientId, updateSelection, initialPosition);
    }
  }, [getBlockOrder, targetRootClientId, targetBlockIndex, operation, replaceBlocks, getBlock, nearestSide, canInsertBlockType, getGroupingBlockName, insertBlocks]);
  const moveBlocks = (0,external_wp_element_namespaceObject.useCallback)((sourceClientIds, sourceRootClientId, insertIndex) =&gt; {
    if (operation === &#039;replace&#039;) {
      const sourceBlocks = getBlocksByClientId(sourceClientIds);
      const targetBlockClientIds = getBlockOrder(targetRootClientId);
      const targetBlockClientId = targetBlockClientIds[targetBlockIndex];
      registry.batch(() =&gt; {
        // Remove the source blocks.
        removeBlocks(sourceClientIds, false);
        // Replace the target block with the source blocks.
        replaceBlocks(targetBlockClientId, sourceBlocks, undefined, 0);
      });
    } else {
      moveBlocksToPosition(sourceClientIds, sourceRootClientId, targetRootClientId, insertIndex);
    }
  }, [operation, getBlockOrder, getBlocksByClientId, moveBlocksToPosition, registry, removeBlocks, replaceBlocks, targetBlockIndex, targetRootClientId]);
  const _onDrop = onBlockDrop(targetRootClientId, targetBlockIndex, getBlockIndex, getClientIdsOfDescendants, moveBlocks, insertOrReplaceBlocks, clearSelectedBlock, operation, getBlock);
  const _onFilesDrop = onFilesDrop(targetRootClientId, getSettings, updateBlockAttributes, canInsertBlockType, insertOrReplaceBlocks);
  const _onHTMLDrop = onHTMLDrop(insertOrReplaceBlocks);
  return event =&gt; {
    const files = (0,external_wp_dom_namespaceObject.getFilesFromDataTransfer)(event.dataTransfer);
    const html = event.dataTransfer.getData(&#039;text/html&#039;);

    /**
     * From Windows Chrome 96, the `event.dataTransfer` returns both file object and HTML.
     * The order of the checks is important to recognise the HTML drop.
     */
    if (html) {
      _onHTMLDrop(html);
    } else if (files.length) {
      _onFilesDrop(files);
    } else {
      _onDrop(event);
    }
  };
}

;// ./node_modules/@wordpress/block-editor/build-module/utils/math.js
/**
 * A string representing the name of an edge.
 *
 * @typedef {&#039;top&#039;|&#039;right&#039;|&#039;bottom&#039;|&#039;left&#039;} WPEdgeName
 */

/**
 * @typedef  {Object} WPPoint
 * @property {number} x The horizontal position.
 * @property {number} y The vertical position.
 */

/**
 * Given a point, a DOMRect and the name of an edge, returns the distance to
 * that edge of the rect.
 *
 * This function works for edges that are horizontal or vertical (e.g. not
 * rotated), the following terms are used so that the function works in both
 * orientations:
 *
 * - Forward, meaning the axis running horizontally when an edge is vertical
 *   and vertically when an edge is horizontal.
 * - Lateral, meaning the axis running vertically when an edge is vertical
 *   and horizontally when an edge is horizontal.
 *
 * @param {WPPoint}    point The point to measure distance from.
 * @param {DOMRect}    rect  A DOM Rect containing edge positions.
 * @param {WPEdgeName} edge  The edge to measure to.
 */
function getDistanceFromPointToEdge(point, rect, edge) {
  const isHorizontal = edge === &#039;top&#039; || edge === &#039;bottom&#039;;
  const {
    x,
    y
  } = point;
  const pointLateralPosition = isHorizontal ? x : y;
  const pointForwardPosition = isHorizontal ? y : x;
  const edgeStart = isHorizontal ? rect.left : rect.top;
  const edgeEnd = isHorizontal ? rect.right : rect.bottom;
  const edgeForwardPosition = rect[edge];

  // Measure the straight line distance to the edge of the rect, when the
  // point is adjacent to the edge.
  // Else, if the point is positioned diagonally to the edge of the rect,
  // measure diagonally to the nearest corner that the edge meets.
  let edgeLateralPosition;
  if (pointLateralPosition &gt;= edgeStart &amp;&amp; pointLateralPosition &lt;= edgeEnd) {
    edgeLateralPosition = pointLateralPosition;
  } else if (pointLateralPosition &lt; edgeEnd) {
    edgeLateralPosition = edgeStart;
  } else {
    edgeLateralPosition = edgeEnd;
  }
  return Math.sqrt((pointLateralPosition - edgeLateralPosition) ** 2 + (pointForwardPosition - edgeForwardPosition) ** 2);
}

/**
 * Given a point, a DOMRect and a list of allowed edges returns the name of and
 * distance to the nearest edge.
 *
 * @param {WPPoint}      point        The point to measure distance from.
 * @param {DOMRect}      rect         A DOM Rect containing edge positions.
 * @param {WPEdgeName[]} allowedEdges A list of the edges included in the
 *                                    calculation. Defaults to all edges.
 *
 * @return {[number, string]} An array where the first value is the distance
 *                              and a second is the edge name.
 */
function getDistanceToNearestEdge(point, rect, allowedEdges = [&#039;top&#039;, &#039;bottom&#039;, &#039;left&#039;, &#039;right&#039;]) {
  let candidateDistance;
  let candidateEdge;
  allowedEdges.forEach(edge =&gt; {
    const distance = getDistanceFromPointToEdge(point, rect, edge);
    if (candidateDistance === undefined || distance &lt; candidateDistance) {
      candidateDistance = distance;
      candidateEdge = edge;
    }
  });
  return [candidateDistance, candidateEdge];
}

/**
 * Is the point contained by the rectangle.
 *
 * @param {WPPoint} point The point.
 * @param {DOMRect} rect  The rectangle.
 *
 * @return {boolean} True if the point is contained by the rectangle, false otherwise.
 */
function isPointContainedByRect(point, rect) {
  return rect.left &lt;= point.x &amp;&amp; rect.right &gt;= point.x &amp;&amp; rect.top &lt;= point.y &amp;&amp; rect.bottom &gt;= point.y;
}

/**
 * Is the point within the top and bottom boundaries of the rectangle.
 *
 * @param {WPPoint} point The point.
 * @param {DOMRect} rect  The rectangle.
 *
 * @return {boolean} True if the point is within top and bottom of rectangle, false otherwise.
 */
function isPointWithinTopAndBottomBoundariesOfRect(point, rect) {
  return rect.top &lt;= point.y &amp;&amp; rect.bottom &gt;= point.y;
}

;// ./node_modules/@wordpress/block-editor/build-module/components/use-block-drop-zone/index.js
/**
 * WordPress dependencies
 */






/**
 * Internal dependencies
 */




const THRESHOLD_DISTANCE = 30;
const MINIMUM_HEIGHT_FOR_THRESHOLD = 120;
const MINIMUM_WIDTH_FOR_THRESHOLD = 120;

/** @typedef {import(&#039;../../utils/math&#039;).WPPoint} WPPoint */
/** @typedef {import(&#039;../use-on-block-drop/types&#039;).WPDropOperation} WPDropOperation */

/**
 * The orientation of a block list.
 *
 * @typedef {&#039;horizontal&#039;|&#039;vertical&#039;|undefined} WPBlockListOrientation
 */

/**
 * The insert position when dropping a block.
 *
 * @typedef {&#039;before&#039;|&#039;after&#039;} WPInsertPosition
 */

/**
 * @typedef {Object} WPBlockData
 * @property {boolean}       isUnmodifiedDefaultBlock Is the block unmodified default block.
 * @property {() =&gt; DOMRect} getBoundingClientRect    Get the bounding client rect of the block.
 * @property {number}        blockIndex               The index of the block.
 */

/**
 * Get the drop target position from a given drop point and the orientation.
 *
 * @param {WPBlockData[]}          blocksData  The block data list.
 * @param {WPPoint}                position    The position of the item being dragged.
 * @param {WPBlockListOrientation} orientation The orientation of the block list.
 * @param {Object}                 options     Additional options.
 * @return {[number, WPDropOperation]} The drop target position.
 */
function getDropTargetPosition(blocksData, position, orientation = &#039;vertical&#039;, options = {}) {
  const allowedEdges = orientation === &#039;horizontal&#039; ? [&#039;left&#039;, &#039;right&#039;] : [&#039;top&#039;, &#039;bottom&#039;];
  let nearestIndex = 0;
  let insertPosition = &#039;before&#039;;
  let minDistance = Infinity;
  let targetBlockIndex = null;
  let nearestSide = &#039;right&#039;;
  const {
    dropZoneElement,
    parentBlockOrientation,
    rootBlockIndex = 0
  } = options;

  // Allow before/after when dragging over the top/bottom edges of the drop zone.
  if (dropZoneElement &amp;&amp; parentBlockOrientation !== &#039;horizontal&#039;) {
    const rect = dropZoneElement.getBoundingClientRect();
    const [distance, edge] = getDistanceToNearestEdge(position, rect, [&#039;top&#039;, &#039;bottom&#039;]);

    // If dragging over the top or bottom of the drop zone, insert the block
    // before or after the parent block. This only applies to blocks that use
    // a drop zone element, typically container blocks such as Group or Cover.
    if (rect.height &gt; MINIMUM_HEIGHT_FOR_THRESHOLD &amp;&amp; distance &lt; THRESHOLD_DISTANCE) {
      if (edge === &#039;top&#039;) {
        return [rootBlockIndex, &#039;before&#039;];
      }
      if (edge === &#039;bottom&#039;) {
        return [rootBlockIndex + 1, &#039;after&#039;];
      }
    }
  }
  const isRightToLeft = (0,external_wp_i18n_namespaceObject.isRTL)();

  // Allow before/after when dragging over the left/right edges of the drop zone.
  if (dropZoneElement &amp;&amp; parentBlockOrientation === &#039;horizontal&#039;) {
    const rect = dropZoneElement.getBoundingClientRect();
    const [distance, edge] = getDistanceToNearestEdge(position, rect, [&#039;left&#039;, &#039;right&#039;]);

    // If dragging over the left or right of the drop zone, insert the block
    // before or after the parent block. This only applies to blocks that use
    // a drop zone element, typically container blocks such as Group.
    if (rect.width &gt; MINIMUM_WIDTH_FOR_THRESHOLD &amp;&amp; distance &lt; THRESHOLD_DISTANCE) {
      if (isRightToLeft &amp;&amp; edge === &#039;right&#039; || !isRightToLeft &amp;&amp; edge === &#039;left&#039;) {
        return [rootBlockIndex, &#039;before&#039;];
      }
      if (isRightToLeft &amp;&amp; edge === &#039;left&#039; || !isRightToLeft &amp;&amp; edge === &#039;right&#039;) {
        return [rootBlockIndex + 1, &#039;after&#039;];
      }
    }
  }
  blocksData.forEach(({
    isUnmodifiedDefaultBlock,
    getBoundingClientRect,
    blockIndex,
    blockOrientation
  }) =&gt; {
    const rect = getBoundingClientRect();
    let [distance, edge] = getDistanceToNearestEdge(position, rect, allowedEdges);
    // If the the point is close to a side, prioritize that side.
    const [sideDistance, sideEdge] = getDistanceToNearestEdge(position, rect, [&#039;left&#039;, &#039;right&#039;]);
    const isPointInsideRect = isPointContainedByRect(position, rect);

    // Prioritize the element if the point is inside of an unmodified default block.
    if (isUnmodifiedDefaultBlock &amp;&amp; isPointInsideRect) {
      distance = 0;
    } else if (orientation === &#039;vertical&#039; &amp;&amp; blockOrientation !== &#039;horizontal&#039; &amp;&amp; (isPointInsideRect &amp;&amp; sideDistance &lt; THRESHOLD_DISTANCE || !isPointInsideRect &amp;&amp; isPointWithinTopAndBottomBoundariesOfRect(position, rect))) {
      /**
       * This condition should only apply when the layout is vertical (otherwise there&#039;s
       * no need to create a Row) and dropzones should only activate when the block is
       * either within and close to the sides of the target block or on its outer sides.
       */
      targetBlockIndex = blockIndex;
      nearestSide = sideEdge;
    }
    if (distance &lt; minDistance) {
      // Where the dropped block will be inserted on the nearest block.
      insertPosition = edge === &#039;bottom&#039; || !isRightToLeft &amp;&amp; edge === &#039;right&#039; || isRightToLeft &amp;&amp; edge === &#039;left&#039; ? &#039;after&#039; : &#039;before&#039;;

      // Update the currently known best candidate.
      minDistance = distance;
      nearestIndex = blockIndex;
    }
  });
  const adjacentIndex = nearestIndex + (insertPosition === &#039;after&#039; ? 1 : -1);
  const isNearestBlockUnmodifiedDefaultBlock = !!blocksData[nearestIndex]?.isUnmodifiedDefaultBlock;
  const isAdjacentBlockUnmodifiedDefaultBlock = !!blocksData[adjacentIndex]?.isUnmodifiedDefaultBlock;

  // If the target index is set then group with the block at that index.
  if (targetBlockIndex !== null) {
    return [targetBlockIndex, &#039;group&#039;, nearestSide];
  }
  // If both blocks are not unmodified default blocks then just insert between them.
  if (!isNearestBlockUnmodifiedDefaultBlock &amp;&amp; !isAdjacentBlockUnmodifiedDefaultBlock) {
    // If the user is dropping to the trailing edge of the block
    // add 1 to the index to represent dragging after.
    const insertionIndex = insertPosition === &#039;after&#039; ? nearestIndex + 1 : nearestIndex;
    return [insertionIndex, &#039;insert&#039;];
  }

  // Otherwise, replace the nearest unmodified default block.
  return [isNearestBlockUnmodifiedDefaultBlock ? nearestIndex : adjacentIndex, &#039;replace&#039;];
}

/**
 * Check if the dragged blocks can be dropped on the target.
 * @param {Function} getBlockType
 * @param {Object[]} allowedBlocks
 * @param {string[]} draggedBlockNames
 * @param {string}   targetBlockName
 * @return {boolean} Whether the dragged blocks can be dropped on the target.
 */
function isDropTargetValid(getBlockType, allowedBlocks, draggedBlockNames, targetBlockName) {
  // At root level allowedBlocks is undefined and all blocks are allowed.
  // Otherwise, check if all dragged blocks are allowed.
  let areBlocksAllowed = true;
  if (allowedBlocks) {
    const allowedBlockNames = allowedBlocks?.map(({
      name
    }) =&gt; name);
    areBlocksAllowed = draggedBlockNames.every(name =&gt; allowedBlockNames?.includes(name));
  }

  // Work out if dragged blocks have an allowed parent and if so
  // check target block matches the allowed parent.
  const draggedBlockTypes = draggedBlockNames.map(name =&gt; getBlockType(name));
  const targetMatchesDraggedBlockParents = draggedBlockTypes.every(block =&gt; {
    const [allowedParentName] = block?.parent || [];
    if (!allowedParentName) {
      return true;
    }
    return allowedParentName === targetBlockName;
  });
  return areBlocksAllowed &amp;&amp; targetMatchesDraggedBlockParents;
}

/**
 * Checks if the given element is an insertion point.
 *
 * @param {EventTarget|null} targetToCheck - The element to check.
 * @param {Document}         ownerDocument - The owner document of the element.
 * @return {boolean} True if the element is a insertion point, false otherwise.
 */
function isInsertionPoint(targetToCheck, ownerDocument) {
  const {
    defaultView
  } = ownerDocument;
  return !!(defaultView &amp;&amp; targetToCheck instanceof defaultView.HTMLElement &amp;&amp; targetToCheck.closest(&#039;[data-is-insertion-point]&#039;));
}

/**
 * @typedef  {Object} WPBlockDropZoneConfig
 * @property {?HTMLElement} dropZoneElement Optional element to be used as the drop zone.
 * @property {string}       rootClientId    The root client id for the block list.
 */

/**
 * A React hook that can be used to make a block list handle drag and drop.
 *
 * @param {WPBlockDropZoneConfig} dropZoneConfig configuration data for the drop zone.
 */
function useBlockDropZone({
  dropZoneElement,
  // An undefined value represents a top-level block. Default to an empty
  // string for this so that `targetRootClientId` can be easily compared to
  // values returned by the `getRootBlockClientId` selector, which also uses
  // an empty string to represent top-level blocks.
  rootClientId: targetRootClientId = &#039;&#039;,
  parentClientId: parentBlockClientId = &#039;&#039;,
  isDisabled = false
} = {}) {
  const registry = (0,external_wp_data_namespaceObject.useRegistry)();
  const [dropTarget, setDropTarget] = (0,external_wp_element_namespaceObject.useState)({
    index: null,
    operation: &#039;insert&#039;
  });
  const {
    getBlockType,
    getBlockVariations,
    getGroupingBlockName
  } = (0,external_wp_data_namespaceObject.useSelect)(external_wp_blocks_namespaceObject.store);
  const {
    canInsertBlockType,
    getBlockListSettings,
    getBlocks,
    getBlockIndex,
    getDraggedBlockClientIds,
    getBlockNamesByClientId,
    getAllowedBlocks,
    isDragging,
    isGroupable,
    isZoomOut,
    getSectionRootClientId,
    getBlockParents
  } = unlock((0,external_wp_data_namespaceObject.useSelect)(store));
  const {
    showInsertionPoint,
    hideInsertionPoint,
    startDragging,
    stopDragging
  } = unlock((0,external_wp_data_namespaceObject.useDispatch)(store));
  const onBlockDrop = useOnBlockDrop(dropTarget.operation === &#039;before&#039; || dropTarget.operation === &#039;after&#039; ? parentBlockClientId : targetRootClientId, dropTarget.index, {
    operation: dropTarget.operation,
    nearestSide: dropTarget.nearestSide
  });
  const throttled = (0,external_wp_compose_namespaceObject.useThrottle)((0,external_wp_element_namespaceObject.useCallback)((event, ownerDocument) =&gt; {
    if (!isDragging()) {
      // When dragging from the desktop, no drag start event is fired.
      // So, ensure that the drag state is set when the user drags over a drop zone.
      startDragging();
    }
    const draggedBlockClientIds = getDraggedBlockClientIds();
    const targetParents = [targetRootClientId, ...getBlockParents(targetRootClientId, true)];

    // Check if the target is within any of the dragged blocks.
    const isTargetWithinDraggedBlocks = draggedBlockClientIds.some(clientId =&gt; targetParents.includes(clientId));
    if (isTargetWithinDraggedBlocks) {
      return;
    }
    const allowedBlocks = getAllowedBlocks(targetRootClientId);
    const targetBlockName = getBlockNamesByClientId([targetRootClientId])[0];
    const draggedBlockNames = getBlockNamesByClientId(draggedBlockClientIds);
    const isBlockDroppingAllowed = isDropTargetValid(getBlockType, allowedBlocks, draggedBlockNames, targetBlockName);
    if (!isBlockDroppingAllowed) {
      return;
    }
    const sectionRootClientId = getSectionRootClientId();

    // In Zoom Out mode, if the target is not the section root provided by settings then
    // do not allow dropping as the drop target is not within the root (that which is
    // treated as &quot;the content&quot; by Zoom Out Mode).
    if (isZoomOut() &amp;&amp; sectionRootClientId !== targetRootClientId) {
      return;
    }
    const blocks = getBlocks(targetRootClientId);

    // The block list is empty, don&#039;t show the insertion point but still allow dropping.
    if (blocks.length === 0) {
      registry.batch(() =&gt; {
        setDropTarget({
          index: 0,
          operation: &#039;insert&#039;
        });
        showInsertionPoint(targetRootClientId, 0, {
          operation: &#039;insert&#039;
        });
      });
      return;
    }
    const blocksData = blocks.map(block =&gt; {
      const clientId = block.clientId;
      return {
        isUnmodifiedDefaultBlock: (0,external_wp_blocks_namespaceObject.isUnmodifiedDefaultBlock)(block),
        getBoundingClientRect: () =&gt; ownerDocument.getElementById(`block-${clientId}`).getBoundingClientRect(),
        blockIndex: getBlockIndex(clientId),
        blockOrientation: getBlockListSettings(clientId)?.orientation
      };
    });
    const dropTargetPosition = getDropTargetPosition(blocksData, {
      x: event.clientX,
      y: event.clientY
    }, getBlockListSettings(targetRootClientId)?.orientation, {
      dropZoneElement,
      parentBlockClientId,
      parentBlockOrientation: parentBlockClientId ? getBlockListSettings(parentBlockClientId)?.orientation : undefined,
      rootBlockIndex: getBlockIndex(targetRootClientId)
    });
    const [targetIndex, operation, nearestSide] = dropTargetPosition;
    const isTargetIndexEmptyDefaultBlock = blocksData[targetIndex]?.isUnmodifiedDefaultBlock;
    if (isZoomOut() &amp;&amp; !isTargetIndexEmptyDefaultBlock &amp;&amp; operation !== &#039;insert&#039;) {
      return;
    }
    if (operation === &#039;group&#039;) {
      const targetBlock = blocks[targetIndex];
      const areAllImages = [targetBlock.name, ...draggedBlockNames].every(name =&gt; name === &#039;core/image&#039;);
      const canInsertGalleryBlock = canInsertBlockType(&#039;core/gallery&#039;, targetRootClientId);
      const areGroupableBlocks = isGroupable([targetBlock.clientId, getDraggedBlockClientIds()]);
      const groupBlockVariations = getBlockVariations(getGroupingBlockName(), &#039;block&#039;);
      const canInsertRow = groupBlockVariations &amp;&amp; groupBlockVariations.find(({
        name
      }) =&gt; name === &#039;group-row&#039;);

      // If the dragged blocks and the target block are all images,
      // check if it is creatable either a Row variation or a Gallery block.
      if (areAllImages &amp;&amp; !canInsertGalleryBlock &amp;&amp; (!areGroupableBlocks || !canInsertRow)) {
        return;
      }
      // If the dragged blocks and the target block are not all images,
      // check if it is creatable a Row variation.
      if (!areAllImages &amp;&amp; (!areGroupableBlocks || !canInsertRow)) {
        return;
      }
    }
    registry.batch(() =&gt; {
      setDropTarget({
        index: targetIndex,
        operation,
        nearestSide
      });
      const insertionPointClientId = [&#039;before&#039;, &#039;after&#039;].includes(operation) ? parentBlockClientId : targetRootClientId;
      showInsertionPoint(insertionPointClientId, targetIndex, {
        operation,
        nearestSide
      });
    });
  }, [isDragging, getAllowedBlocks, targetRootClientId, getBlockNamesByClientId, getDraggedBlockClientIds, getBlockType, getSectionRootClientId, isZoomOut, getBlocks, getBlockListSettings, dropZoneElement, parentBlockClientId, getBlockIndex, registry, startDragging, showInsertionPoint, canInsertBlockType, isGroupable, getBlockVariations, getGroupingBlockName]), 200);
  return (0,external_wp_compose_namespaceObject.__experimentalUseDropZone)({
    dropZoneElement,
    isDisabled,
    onDrop: onBlockDrop,
    onDragOver(event) {
      // `currentTarget` is only available while the event is being
      // handled, so get it now and pass it to the thottled function.
      // https://developer.mozilla.org/en-US/docs/Web/API/Event/currentTarget
      throttled(event, event.currentTarget.ownerDocument);
    },
    onDragLeave(event) {
      const {
        ownerDocument
      } = event.currentTarget;

      // If the drag event is leaving the drop zone and entering an insertion point,
      // do not hide the insertion point as it is conceptually within the dropzone.
      if (isInsertionPoint(event.relatedTarget, ownerDocument) || isInsertionPoint(event.target, ownerDocument)) {
        return;
      }
      throttled.cancel();
      hideInsertionPoint();
    },
    onDragEnd() {
      throttled.cancel();
      stopDragging();
      hideInsertionPoint();
    }
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/inner-blocks/index.js
/**
 * External dependencies
 */


/**
 * WordPress dependencies
 */





/**
 * Internal dependencies
 */













const EMPTY_OBJECT = {};
function BlockContext({
  children,
  clientId
}) {
  const context = useBlockContext(clientId);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockContextProvider, {
    value: context,
    children: children
  });
}
const BlockListItemsMemo = (0,external_wp_element_namespaceObject.memo)(BlockListItems);

/**
 * InnerBlocks is a component which allows a single block to have multiple blocks
 * as children. The UncontrolledInnerBlocks component is used whenever the inner
 * blocks are not controlled by another entity. In other words, it is normally
 * used for inner blocks in the post editor
 *
 * @param {Object} props The component props.
 */
function UncontrolledInnerBlocks(props) {
  const {
    clientId,
    allowedBlocks,
    prioritizedInserterBlocks,
    defaultBlock,
    directInsert,
    __experimentalDefaultBlock,
    __experimentalDirectInsert,
    template,
    templateLock,
    wrapperRef,
    templateInsertUpdatesSelection,
    __experimentalCaptureToolbars: captureToolbars,
    __experimentalAppenderTagName,
    renderAppender,
    orientation,
    placeholder,
    layout,
    name,
    blockType,
    parentLock,
    defaultLayout
  } = props;
  useNestedSettingsUpdate(clientId, parentLock, allowedBlocks, prioritizedInserterBlocks, defaultBlock, directInsert, __experimentalDefaultBlock, __experimentalDirectInsert, templateLock, captureToolbars, orientation, layout);
  useInnerBlockTemplateSync(clientId, template, templateLock, templateInsertUpdatesSelection);
  const defaultLayoutBlockSupport = (0,external_wp_blocks_namespaceObject.getBlockSupport)(name, &#039;layout&#039;) || (0,external_wp_blocks_namespaceObject.getBlockSupport)(name, &#039;__experimentalLayout&#039;) || EMPTY_OBJECT;
  const {
    allowSizingOnChildren = false
  } = defaultLayoutBlockSupport;
  const usedLayout = layout || defaultLayoutBlockSupport;
  const memoedLayout = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; ({
    // Default layout will know about any content/wide size defined by the theme.
    ...defaultLayout,
    ...usedLayout,
    ...(allowSizingOnChildren &amp;&amp; {
      allowSizingOnChildren: true
    })
  }), [defaultLayout, usedLayout, allowSizingOnChildren]);

  // For controlled inner blocks, we don&#039;t want a change in blocks to
  // re-render the blocks list.
  const items = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockListItemsMemo, {
    rootClientId: clientId,
    renderAppender: renderAppender,
    __experimentalAppenderTagName: __experimentalAppenderTagName,
    layout: memoedLayout,
    wrapperRef: wrapperRef,
    placeholder: placeholder
  });
  if (!blockType?.providesContext || Object.keys(blockType.providesContext).length === 0) {
    return items;
  }
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockContext, {
    clientId: clientId,
    children: items
  });
}

/**
 * The controlled inner blocks component wraps the uncontrolled inner blocks
 * component with the blockSync hook. This keeps the innerBlocks of the block in
 * the block-editor store in sync with the blocks of the controlling entity. An
 * example of an inner block controller is a template part block, which provides
 * its own blocks from the template part entity data source.
 *
 * @param {Object} props The component props.
 */
function ControlledInnerBlocks(props) {
  useBlockSync(props);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(UncontrolledInnerBlocks, {
    ...props
  });
}
const ForwardedInnerBlocks = (0,external_wp_element_namespaceObject.forwardRef)((props, ref) =&gt; {
  const innerBlocksProps = useInnerBlocksProps({
    ref
  }, props);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
    className: &quot;block-editor-inner-blocks&quot;,
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
      ...innerBlocksProps
    })
  });
});

/**
 * This hook is used to lightly mark an element as an inner blocks wrapper
 * element. Call this hook and pass the returned props to the element to mark as
 * an inner blocks wrapper, automatically rendering inner blocks as children. If
 * you define a ref for the element, it is important to pass the ref to this
 * hook, which the hook in turn will pass to the component through the props it
 * returns. Optionally, you can also pass any other props through this hook, and
 * they will be merged and returned.
 *
 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/inner-blocks/README.md
 *
 * @param {Object} props   Optional. Props to pass to the element. Must contain
 *                         the ref if one is defined.
 * @param {Object} options Optional. Inner blocks options.
 */
function useInnerBlocksProps(props = {}, options = {}) {
  const {
    __unstableDisableLayoutClassNames,
    __unstableDisableDropZone,
    dropZoneElement
  } = options;
  const {
    clientId,
    layout = null,
    __unstableLayoutClassNames: layoutClassNames = &#039;&#039;
  } = useBlockEditContext();
  const selected = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      getBlockName,
      isZoomOut,
      getTemplateLock,
      getBlockRootClientId,
      getBlockEditingMode,
      getBlockSettings,
      getSectionRootClientId
    } = unlock(select(store));
    if (!clientId) {
      const sectionRootClientId = getSectionRootClientId();
      // Disable the root drop zone when zoomed out and the section root client id
      // is not the root block list (represented by an empty string).
      // This avoids drag handling bugs caused by having two block lists acting as
      // drop zones - the actual &#039;root&#039; block list and the section root.
      return {
        isDropZoneDisabled: isZoomOut() &amp;&amp; sectionRootClientId !== &#039;&#039;
      };
    }
    const {
      hasBlockSupport,
      getBlockType
    } = select(external_wp_blocks_namespaceObject.store);
    const blockName = getBlockName(clientId);
    const blockEditingMode = getBlockEditingMode(clientId);
    const parentClientId = getBlockRootClientId(clientId);
    const [defaultLayout] = getBlockSettings(clientId, &#039;layout&#039;);
    let _isDropZoneDisabled = blockEditingMode === &#039;disabled&#039;;
    if (isZoomOut()) {
      // In zoom out mode, we want to disable the drop zone for the sections.
      // The inner blocks belonging to the section drop zone is
      // already disabled by the blocks themselves being disabled.
      const sectionRootClientId = getSectionRootClientId();
      _isDropZoneDisabled = clientId !== sectionRootClientId;
    }
    return {
      __experimentalCaptureToolbars: hasBlockSupport(blockName, &#039;__experimentalExposeControlsToChildren&#039;, false),
      name: blockName,
      blockType: getBlockType(blockName),
      parentLock: getTemplateLock(parentClientId),
      parentClientId,
      isDropZoneDisabled: _isDropZoneDisabled,
      defaultLayout
    };
  }, [clientId]);
  const {
    __experimentalCaptureToolbars,
    name,
    blockType,
    parentLock,
    parentClientId,
    isDropZoneDisabled,
    defaultLayout
  } = selected;
  const blockDropZoneRef = useBlockDropZone({
    dropZoneElement,
    rootClientId: clientId,
    parentClientId
  });
  const ref = (0,external_wp_compose_namespaceObject.useMergeRefs)([props.ref, __unstableDisableDropZone || isDropZoneDisabled || layout?.isManualPlacement &amp;&amp; window.__experimentalEnableGridInteractivity ? null : blockDropZoneRef]);
  const innerBlocksProps = {
    __experimentalCaptureToolbars,
    layout,
    name,
    blockType,
    parentLock,
    defaultLayout,
    ...options
  };
  const InnerBlocks = innerBlocksProps.value &amp;&amp; innerBlocksProps.onChange ? ControlledInnerBlocks : UncontrolledInnerBlocks;
  return {
    ...props,
    ref,
    className: dist_clsx(props.className, &#039;block-editor-block-list__layout&#039;, __unstableDisableLayoutClassNames ? &#039;&#039; : layoutClassNames),
    children: clientId ? /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(InnerBlocks, {
      ...innerBlocksProps,
      clientId: clientId
    }) : /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockListItems, {
      ...options
    })
  };
}
useInnerBlocksProps.save = external_wp_blocks_namespaceObject.__unstableGetInnerBlocksProps;

// Expose default appender placeholders as components.
ForwardedInnerBlocks.DefaultBlockAppender = default_block_appender_DefaultBlockAppender;
ForwardedInnerBlocks.ButtonBlockAppender = ButtonBlockAppender;
ForwardedInnerBlocks.Content = () =&gt; useInnerBlocksProps.save().children;

/**
 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/inner-blocks/README.md
 */
/* harmony default export */ const inner_blocks = (ForwardedInnerBlocks);

;// ./node_modules/@wordpress/block-editor/build-module/components/observe-typing/index.js
/**
 * WordPress dependencies
 */





/**
 * Internal dependencies
 */


/**
 * Set of key codes upon which typing is to be initiated on a keydown event.
 *
 * @type {Set&lt;number&gt;}
 */

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]);

/**
 * Returns true if a given keydown event can be inferred as intent to start
 * typing, or false otherwise. A keydown is considered eligible if it is a
 * text navigation without shift active.
 *
 * @param {KeyboardEvent} event Keydown event to test.
 *
 * @return {boolean} Whether event is eligible to start typing.
 */
function isKeyDownEligibleForStartTyping(event) {
  const {
    keyCode,
    shiftKey
  } = event;
  return !shiftKey &amp;&amp; KEY_DOWN_ELIGIBLE_KEY_CODES.has(keyCode);
}

/**
 * Removes the `isTyping` flag when the mouse moves in the document of the given
 * element.
 */
function useMouseMoveTypingReset() {
  const isTyping = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; select(store).isTyping(), []);
  const {
    stopTyping
  } = (0,external_wp_data_namespaceObject.useDispatch)(store);
  return (0,external_wp_compose_namespaceObject.useRefEffect)(node =&gt; {
    if (!isTyping) {
      return;
    }
    const {
      ownerDocument
    } = node;
    let lastClientX;
    let lastClientY;

    /**
     * On mouse move, unset typing flag if user has moved cursor.
     *
     * @param {MouseEvent} event Mousemove event.
     */
    function stopTypingOnMouseMove(event) {
      const {
        clientX,
        clientY
      } = event;

      // We need to check that the mouse really moved because Safari
      // triggers mousemove events when shift or ctrl are pressed.
      if (lastClientX &amp;&amp; lastClientY &amp;&amp; (lastClientX !== clientX || lastClientY !== clientY)) {
        stopTyping();
      }
      lastClientX = clientX;
      lastClientY = clientY;
    }
    ownerDocument.addEventListener(&#039;mousemove&#039;, stopTypingOnMouseMove);
    return () =&gt; {
      ownerDocument.removeEventListener(&#039;mousemove&#039;, stopTypingOnMouseMove);
    };
  }, [isTyping, stopTyping]);
}

/**
 * Sets and removes the `isTyping` flag based on user actions:
 *
 * - Sets the flag if the user types within the given element.
 * - Removes the flag when the user selects some text, focuses a non-text
 *   field, presses ESC or TAB, or moves the mouse in the document.
 */
function useTypingObserver() {
  const {
    isTyping
  } = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      isTyping: _isTyping
    } = select(store);
    return {
      isTyping: _isTyping()
    };
  }, []);
  const {
    startTyping,
    stopTyping
  } = (0,external_wp_data_namespaceObject.useDispatch)(store);
  const ref1 = useMouseMoveTypingReset();
  const ref2 = (0,external_wp_compose_namespaceObject.useRefEffect)(node =&gt; {
    const {
      ownerDocument
    } = node;
    const {
      defaultView
    } = ownerDocument;
    const selection = defaultView.getSelection();

    // Listeners to stop typing should only be added when typing.
    // Listeners to start typing should only be added when not typing.
    if (isTyping) {
      let timerId;

      /**
       * Stops typing when focus transitions to a non-text field element.
       *
       * @param {FocusEvent} event Focus event.
       */
      function stopTypingOnNonTextField(event) {
        const {
          target
        } = event;

        // Since focus to a non-text field via arrow key will trigger
        // before the keydown event, wait until after current stack
        // before evaluating whether typing is to be stopped. Otherwise,
        // typing will re-start.
        timerId = defaultView.setTimeout(() =&gt; {
          if (!(0,external_wp_dom_namespaceObject.isTextField)(target)) {
            stopTyping();
          }
        });
      }

      /**
       * Unsets typing flag if user presses Escape while typing flag is
       * active.
       *
       * @param {KeyboardEvent} event Keypress or keydown event to
       *                              interpret.
       */
      function stopTypingOnEscapeKey(event) {
        const {
          keyCode
        } = event;
        if (keyCode === external_wp_keycodes_namespaceObject.ESCAPE || keyCode === external_wp_keycodes_namespaceObject.TAB) {
          stopTyping();
        }
      }

      /**
       * On selection change, unset typing flag if user has made an
       * uncollapsed (shift) selection.
       */
      function stopTypingOnSelectionUncollapse() {
        if (!selection.isCollapsed) {
          stopTyping();
        }
      }
      node.addEventListener(&#039;focus&#039;, stopTypingOnNonTextField);
      node.addEventListener(&#039;keydown&#039;, stopTypingOnEscapeKey);
      ownerDocument.addEventListener(&#039;selectionchange&#039;, stopTypingOnSelectionUncollapse);
      return () =&gt; {
        defaultView.clearTimeout(timerId);
        node.removeEventListener(&#039;focus&#039;, stopTypingOnNonTextField);
        node.removeEventListener(&#039;keydown&#039;, stopTypingOnEscapeKey);
        ownerDocument.removeEventListener(&#039;selectionchange&#039;, stopTypingOnSelectionUncollapse);
      };
    }

    /**
     * Handles a keypress or keydown event to infer intention to start
     * typing.
     *
     * @param {KeyboardEvent} event Keypress or keydown event to interpret.
     */
    function startTypingInTextField(event) {
      const {
        type,
        target
      } = event;

      // Abort early if already typing, or key press is incurred outside a
      // text field (e.g. arrow-ing through toolbar buttons).
      // Ignore typing if outside the current DOM container
      if (!(0,external_wp_dom_namespaceObject.isTextField)(target) || !node.contains(target)) {
        return;
      }

      // Special-case keydown because certain keys do not emit a keypress
      // event. Conversely avoid keydown as the canonical event since
      // there are many keydown which are explicitly not targeted for
      // typing.
      if (type === &#039;keydown&#039; &amp;&amp; !isKeyDownEligibleForStartTyping(event)) {
        return;
      }
      startTyping();
    }
    node.addEventListener(&#039;keypress&#039;, startTypingInTextField);
    node.addEventListener(&#039;keydown&#039;, startTypingInTextField);
    return () =&gt; {
      node.removeEventListener(&#039;keypress&#039;, startTypingInTextField);
      node.removeEventListener(&#039;keydown&#039;, startTypingInTextField);
    };
  }, [isTyping, startTyping, stopTyping]);
  return (0,external_wp_compose_namespaceObject.useMergeRefs)([ref1, ref2]);
}
function ObserveTyping({
  children
}) {
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
    ref: useTypingObserver(),
    children: children
  });
}

/**
 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/observe-typing/README.md
 */
/* harmony default export */ const observe_typing = (ObserveTyping);

;// ./node_modules/@wordpress/block-editor/build-module/components/block-list/zoom-out-separator.js
/**
 * External dependencies
 */


/**
 * WordPress dependencies
 */






/**
 * Internal dependencies
 */



function ZoomOutSeparator({
  clientId,
  rootClientId = &#039;&#039;,
  position = &#039;top&#039;
}) {
  const [isDraggedOver, setIsDraggedOver] = (0,external_wp_element_namespaceObject.useState)(false);
  const {
    sectionRootClientId,
    sectionClientIds,
    insertionPoint,
    blockInsertionPointVisible,
    blockInsertionPoint,
    blocksBeingDragged
  } = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      getInsertionPoint,
      getBlockOrder,
      getSectionRootClientId,
      isBlockInsertionPointVisible,
      getBlockInsertionPoint,
      getDraggedBlockClientIds
    } = unlock(select(store));
    const root = getSectionRootClientId();
    const sectionRootClientIds = getBlockOrder(root);
    return {
      sectionRootClientId: root,
      sectionClientIds: sectionRootClientIds,
      blockOrder: getBlockOrder(root),
      insertionPoint: getInsertionPoint(),
      blockInsertionPoint: getBlockInsertionPoint(),
      blockInsertionPointVisible: isBlockInsertionPointVisible(),
      blocksBeingDragged: getDraggedBlockClientIds()
    };
  }, []);
  const isReducedMotion = (0,external_wp_compose_namespaceObject.useReducedMotion)();
  if (!clientId) {
    return;
  }
  let isVisible = false;
  const isSectionBlock = rootClientId === sectionRootClientId &amp;&amp; sectionClientIds &amp;&amp; sectionClientIds.includes(clientId);
  if (!isSectionBlock) {
    return null;
  }
  const hasTopInsertionPoint = insertionPoint?.index === 0 &amp;&amp; clientId === sectionClientIds[insertionPoint.index];
  const hasBottomInsertionPoint = insertionPoint &amp;&amp; insertionPoint.hasOwnProperty(&#039;index&#039;) &amp;&amp; clientId === sectionClientIds[insertionPoint.index - 1];

  // We want to show the zoom out separator in either of these conditions:
  // 1. If the inserter has an insertion index set
  // 2. We are dragging a pattern over an insertion point
  if (position === &#039;top&#039;) {
    isVisible = hasTopInsertionPoint || blockInsertionPointVisible &amp;&amp; blockInsertionPoint.index === 0 &amp;&amp; clientId === sectionClientIds[blockInsertionPoint.index];
  }
  if (position === &#039;bottom&#039;) {
    isVisible = hasBottomInsertionPoint || blockInsertionPointVisible &amp;&amp; clientId === sectionClientIds[blockInsertionPoint.index - 1];
  }
  const blockBeingDraggedClientId = blocksBeingDragged[0];
  const isCurrentBlockBeingDragged = blocksBeingDragged.includes(clientId);
  const blockBeingDraggedIndex = sectionClientIds.indexOf(blockBeingDraggedClientId);
  const blockBeingDraggedPreviousSiblingClientId = blockBeingDraggedIndex &gt; 0 ? sectionClientIds[blockBeingDraggedIndex - 1] : null;
  const isCurrentBlockPreviousSiblingOfBlockBeingDragged = blockBeingDraggedPreviousSiblingClientId === clientId;

  // The separators are visually top/bottom of the block, but in actual fact
  // the &quot;top&quot; separator is the &quot;bottom&quot; separator of the previous block.
  // Therefore, this logic hides the separator if the current block is being dragged
  // or if the current block is the previous sibling of the block being dragged.
  if (isCurrentBlockBeingDragged || isCurrentBlockPreviousSiblingOfBlockBeingDragged) {
    isVisible = false;
  }
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__unstableAnimatePresence, {
    children: isVisible &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__unstableMotion.div, {
      initial: {
        height: 0
      },
      animate: {
        // Use a height equal to that of the zoom out frame size.
        height: &#039;calc(1 * var(--wp-block-editor-iframe-zoom-out-frame-size) / var(--wp-block-editor-iframe-zoom-out-scale)&#039;
      },
      exit: {
        height: 0
      },
      transition: {
        type: &#039;tween&#039;,
        duration: isReducedMotion ? 0 : 0.2,
        ease: [0.6, 0, 0.4, 1]
      },
      className: dist_clsx(&#039;block-editor-block-list__zoom-out-separator&#039;, {
        &#039;is-dragged-over&#039;: isDraggedOver
      }),
      &quot;data-is-insertion-point&quot;: &quot;true&quot;,
      onDragOver: () =&gt; setIsDraggedOver(true),
      onDragLeave: () =&gt; setIsDraggedOver(false),
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__unstableMotion.div, {
        initial: {
          opacity: 0
        },
        animate: {
          opacity: 1
        },
        exit: {
          opacity: 0,
          transition: {
            delay: -0.125
          }
        },
        transition: {
          ease: &#039;linear&#039;,
          duration: 0.1,
          delay: 0.125
        },
        children: (0,external_wp_i18n_namespaceObject.__)(&#039;Drop pattern.&#039;)
      })
    })
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/block-list/index.js
/**
 * External dependencies
 */


/**
 * WordPress dependencies
 */





/**
 * Internal dependencies
 */












const block_list_IntersectionObserver = (0,external_wp_element_namespaceObject.createContext)();
const pendingBlockVisibilityUpdatesPerRegistry = new WeakMap();
function Root({
  className,
  ...settings
}) {
  const {
    isOutlineMode,
    isFocusMode,
    temporarilyEditingAsBlocks
  } = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      getSettings,
      getTemporarilyEditingAsBlocks,
      isTyping
    } = unlock(select(store));
    const {
      outlineMode,
      focusMode
    } = getSettings();
    return {
      isOutlineMode: outlineMode &amp;&amp; !isTyping(),
      isFocusMode: focusMode,
      temporarilyEditingAsBlocks: getTemporarilyEditingAsBlocks()
    };
  }, []);
  const registry = (0,external_wp_data_namespaceObject.useRegistry)();
  const {
    setBlockVisibility
  } = (0,external_wp_data_namespaceObject.useDispatch)(store);
  const delayedBlockVisibilityUpdates = (0,external_wp_compose_namespaceObject.useDebounce)((0,external_wp_element_namespaceObject.useCallback)(() =&gt; {
    const updates = {};
    pendingBlockVisibilityUpdatesPerRegistry.get(registry).forEach(([id, isIntersecting]) =&gt; {
      updates[id] = isIntersecting;
    });
    setBlockVisibility(updates);
  }, [registry]), 300, {
    trailing: true
  });
  const intersectionObserver = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; {
    const {
      IntersectionObserver: Observer
    } = window;
    if (!Observer) {
      return;
    }
    return new Observer(entries =&gt; {
      if (!pendingBlockVisibilityUpdatesPerRegistry.get(registry)) {
        pendingBlockVisibilityUpdatesPerRegistry.set(registry, []);
      }
      for (const entry of entries) {
        const clientId = entry.target.getAttribute(&#039;data-block&#039;);
        pendingBlockVisibilityUpdatesPerRegistry.get(registry).push([clientId, entry.isIntersecting]);
      }
      delayedBlockVisibilityUpdates();
    });
  }, []);
  const innerBlocksProps = useInnerBlocksProps({
    ref: (0,external_wp_compose_namespaceObject.useMergeRefs)([useBlockSelectionClearer(), useInBetweenInserter(), useTypingObserver()]),
    className: dist_clsx(&#039;is-root-container&#039;, className, {
      &#039;is-outline-mode&#039;: isOutlineMode,
      &#039;is-focus-mode&#039;: isFocusMode
    })
  }, settings);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(block_list_IntersectionObserver.Provider, {
    value: intersectionObserver,
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
      ...innerBlocksProps
    }), !!temporarilyEditingAsBlocks &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(StopEditingAsBlocksOnOutsideSelect, {
      clientId: temporarilyEditingAsBlocks
    })]
  });
}
function StopEditingAsBlocksOnOutsideSelect({
  clientId
}) {
  const {
    stopEditingAsBlocks
  } = unlock((0,external_wp_data_namespaceObject.useDispatch)(store));
  const isBlockOrDescendantSelected = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      isBlockSelected,
      hasSelectedInnerBlock
    } = select(store);
    return isBlockSelected(clientId) || hasSelectedInnerBlock(clientId, true);
  }, [clientId]);
  (0,external_wp_element_namespaceObject.useEffect)(() =&gt; {
    if (!isBlockOrDescendantSelected) {
      stopEditingAsBlocks(clientId);
    }
  }, [isBlockOrDescendantSelected, clientId, stopEditingAsBlocks]);
  return null;
}
function BlockList(settings) {
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Provider, {
    value: DEFAULT_BLOCK_EDIT_CONTEXT,
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Root, {
      ...settings
    })
  });
}
const block_list_EMPTY_ARRAY = [];
const block_list_EMPTY_SET = new Set();
function Items({
  placeholder,
  rootClientId,
  renderAppender: CustomAppender,
  __experimentalAppenderTagName,
  layout = defaultLayout
}) {
  // Avoid passing CustomAppender to useSelect because it could be a new
  // function on every render.
  const hasAppender = CustomAppender !== false;
  const hasCustomAppender = !!CustomAppender;
  const {
    order,
    isZoomOut,
    selectedBlocks,
    visibleBlocks,
    shouldRenderAppender
  } = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      getSettings,
      getBlockOrder,
      getSelectedBlockClientIds,
      __unstableGetVisibleBlocks,
      getTemplateLock,
      getBlockEditingMode,
      isSectionBlock,
      isZoomOut: _isZoomOut,
      canInsertBlockType
    } = unlock(select(store));
    const _order = getBlockOrder(rootClientId);
    if (getSettings().isPreviewMode) {
      return {
        order: _order,
        selectedBlocks: block_list_EMPTY_ARRAY,
        visibleBlocks: block_list_EMPTY_SET
      };
    }
    const selectedBlockClientIds = getSelectedBlockClientIds();
    const selectedBlockClientId = selectedBlockClientIds[0];
    const showRootAppender = !rootClientId &amp;&amp; !selectedBlockClientId &amp;&amp; (!_order.length || !canInsertBlockType((0,external_wp_blocks_namespaceObject.getDefaultBlockName)(), rootClientId));
    const hasSelectedRoot = !!(rootClientId &amp;&amp; selectedBlockClientId &amp;&amp; rootClientId === selectedBlockClientId);
    return {
      order: _order,
      selectedBlocks: selectedBlockClientIds,
      visibleBlocks: __unstableGetVisibleBlocks(),
      isZoomOut: _isZoomOut(),
      shouldRenderAppender: !isSectionBlock(rootClientId) &amp;&amp; getBlockEditingMode(rootClientId) !== &#039;disabled&#039; &amp;&amp; !getTemplateLock(rootClientId) &amp;&amp; hasAppender &amp;&amp; !_isZoomOut() &amp;&amp; (hasCustomAppender || hasSelectedRoot || showRootAppender)
    };
  }, [rootClientId, hasAppender, hasCustomAppender]);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(LayoutProvider, {
    value: layout,
    children: [order.map(clientId =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_data_namespaceObject.AsyncModeProvider, {
      value:
      // Only provide data asynchronously if the block is
      // not visible and not selected.
      !visibleBlocks.has(clientId) &amp;&amp; !selectedBlocks.includes(clientId),
      children: [isZoomOut &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ZoomOutSeparator, {
        clientId: clientId,
        rootClientId: rootClientId,
        position: &quot;top&quot;
      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block, {
        rootClientId: rootClientId,
        clientId: clientId
      }), isZoomOut &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ZoomOutSeparator, {
        clientId: clientId,
        rootClientId: rootClientId,
        position: &quot;bottom&quot;
      })]
    }, clientId)), order.length &lt; 1 &amp;&amp; placeholder, shouldRenderAppender &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockListAppender, {
      tagName: __experimentalAppenderTagName,
      rootClientId: rootClientId,
      CustomAppender: CustomAppender
    })]
  });
}
function BlockListItems(props) {
  // This component needs to always be synchronous as it&#039;s the one changing
  // the async mode depending on the block selection.
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_data_namespaceObject.AsyncModeProvider, {
    value: false,
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Items, {
      ...props
    })
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/writing-flow/use-multi-selection.js
/**
 * WordPress dependencies
 */



/**
 * Internal dependencies
 */

function selector(select) {
  const {
    isMultiSelecting,
    getMultiSelectedBlockClientIds,
    hasMultiSelection,
    getSelectedBlockClientId,
    getSelectedBlocksInitialCaretPosition,
    __unstableIsFullySelected
  } = select(store);
  return {
    isMultiSelecting: isMultiSelecting(),
    multiSelectedBlockClientIds: getMultiSelectedBlockClientIds(),
    hasMultiSelection: hasMultiSelection(),
    selectedBlockClientId: getSelectedBlockClientId(),
    initialPosition: getSelectedBlocksInitialCaretPosition(),
    isFullSelection: __unstableIsFullySelected()
  };
}
function useMultiSelection() {
  const {
    initialPosition,
    isMultiSelecting,
    multiSelectedBlockClientIds,
    hasMultiSelection,
    selectedBlockClientId,
    isFullSelection
  } = (0,external_wp_data_namespaceObject.useSelect)(selector, []);

  /**
   * When the component updates, and there is multi selection, we need to
   * select the entire block contents.
   */
  return (0,external_wp_compose_namespaceObject.useRefEffect)(node =&gt; {
    const {
      ownerDocument
    } = node;
    const {
      defaultView
    } = ownerDocument;

    // Allow initialPosition to bypass focus behavior. This is useful
    // for the list view or other areas where we don&#039;t want to transfer
    // focus to the editor canvas.
    if (initialPosition === undefined || initialPosition === null) {
      return;
    }
    if (!hasMultiSelection || isMultiSelecting) {
      return;
    }
    const {
      length
    } = multiSelectedBlockClientIds;
    if (length &lt; 2) {
      return;
    }
    if (!isFullSelection) {
      return;
    }

    // Allow cross contentEditable selection by temporarily making
    // all content editable. We can&#039;t rely on using the store and
    // React because re-rending happens too slowly. We need to be
    // able to select across instances immediately.
    node.contentEditable = true;

    // For some browsers, like Safari, it is important that focus
    // happens BEFORE selection removal.
    node.focus();
    defaultView.getSelection().removeAllRanges();
  }, [hasMultiSelection, isMultiSelecting, multiSelectedBlockClientIds, selectedBlockClientId, initialPosition, isFullSelection]);
}

;// ./node_modules/@wordpress/block-editor/build-module/components/writing-flow/use-tab-nav.js
/**
 * WordPress dependencies
 */






/**
 * Internal dependencies
 */




function useTabNav() {
  const containerRef = /** @type {typeof useRef&lt;HTMLElement&gt;} */(0,external_wp_element_namespaceObject.useRef)();
  const focusCaptureBeforeRef = (0,external_wp_element_namespaceObject.useRef)();
  const focusCaptureAfterRef = (0,external_wp_element_namespaceObject.useRef)();
  const {
    hasMultiSelection,
    getSelectedBlockClientId,
    getBlockCount,
    getBlockOrder,
    getLastFocus,
    getSectionRootClientId,
    isZoomOut
  } = unlock((0,external_wp_data_namespaceObject.useSelect)(store));
  const {
    setLastFocus
  } = unlock((0,external_wp_data_namespaceObject.useDispatch)(store));

  // Reference that holds the a flag for enabling or disabling
  // capturing on the focus capture elements.
  const noCaptureRef = (0,external_wp_element_namespaceObject.useRef)();
  function onFocusCapture(event) {
    const canvasElement = containerRef.current.ownerDocument === event.target.ownerDocument ? containerRef.current : containerRef.current.ownerDocument.defaultView.frameElement;

    // Do not capture incoming focus if set by us in WritingFlow.
    if (noCaptureRef.current) {
      noCaptureRef.current = null;
    } else if (hasMultiSelection()) {
      containerRef.current.focus();
    } else if (getSelectedBlockClientId()) {
      if (getLastFocus()?.current) {
        getLastFocus().current.focus();
      } else {
        // Handles when the last focus has not been set yet, or has been cleared by new blocks being added via the inserter.
        containerRef.current.querySelector(`[data-block=&quot;${getSelectedBlockClientId()}&quot;]`).focus();
      }
    }
    // In &quot;compose&quot; mode without a selected ID, we want to place focus on the section root when tabbing to the canvas.
    else if (isZoomOut()) {
      const sectionRootClientId = getSectionRootClientId();
      const sectionBlocks = getBlockOrder(sectionRootClientId);

      // If we have section within the section root, focus the first one.
      if (sectionBlocks.length) {
        containerRef.current.querySelector(`[data-block=&quot;${sectionBlocks[0]}&quot;]`).focus();
      }
      // If we don&#039;t have any section blocks, focus the section root.
      else if (sectionRootClientId) {
        containerRef.current.querySelector(`[data-block=&quot;${sectionRootClientId}&quot;]`).focus();
      } else {
        // If we don&#039;t have any section root, focus the canvas.
        canvasElement.focus();
      }
    } else {
      const isBefore =
      // eslint-disable-next-line no-bitwise
      event.target.compareDocumentPosition(canvasElement) &amp; event.target.DOCUMENT_POSITION_FOLLOWING;
      const tabbables = external_wp_dom_namespaceObject.focus.tabbable.find(containerRef.current);
      if (tabbables.length) {
        const next = isBefore ? tabbables[0] : tabbables[tabbables.length - 1];
        next.focus();
      }
    }
  }
  const before = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
    ref: focusCaptureBeforeRef,
    tabIndex: &quot;0&quot;,
    onFocus: onFocusCapture
  });
  const after = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
    ref: focusCaptureAfterRef,
    tabIndex: &quot;0&quot;,
    onFocus: onFocusCapture
  });
  const ref = (0,external_wp_compose_namespaceObject.useRefEffect)(node =&gt; {
    function onKeyDown(event) {
      if (event.defaultPrevented) {
        return;
      }

      // In Edit mode, Tab should focus the first tabbable element after
      // the content, which is normally the sidebar (with block controls)
      // and Shift+Tab should focus the first tabbable element before the
      // content, which is normally the block toolbar.
      // Arrow keys can be used, and Tab and arrow keys can be used in
      // Navigation mode (press Esc), to navigate through blocks.
      if (event.keyCode !== external_wp_keycodes_namespaceObject.TAB) {
        return;
      }
      if (
      // Bails in case the focus capture elements aren’t present. They
      // may be omitted to avoid silent tab stops in preview mode.
      // See: https://github.com/WordPress/gutenberg/pull/59317
      !focusCaptureAfterRef.current || !focusCaptureBeforeRef.current) {
        return;
      }
      const {
        target,
        shiftKey: isShift
      } = event;
      const direction = isShift ? &#039;findPrevious&#039; : &#039;findNext&#039;;
      const nextTabbable = external_wp_dom_namespaceObject.focus.tabbable[direction](target);

      // We want to constrain the tabbing to the block and its child blocks.
      // If the preceding form element is within a different block,
      // such as two sibling image blocks in the placeholder state,
      // we want shift + tab from the first form element to move to the image
      // block toolbar and not the previous image block&#039;s form element.
      const currentBlock = target.closest(&#039;[data-block]&#039;);
      const isElementPartOfSelectedBlock = currentBlock &amp;&amp; nextTabbable &amp;&amp; (isInSameBlock(currentBlock, nextTabbable) || isInsideRootBlock(currentBlock, nextTabbable));

      // Allow tabbing from the block wrapper to a form element,
      // and between form elements rendered in a block and its child blocks,
      // such as inside a placeholder. Form elements are generally
      // meant to be UI rather than part of the content. Ideally
      // these are not rendered in the content and perhaps in the
      // future they can be rendered in an iframe or shadow DOM.
      if ((0,external_wp_dom_namespaceObject.isFormElement)(nextTabbable) &amp;&amp; isElementPartOfSelectedBlock) {
        return;
      }
      const next = isShift ? focusCaptureBeforeRef : focusCaptureAfterRef;

      // Disable focus capturing on the focus capture element, so it
      // doesn&#039;t refocus this block and so it allows default behaviour
      // (moving focus to the next tabbable element).
      noCaptureRef.current = true;

      // Focusing the focus capture element, which is located above and
      // below the editor, should not scroll the page all the way up or
      // down.
      next.current.focus({
        preventScroll: true
      });
    }
    function onFocusOut(event) {
      setLastFocus({
        ...getLastFocus(),
        current: event.target
      });
      const {
        ownerDocument
      } = node;

      // If focus disappears due to there being no blocks, move focus to
      // the writing flow wrapper.
      if (!event.relatedTarget &amp;&amp; event.target.hasAttribute(&#039;data-block&#039;) &amp;&amp; ownerDocument.activeElement === ownerDocument.body &amp;&amp; getBlockCount() === 0) {
        node.focus();
      }
    }

    // When tabbing back to an element in block list, this event handler prevents scrolling if the
    // focus capture divs (before/after) are outside of the viewport. (For example shift+tab back to a paragraph
    // when focus is on a sidebar element. This prevents the scrollable writing area from jumping either to the
    // top or bottom of the document.
    //
    // Note that it isn&#039;t possible to disable scrolling in the onFocus event. We need to intercept this
    // earlier in the keypress handler, and call focus( { preventScroll: true } ) instead.
    // https://developer.mozilla.org/en-US/docs/Web/API/HTMLOrForeignElement/focus#parameters
    function preventScrollOnTab(event) {
      if (event.keyCode !== external_wp_keycodes_namespaceObject.TAB) {
        return;
      }
      if (event.target?.getAttribute(&#039;role&#039;) === &#039;region&#039;) {
        return;
      }
      if (containerRef.current === event.target) {
        return;
      }
      const isShift = event.shiftKey;
      const direction = isShift ? &#039;findPrevious&#039; : &#039;findNext&#039;;
      const target = external_wp_dom_namespaceObject.focus.tabbable[direction](event.target);
      // Only do something when the next tabbable is a focus capture div (before/after)
      if (target === focusCaptureBeforeRef.current || target === focusCaptureAfterRef.current) {
        event.preventDefault();
        target.focus({
          preventScroll: true
        });
      }
    }
    const {
      ownerDocument
    } = node;
    const {
      defaultView
    } = ownerDocument;
    defaultView.addEventListener(&#039;keydown&#039;, preventScrollOnTab);
    node.addEventListener(&#039;keydown&#039;, onKeyDown);
    node.addEventListener(&#039;focusout&#039;, onFocusOut);
    return () =&gt; {
      defaultView.removeEventListener(&#039;keydown&#039;, preventScrollOnTab);
      node.removeEventListener(&#039;keydown&#039;, onKeyDown);
      node.removeEventListener(&#039;focusout&#039;, onFocusOut);
    };
  }, []);
  const mergedRefs = (0,external_wp_compose_namespaceObject.useMergeRefs)([containerRef, ref]);
  return [before, mergedRefs, after];
}

;// ./node_modules/@wordpress/block-editor/build-module/components/writing-flow/use-arrow-nav.js
/**
 * WordPress dependencies
 */





/**
 * Internal dependencies
 */



/**
 * Returns true if the element should consider edge navigation upon a keyboard
 * event of the given directional key code, or false otherwise.
 *
 * @param {Element} element     HTML element to test.
 * @param {number}  keyCode     KeyboardEvent keyCode to test.
 * @param {boolean} hasModifier Whether a modifier is pressed.
 *
 * @return {boolean} Whether element should consider edge navigation.
 */
function isNavigationCandidate(element, keyCode, hasModifier) {
  const isVertical = keyCode === external_wp_keycodes_namespaceObject.UP || keyCode === external_wp_keycodes_namespaceObject.DOWN;
  const {
    tagName
  } = element;
  const elementType = element.getAttribute(&#039;type&#039;);

  // Native inputs should not navigate vertically, unless they are simple types that don&#039;t need up/down arrow keys.
  if (isVertical &amp;&amp; !hasModifier) {
    if (tagName === &#039;INPUT&#039;) {
      const verticalInputTypes = [&#039;date&#039;, &#039;datetime-local&#039;, &#039;month&#039;, &#039;number&#039;, &#039;range&#039;, &#039;time&#039;, &#039;week&#039;];
      return !verticalInputTypes.includes(elementType);
    }
    return true;
  }

  // Native inputs should not navigate horizontally, unless they are simple types that don&#039;t need left/right arrow keys.
  if (tagName === &#039;INPUT&#039;) {
    const simpleInputTypes = [&#039;button&#039;, &#039;checkbox&#039;, &#039;number&#039;, &#039;color&#039;, &#039;file&#039;, &#039;image&#039;, &#039;radio&#039;, &#039;reset&#039;, &#039;submit&#039;];
    return simpleInputTypes.includes(elementType);
  }

  // Native textareas should not navigate horizontally.
  return tagName !== &#039;TEXTAREA&#039;;
}

/**
 * Returns the optimal tab target from the given focused element in the desired
 * direction. A preference is made toward text fields, falling back to the block
 * focus stop if no other candidates exist for the block.
 *
 * @param {Element} target           Currently focused text field.
 * @param {boolean} isReverse        True if considering as the first field.
 * @param {Element} containerElement Element containing all blocks.
 * @param {boolean} onlyVertical     Whether to only consider tabbable elements
 *                                   that are visually above or under the
 *                                   target.
 *
 * @return {?Element} Optimal tab target, if one exists.
 */
function getClosestTabbable(target, isReverse, containerElement, onlyVertical) {
  // Since the current focus target is not guaranteed to be a text field, find
  // all focusables. Tabbability is considered later.
  let focusableNodes = external_wp_dom_namespaceObject.focus.focusable.find(containerElement);
  if (isReverse) {
    focusableNodes.reverse();
  }

  // Consider as candidates those focusables after the current target. It&#039;s
  // assumed this can only be reached if the target is focusable (on its
  // keydown event), so no need to verify it exists in the set.
  focusableNodes = focusableNodes.slice(focusableNodes.indexOf(target) + 1);
  let targetRect;
  if (onlyVertical) {
    targetRect = target.getBoundingClientRect();
  }
  function isTabCandidate(node) {
    if (node.closest(&#039;[inert]&#039;)) {
      return;
    }

    // Skip if there&#039;s only one child that is content editable (and thus a
    // better candidate).
    if (node.children.length === 1 &amp;&amp; isInSameBlock(node, node.firstElementChild) &amp;&amp; node.firstElementChild.getAttribute(&#039;contenteditable&#039;) === &#039;true&#039;) {
      return;
    }

    // Not a candidate if the node is not tabbable.
    if (!external_wp_dom_namespaceObject.focus.tabbable.isTabbableIndex(node)) {
      return false;
    }

    // Skip focusable elements such as links within content editable nodes.
    if (node.isContentEditable &amp;&amp; node.contentEditable !== &#039;true&#039;) {
      return false;
    }
    if (onlyVertical) {
      const nodeRect = node.getBoundingClientRect();
      if (nodeRect.left &gt;= targetRect.right || nodeRect.right &lt;= targetRect.left) {
        return false;
      }
    }
    return true;
  }
  return focusableNodes.find(isTabCandidate);
}
function useArrowNav() {
  const {
    getMultiSelectedBlocksStartClientId,
    getMultiSelectedBlocksEndClientId,
    getSettings,
    hasMultiSelection,
    __unstableIsFullySelected
  } = (0,external_wp_data_namespaceObject.useSelect)(store);
  const {
    selectBlock
  } = (0,external_wp_data_namespaceObject.useDispatch)(store);
  return (0,external_wp_compose_namespaceObject.useRefEffect)(node =&gt; {
    // Here a DOMRect is stored while moving the caret vertically so
    // vertical position of the start position can be restored. This is to
    // recreate browser behaviour across blocks.
    let verticalRect;
    function onMouseDown() {
      verticalRect = null;
    }
    function isClosestTabbableABlock(target, isReverse) {
      const closestTabbable = getClosestTabbable(target, isReverse, node);
      return closestTabbable &amp;&amp; getBlockClientId(closestTabbable);
    }
    function onKeyDown(event) {
      // Abort if navigation has already been handled (e.g. RichText
      // inline boundaries).
      if (event.defaultPrevented) {
        return;
      }
      const {
        keyCode,
        target,
        shiftKey,
        ctrlKey,
        altKey,
        metaKey
      } = event;
      const isUp = keyCode === external_wp_keycodes_namespaceObject.UP;
      const isDown = keyCode === external_wp_keycodes_namespaceObject.DOWN;
      const isLeft = keyCode === external_wp_keycodes_namespaceObject.LEFT;
      const isRight = keyCode === external_wp_keycodes_namespaceObject.RIGHT;
      const isReverse = isUp || isLeft;
      const isHorizontal = isLeft || isRight;
      const isVertical = isUp || isDown;
      const isNav = isHorizontal || isVertical;
      const hasModifier = shiftKey || ctrlKey || altKey || metaKey;
      const isNavEdge = isVertical ? external_wp_dom_namespaceObject.isVerticalEdge : external_wp_dom_namespaceObject.isHorizontalEdge;
      const {
        ownerDocument
      } = node;
      const {
        defaultView
      } = ownerDocument;
      if (!isNav) {
        return;
      }

      // If there is a multi-selection, the arrow keys should collapse the
      // selection to the start or end of the selection.
      if (hasMultiSelection()) {
        if (shiftKey) {
          return;
        }

        // Only handle if we have a full selection (not a native partial
        // selection).
        if (!__unstableIsFullySelected()) {
          return;
        }
        event.preventDefault();
        if (isReverse) {
          selectBlock(getMultiSelectedBlocksStartClientId());
        } else {
          selectBlock(getMultiSelectedBlocksEndClientId(), -1);
        }
        return;
      }

      // Abort if our current target is not a candidate for navigation
      // (e.g. preserve native input behaviors).
      if (!isNavigationCandidate(target, keyCode, hasModifier)) {
        return;
      }

      // When presing any key other than up or down, the initial vertical
      // position must ALWAYS be reset. The vertical position is saved so
      // it can be restored as well as possible on sebsequent vertical
      // arrow key presses. It may not always be possible to restore the
      // exact same position (such as at an empty line), so it wouldn&#039;t be
      // good to compute the position right before any vertical arrow key
      // press.
      if (!isVertical) {
        verticalRect = null;
      } else if (!verticalRect) {
        verticalRect = (0,external_wp_dom_namespaceObject.computeCaretRect)(defaultView);
      }

      // In the case of RTL scripts, right means previous and left means
      // next, which is the exact reverse of LTR.
      const isReverseDir = (0,external_wp_dom_namespaceObject.isRTL)(target) ? !isReverse : isReverse;
      const {
        keepCaretInsideBlock
      } = getSettings();
      if (shiftKey) {
        if (isClosestTabbableABlock(target, isReverse) &amp;&amp; isNavEdge(target, isReverse)) {
          node.contentEditable = true;
          // Firefox doesn&#039;t automatically move focus.
          node.focus();
        }
      } else if (isVertical &amp;&amp; (0,external_wp_dom_namespaceObject.isVerticalEdge)(target, isReverse) &amp;&amp; (
      // When Alt is pressed, only intercept if the caret is also at
      // the horizontal edge.
      altKey ? (0,external_wp_dom_namespaceObject.isHorizontalEdge)(target, isReverseDir) : true) &amp;&amp; !keepCaretInsideBlock) {
        const closestTabbable = getClosestTabbable(target, isReverse, node, true);
        if (closestTabbable) {
          (0,external_wp_dom_namespaceObject.placeCaretAtVerticalEdge)(closestTabbable,
          // When Alt is pressed, place the caret at the furthest
          // horizontal edge and the furthest vertical edge.
          altKey ? !isReverse : isReverse, altKey ? undefined : verticalRect);
          event.preventDefault();
        }
      } else if (isHorizontal &amp;&amp; defaultView.getSelection().isCollapsed &amp;&amp; (0,external_wp_dom_namespaceObject.isHorizontalEdge)(target, isReverseDir) &amp;&amp; !keepCaretInsideBlock) {
        const closestTabbable = getClosestTabbable(target, isReverseDir, node);
        (0,external_wp_dom_namespaceObject.placeCaretAtHorizontalEdge)(closestTabbable, isReverse);
        event.preventDefault();
      }
    }
    node.addEventListener(&#039;mousedown&#039;, onMouseDown);
    node.addEventListener(&#039;keydown&#039;, onKeyDown);
    return () =&gt; {
      node.removeEventListener(&#039;mousedown&#039;, onMouseDown);
      node.removeEventListener(&#039;keydown&#039;, onKeyDown);
    };
  }, []);
}

;// ./node_modules/@wordpress/block-editor/build-module/components/writing-flow/use-select-all.js
/**
 * WordPress dependencies
 */





/**
 * Internal dependencies
 */

function useSelectAll() {
  const {
    getBlockOrder,
    getSelectedBlockClientIds,
    getBlockRootClientId
  } = (0,external_wp_data_namespaceObject.useSelect)(store);
  const {
    multiSelect,
    selectBlock
  } = (0,external_wp_data_namespaceObject.useDispatch)(store);
  const isMatch = (0,external_wp_keyboardShortcuts_namespaceObject.__unstableUseShortcutEventMatch)();
  return (0,external_wp_compose_namespaceObject.useRefEffect)(node =&gt; {
    function onKeyDown(event) {
      if (!isMatch(&#039;core/block-editor/select-all&#039;, event)) {
        return;
      }
      const selectedClientIds = getSelectedBlockClientIds();
      if (selectedClientIds.length &lt; 2 &amp;&amp; !(0,external_wp_dom_namespaceObject.isEntirelySelected)(event.target)) {
        return;
      }
      event.preventDefault();
      const [firstSelectedClientId] = selectedClientIds;
      const rootClientId = getBlockRootClientId(firstSelectedClientId);
      const blockClientIds = getBlockOrder(rootClientId);

      // If we have selected all sibling nested blocks, try selecting up a
      // level. See: https://github.com/WordPress/gutenberg/pull/31859/
      if (selectedClientIds.length === blockClientIds.length) {
        if (rootClientId) {
          node.ownerDocument.defaultView.getSelection().removeAllRanges();
          selectBlock(rootClientId);
        }
        return;
      }
      multiSelect(blockClientIds[0], blockClientIds[blockClientIds.length - 1]);
    }
    node.addEventListener(&#039;keydown&#039;, onKeyDown);
    return () =&gt; {
      node.removeEventListener(&#039;keydown&#039;, onKeyDown);
    };
  }, []);
}

;// ./node_modules/@wordpress/block-editor/build-module/components/writing-flow/use-drag-selection.js
/**
 * WordPress dependencies
 */



/**
 * Internal dependencies
 */


/**
 * Sets the `contenteditable` wrapper element to `value`.
 *
 * @param {HTMLElement} node  Block element.
 * @param {boolean}     value `contentEditable` value (true or false)
 */
function setContentEditableWrapper(node, value) {
  node.contentEditable = value;
  // Firefox doesn&#039;t automatically move focus.
  if (value) {
    node.focus();
  }
}

/**
 * Sets a multi-selection based on the native selection across blocks.
 */
function useDragSelection() {
  const {
    startMultiSelect,
    stopMultiSelect
  } = (0,external_wp_data_namespaceObject.useDispatch)(store);
  const {
    isSelectionEnabled,
    hasSelectedBlock,
    isDraggingBlocks,
    isMultiSelecting
  } = (0,external_wp_data_namespaceObject.useSelect)(store);
  return (0,external_wp_compose_namespaceObject.useRefEffect)(node =&gt; {
    const {
      ownerDocument
    } = node;
    const {
      defaultView
    } = ownerDocument;
    let anchorElement;
    let rafId;
    function onMouseUp() {
      stopMultiSelect();
      // Equivalent to attaching the listener once.
      defaultView.removeEventListener(&#039;mouseup&#039;, onMouseUp);
      // The browser selection won&#039;t have updated yet at this point,
      // so wait until the next animation frame to get the browser
      // selection.
      rafId = defaultView.requestAnimationFrame(() =&gt; {
        if (!hasSelectedBlock()) {
          return;
        }

        // If the selection is complete (on mouse up), and no
        // multiple blocks have been selected, set focus back to the
        // anchor element. if the anchor element contains the
        // selection. Additionally, the contentEditable wrapper can
        // now be disabled again.
        setContentEditableWrapper(node, false);
        const selection = defaultView.getSelection();
        if (selection.rangeCount) {
          const range = selection.getRangeAt(0);
          const {
            commonAncestorContainer
          } = range;
          const clonedRange = range.cloneRange();
          if (anchorElement.contains(commonAncestorContainer)) {
            anchorElement.focus();
            selection.removeAllRanges();
            selection.addRange(clonedRange);
          }
        }
      });
    }
    let lastMouseDownTarget;
    function onMouseDown({
      target
    }) {
      lastMouseDownTarget = target;
    }
    function onMouseLeave({
      buttons,
      target,
      relatedTarget
    }) {
      if (!target.contains(lastMouseDownTarget)) {
        return;
      }

      // If we&#039;re moving into a child element, ignore. We&#039;re tracking
      // the mouse leaving the element to a parent, no a child.
      if (target.contains(relatedTarget)) {
        return;
      }

      // Avoid triggering a multi-selection if the user is already
      // dragging blocks.
      if (isDraggingBlocks()) {
        return;
      }

      // The primary button must be pressed to initiate selection.
      // See https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/buttons
      if (buttons !== 1) {
        return;
      }

      // Abort if we are already multi-selecting.
      if (isMultiSelecting()) {
        return;
      }

      // Abort if selection is leaving writing flow.
      if (node === target) {
        return;
      }

      // Check the attribute, not the contentEditable attribute. All
      // child elements of the content editable wrapper are editable
      // and return true for this property. We only want to start
      // multi selecting when the mouse leaves the wrapper.
      if (target.getAttribute(&#039;contenteditable&#039;) !== &#039;true&#039;) {
        return;
      }
      if (!isSelectionEnabled()) {
        return;
      }

      // Do not rely on the active element because it may change after
      // the mouse leaves for the first time. See
      // https://github.com/WordPress/gutenberg/issues/48747.
      anchorElement = target;
      startMultiSelect();

      // `onSelectionStart` is called after `mousedown` and
      // `mouseleave` (from a block). The selection ends when
      // `mouseup` happens anywhere in the window.
      defaultView.addEventListener(&#039;mouseup&#039;, onMouseUp);

      // Allow cross contentEditable selection by temporarily making
      // all content editable. We can&#039;t rely on using the store and
      // React because re-rending happens too slowly. We need to be
      // able to select across instances immediately.
      setContentEditableWrapper(node, true);
    }
    node.addEventListener(&#039;mouseout&#039;, onMouseLeave);
    node.addEventListener(&#039;mousedown&#039;, onMouseDown);
    return () =&gt; {
      node.removeEventListener(&#039;mouseout&#039;, onMouseLeave);
      defaultView.removeEventListener(&#039;mouseup&#039;, onMouseUp);
      defaultView.cancelAnimationFrame(rafId);
    };
  }, [startMultiSelect, stopMultiSelect, isSelectionEnabled, hasSelectedBlock]);
}

;// ./node_modules/@wordpress/block-editor/build-module/components/writing-flow/use-selection-observer.js
/**
 * WordPress dependencies
 */





/**
 * Internal dependencies
 */



/**
 * Extract the selection start node from the selection. When the anchor node is
 * not a text node, the selection offset is the index of a child node.
 *
 * @param {Selection} selection The selection.
 *
 * @return {Element} The selection start node.
 */
function extractSelectionStartNode(selection) {
  const {
    anchorNode,
    anchorOffset
  } = selection;
  if (anchorNode.nodeType === anchorNode.TEXT_NODE) {
    return anchorNode;
  }
  if (anchorOffset === 0) {
    return anchorNode;
  }
  return anchorNode.childNodes[anchorOffset - 1];
}

/**
 * Extract the selection end node from the selection. When the focus node is not
 * a text node, the selection offset is the index of a child node. The selection
 * reaches up to but excluding that child node.
 *
 * @param {Selection} selection The selection.
 *
 * @return {Element} The selection start node.
 */
function extractSelectionEndNode(selection) {
  const {
    focusNode,
    focusOffset
  } = selection;
  if (focusNode.nodeType === focusNode.TEXT_NODE) {
    return focusNode;
  }
  if (focusOffset === focusNode.childNodes.length) {
    return focusNode;
  }

  // When the selection is forward (the selection ends with the focus node),
  // the selection may extend into the next element with an offset of 0. This
  // may trigger multi selection even though the selection does not visually
  // end in the next block.
  if (focusOffset === 0 &amp;&amp; (0,external_wp_dom_namespaceObject.isSelectionForward)(selection)) {
    var _focusNode$previousSi;
    return (_focusNode$previousSi = focusNode.previousSibling) !== null &amp;&amp; _focusNode$previousSi !== void 0 ? _focusNode$previousSi : focusNode.parentElement;
  }
  return focusNode.childNodes[focusOffset];
}
function findDepth(a, b) {
  let depth = 0;
  while (a[depth] === b[depth]) {
    depth++;
  }
  return depth;
}

/**
 * Sets the `contenteditable` wrapper element to `value`.
 *
 * @param {HTMLElement} node  Block element.
 * @param {boolean}     value `contentEditable` value (true or false)
 */
function use_selection_observer_setContentEditableWrapper(node, value) {
  // Since we are calling this on every selection change, check if the value
  // needs to be updated first because it trigger the browser to recalculate
  // style.
  if (node.contentEditable !== String(value)) {
    node.contentEditable = value;

    // Firefox doesn&#039;t automatically move focus.
    if (value) {
      node.focus();
    }
  }
}
function getRichTextElement(node) {
  const element = node.nodeType === node.ELEMENT_NODE ? node : node.parentElement;
  return element?.closest(&#039;[data-wp-block-attribute-key]&#039;);
}

/**
 * Sets a multi-selection based on the native selection across blocks.
 */
function useSelectionObserver() {
  const {
    multiSelect,
    selectBlock,
    selectionChange
  } = (0,external_wp_data_namespaceObject.useDispatch)(store);
  const {
    getBlockParents,
    getBlockSelectionStart,
    isMultiSelecting
  } = (0,external_wp_data_namespaceObject.useSelect)(store);
  return (0,external_wp_compose_namespaceObject.useRefEffect)(node =&gt; {
    const {
      ownerDocument
    } = node;
    const {
      defaultView
    } = ownerDocument;
    function onSelectionChange(event) {
      const selection = defaultView.getSelection();
      if (!selection.rangeCount) {
        return;
      }
      const startNode = extractSelectionStartNode(selection);
      const endNode = extractSelectionEndNode(selection);
      if (!node.contains(startNode) || !node.contains(endNode)) {
        return;
      }

      // If selection is collapsed and we haven&#039;t used `shift+click`,
      // end multi selection and disable the contentEditable wrapper.
      // We have to check about `shift+click` case because elements
      // that don&#039;t support text selection might be involved, and we might
      // update the clientIds to multi-select blocks.
      // For now we check if the event is a `mouse` event.
      const isClickShift = event.shiftKey &amp;&amp; event.type === &#039;mouseup&#039;;
      if (selection.isCollapsed &amp;&amp; !isClickShift) {
        if (node.contentEditable === &#039;true&#039; &amp;&amp; !isMultiSelecting()) {
          use_selection_observer_setContentEditableWrapper(node, false);
          let element = startNode.nodeType === startNode.ELEMENT_NODE ? startNode : startNode.parentElement;
          element = element?.closest(&#039;[contenteditable]&#039;);
          element?.focus();
        }
        return;
      }
      let startClientId = getBlockClientId(startNode);
      let endClientId = getBlockClientId(endNode);

      // If the selection has changed and we had pressed `shift+click`,
      // we need to check if in an element that doesn&#039;t support
      // text selection has been clicked.
      if (isClickShift) {
        const selectedClientId = getBlockSelectionStart();
        const clickedClientId = getBlockClientId(event.target);
        // `endClientId` is not defined if we end the selection by clicking a non-selectable block.
        // We need to check if there was already a selection with a non-selectable focusNode.
        const focusNodeIsNonSelectable = clickedClientId !== endClientId;
        if (startClientId === endClientId &amp;&amp; selection.isCollapsed || !endClientId || focusNodeIsNonSelectable) {
          endClientId = clickedClientId;
        }
        // Handle the case when we have a non-selectable block
        // selected and click another one.
        if (startClientId !== selectedClientId) {
          startClientId = selectedClientId;
        }
      }

      // If the selection did not involve a block, return.
      if (startClientId === undefined &amp;&amp; endClientId === undefined) {
        use_selection_observer_setContentEditableWrapper(node, false);
        return;
      }
      const isSingularSelection = startClientId === endClientId;
      if (isSingularSelection) {
        if (!isMultiSelecting()) {
          selectBlock(startClientId);
        } else {
          multiSelect(startClientId, startClientId);
        }
      } else {
        const startPath = [...getBlockParents(startClientId), startClientId];
        const endPath = [...getBlockParents(endClientId), endClientId];
        const depth = findDepth(startPath, endPath);
        if (startPath[depth] !== startClientId || endPath[depth] !== endClientId) {
          multiSelect(startPath[depth], endPath[depth]);
          return;
        }
        const richTextElementStart = getRichTextElement(startNode);
        const richTextElementEnd = getRichTextElement(endNode);
        if (richTextElementStart &amp;&amp; richTextElementEnd) {
          var _richTextDataStart$st, _richTextDataEnd$star;
          const range = selection.getRangeAt(0);
          const richTextDataStart = (0,external_wp_richText_namespaceObject.create)({
            element: richTextElementStart,
            range,
            __unstableIsEditableTree: true
          });
          const richTextDataEnd = (0,external_wp_richText_namespaceObject.create)({
            element: richTextElementEnd,
            range,
            __unstableIsEditableTree: true
          });
          const startOffset = (_richTextDataStart$st = richTextDataStart.start) !== null &amp;&amp; _richTextDataStart$st !== void 0 ? _richTextDataStart$st : richTextDataStart.end;
          const endOffset = (_richTextDataEnd$star = richTextDataEnd.start) !== null &amp;&amp; _richTextDataEnd$star !== void 0 ? _richTextDataEnd$star : richTextDataEnd.end;
          selectionChange({
            start: {
              clientId: startClientId,
              attributeKey: richTextElementStart.dataset.wpBlockAttributeKey,
              offset: startOffset
            },
            end: {
              clientId: endClientId,
              attributeKey: richTextElementEnd.dataset.wpBlockAttributeKey,
              offset: endOffset
            }
          });
        } else {
          multiSelect(startClientId, endClientId);
        }
      }
    }
    ownerDocument.addEventListener(&#039;selectionchange&#039;, onSelectionChange);
    defaultView.addEventListener(&#039;mouseup&#039;, onSelectionChange);
    return () =&gt; {
      ownerDocument.removeEventListener(&#039;selectionchange&#039;, onSelectionChange);
      defaultView.removeEventListener(&#039;mouseup&#039;, onSelectionChange);
    };
  }, [multiSelect, selectBlock, selectionChange, getBlockParents]);
}

;// ./node_modules/@wordpress/block-editor/build-module/components/writing-flow/use-click-selection.js
/**
 * WordPress dependencies
 */



/**
 * Internal dependencies
 */


function useClickSelection() {
  const {
    selectBlock
  } = (0,external_wp_data_namespaceObject.useDispatch)(store);
  const {
    isSelectionEnabled,
    getBlockSelectionStart,
    hasMultiSelection
  } = (0,external_wp_data_namespaceObject.useSelect)(store);
  return (0,external_wp_compose_namespaceObject.useRefEffect)(node =&gt; {
    function onMouseDown(event) {
      // The main button.
      // https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/button
      if (!isSelectionEnabled() || event.button !== 0) {
        return;
      }
      const startClientId = getBlockSelectionStart();
      const clickedClientId = getBlockClientId(event.target);
      if (event.shiftKey) {
        if (startClientId !== clickedClientId) {
          node.contentEditable = true;
          // Firefox doesn&#039;t automatically move focus.
          node.focus();
        }
      } else if (hasMultiSelection()) {
        // Allow user to escape out of a multi-selection to a
        // singular selection of a block via click. This is handled
        // here since focus handling excludes blocks when there is
        // multiselection, as focus can be incurred by starting a
        // multiselection (focus moved to first block&#039;s multi-
        // controls).
        selectBlock(clickedClientId);
      }
    }
    node.addEventListener(&#039;mousedown&#039;, onMouseDown);
    return () =&gt; {
      node.removeEventListener(&#039;mousedown&#039;, onMouseDown);
    };
  }, [selectBlock, isSelectionEnabled, getBlockSelectionStart, hasMultiSelection]);
}

;// ./node_modules/@wordpress/block-editor/build-module/components/writing-flow/use-input.js
/**
 * WordPress dependencies
 */





/**
 * Internal dependencies
 */


/**
 * Handles input for selections across blocks.
 */
function useInput() {
  const {
    __unstableIsFullySelected,
    getSelectedBlockClientIds,
    getSelectedBlockClientId,
    __unstableIsSelectionMergeable,
    hasMultiSelection,
    getBlockName,
    canInsertBlockType,
    getBlockRootClientId,
    getSelectionStart,
    getSelectionEnd,
    getBlockAttributes
  } = (0,external_wp_data_namespaceObject.useSelect)(store);
  const {
    replaceBlocks,
    __unstableSplitSelection,
    removeBlocks,
    __unstableDeleteSelection,
    __unstableExpandSelection,
    __unstableMarkAutomaticChange
  } = (0,external_wp_data_namespaceObject.useDispatch)(store);
  return (0,external_wp_compose_namespaceObject.useRefEffect)(node =&gt; {
    function onBeforeInput(event) {
      // If writing flow is editable, NEVER allow the browser to alter the
      // DOM. This will cause React errors (and the DOM should only be
      // altered in a controlled fashion).
      if (node.contentEditable === &#039;true&#039;) {
        event.preventDefault();
      }
    }
    function onKeyDown(event) {
      if (event.defaultPrevented) {
        return;
      }
      if (!hasMultiSelection()) {
        if (event.keyCode === external_wp_keycodes_namespaceObject.ENTER) {
          if (event.shiftKey || __unstableIsFullySelected()) {
            return;
          }
          const clientId = getSelectedBlockClientId();
          const blockName = getBlockName(clientId);
          const selectionStart = getSelectionStart();
          const selectionEnd = getSelectionEnd();
          if (selectionStart.attributeKey === selectionEnd.attributeKey) {
            const selectedAttributeValue = getBlockAttributes(clientId)[selectionStart.attributeKey];
            const transforms = (0,external_wp_blocks_namespaceObject.getBlockTransforms)(&#039;from&#039;).filter(({
              type
            }) =&gt; type === &#039;enter&#039;);
            const transformation = (0,external_wp_blocks_namespaceObject.findTransform)(transforms, item =&gt; {
              return item.regExp.test(selectedAttributeValue);
            });
            if (transformation) {
              replaceBlocks(clientId, transformation.transform({
                content: selectedAttributeValue
              }));
              __unstableMarkAutomaticChange();
              return;
            }
          }
          if (!(0,external_wp_blocks_namespaceObject.hasBlockSupport)(blockName, &#039;splitting&#039;, false) &amp;&amp; !event.__deprecatedOnSplit) {
            return;
          }

          // Ensure template is not locked.
          if (canInsertBlockType(blockName, getBlockRootClientId(clientId))) {
            __unstableSplitSelection();
            event.preventDefault();
          }
        }
        return;
      }
      if (event.keyCode === external_wp_keycodes_namespaceObject.ENTER) {
        node.contentEditable = false;
        event.preventDefault();
        if (__unstableIsFullySelected()) {
          replaceBlocks(getSelectedBlockClientIds(), (0,external_wp_blocks_namespaceObject.createBlock)((0,external_wp_blocks_namespaceObject.getDefaultBlockName)()));
        } else {
          __unstableSplitSelection();
        }
      } else if (event.keyCode === external_wp_keycodes_namespaceObject.BACKSPACE || event.keyCode === external_wp_keycodes_namespaceObject.DELETE) {
        node.contentEditable = false;
        event.preventDefault();
        if (__unstableIsFullySelected()) {
          removeBlocks(getSelectedBlockClientIds());
        } else if (__unstableIsSelectionMergeable()) {
          __unstableDeleteSelection(event.keyCode === external_wp_keycodes_namespaceObject.DELETE);
        } else {
          __unstableExpandSelection();
        }
      } else if (
      // If key.length is longer than 1, it&#039;s a control key that doesn&#039;t
      // input anything.
      event.key.length === 1 &amp;&amp; !(event.metaKey || event.ctrlKey)) {
        node.contentEditable = false;
        if (__unstableIsSelectionMergeable()) {
          __unstableDeleteSelection(event.keyCode === external_wp_keycodes_namespaceObject.DELETE);
        } else {
          event.preventDefault();
          // Safari does not stop default behaviour with either
          // event.preventDefault() or node.contentEditable = false, so
          // remove the selection to stop browser manipulation.
          node.ownerDocument.defaultView.getSelection().removeAllRanges();
        }
      }
    }
    function onCompositionStart(event) {
      if (!hasMultiSelection()) {
        return;
      }
      node.contentEditable = false;
      if (__unstableIsSelectionMergeable()) {
        __unstableDeleteSelection();
      } else {
        event.preventDefault();
        // Safari does not stop default behaviour with either
        // event.preventDefault() or node.contentEditable = false, so
        // remove the selection to stop browser manipulation.
        node.ownerDocument.defaultView.getSelection().removeAllRanges();
      }
    }
    node.addEventListener(&#039;beforeinput&#039;, onBeforeInput);
    node.addEventListener(&#039;keydown&#039;, onKeyDown);
    node.addEventListener(&#039;compositionstart&#039;, onCompositionStart);
    return () =&gt; {
      node.removeEventListener(&#039;beforeinput&#039;, onBeforeInput);
      node.removeEventListener(&#039;keydown&#039;, onKeyDown);
      node.removeEventListener(&#039;compositionstart&#039;, onCompositionStart);
    };
  }, []);
}

;// ./node_modules/@wordpress/block-editor/build-module/utils/use-notify-copy.js
/**
 * WordPress dependencies
 */






/**
 * Internal dependencies
 */

function useNotifyCopy() {
  const {
    getBlockName
  } = (0,external_wp_data_namespaceObject.useSelect)(store);
  const {
    getBlockType
  } = (0,external_wp_data_namespaceObject.useSelect)(external_wp_blocks_namespaceObject.store);
  const {
    createSuccessNotice
  } = (0,external_wp_data_namespaceObject.useDispatch)(external_wp_notices_namespaceObject.store);
  return (0,external_wp_element_namespaceObject.useCallback)((eventType, selectedBlockClientIds) =&gt; {
    let notice = &#039;&#039;;
    if (eventType === &#039;copyStyles&#039;) {
      notice = (0,external_wp_i18n_namespaceObject.__)(&#039;Styles copied to clipboard.&#039;);
    } else if (selectedBlockClientIds.length === 1) {
      const clientId = selectedBlockClientIds[0];
      const title = getBlockType(getBlockName(clientId))?.title;
      if (eventType === &#039;copy&#039;) {
        notice = (0,external_wp_i18n_namespaceObject.sprintf)(
        // Translators: Name of the block being copied, e.g. &quot;Paragraph&quot;.
        (0,external_wp_i18n_namespaceObject.__)(&#039;Copied &quot;%s&quot; to clipboard.&#039;), title);
      } else {
        notice = (0,external_wp_i18n_namespaceObject.sprintf)(
        // Translators: Name of the block being cut, e.g. &quot;Paragraph&quot;.
        (0,external_wp_i18n_namespaceObject.__)(&#039;Moved &quot;%s&quot; to clipboard.&#039;), title);
      }
    } else if (eventType === &#039;copy&#039;) {
      notice = (0,external_wp_i18n_namespaceObject.sprintf)(
      // Translators: %d: Number of blocks being copied.
      (0,external_wp_i18n_namespaceObject._n)(&#039;Copied %d block to clipboard.&#039;, &#039;Copied %d blocks to clipboard.&#039;, selectedBlockClientIds.length), selectedBlockClientIds.length);
    } else {
      notice = (0,external_wp_i18n_namespaceObject.sprintf)(
      // Translators: %d: Number of blocks being moved.
      (0,external_wp_i18n_namespaceObject._n)(&#039;Moved %d block to clipboard.&#039;, &#039;Moved %d blocks to clipboard.&#039;, selectedBlockClientIds.length), selectedBlockClientIds.length);
    }
    createSuccessNotice(notice, {
      type: &#039;snackbar&#039;
    });
  }, [createSuccessNotice, getBlockName, getBlockType]);
}

;// ./node_modules/@wordpress/block-editor/build-module/utils/pasting.js
/**
 * WordPress dependencies
 */


/**
 * Normalizes a given string of HTML to remove the Windows-specific &quot;Fragment&quot;
 * comments and any preceding and trailing content.
 *
 * @param {string} html the html to be normalized
 * @return {string} the normalized html
 */
function removeWindowsFragments(html) {
  const startStr = &#039;&lt;!--StartFragment--&gt;&#039;;
  const startIdx = html.indexOf(startStr);
  if (startIdx &gt; -1) {
    html = html.substring(startIdx + startStr.length);
  } else {
    // No point looking for EndFragment
    return html;
  }
  const endStr = &#039;&lt;!--EndFragment--&gt;&#039;;
  const endIdx = html.indexOf(endStr);
  if (endIdx &gt; -1) {
    html = html.substring(0, endIdx);
  }
  return html;
}

/**
 * Removes the charset meta tag inserted by Chromium.
 * See:
 * - https://github.com/WordPress/gutenberg/issues/33585
 * - https://bugs.chromium.org/p/chromium/issues/detail?id=1264616#c4
 *
 * @param {string} html the html to be stripped of the meta tag.
 * @return {string} the cleaned html
 */
function removeCharsetMetaTag(html) {
  const metaTag = `&lt;meta charset=&#039;utf-8&#039;&gt;`;
  if (html.startsWith(metaTag)) {
    return html.slice(metaTag.length);
  }
  return html;
}
function getPasteEventData({
  clipboardData
}) {
  let plainText = &#039;&#039;;
  let html = &#039;&#039;;
  try {
    plainText = clipboardData.getData(&#039;text/plain&#039;);
    html = clipboardData.getData(&#039;text/html&#039;);
  } catch (error) {
    // Some browsers like UC Browser paste plain text by default and
    // don&#039;t support clipboardData at all, so allow default
    // behaviour.
    return;
  }

  // Remove Windows-specific metadata appended within copied HTML text.
  html = removeWindowsFragments(html);

  // Strip meta tag.
  html = removeCharsetMetaTag(html);
  const files = (0,external_wp_dom_namespaceObject.getFilesFromDataTransfer)(clipboardData);
  if (files.length &amp;&amp; !shouldDismissPastedFiles(files, html)) {
    return {
      files
    };
  }
  return {
    html,
    plainText,
    files: []
  };
}

/**
 * Given a collection of DataTransfer files and HTML and plain text strings,
 * determine whether the files are to be dismissed in favor of the HTML.
 *
 * Certain office-type programs, like Microsoft Word or Apple Numbers,
 * will, upon copy, generate a screenshot of the content being copied and
 * attach it to the clipboard alongside the actual rich text that the user
 * sought to copy. In those cases, we should let Gutenberg handle the rich text
 * content and not the screenshot, since this allows Gutenberg to insert
 * meaningful blocks, like paragraphs, lists or even tables.
 *
 * @param {File[]} files File objects obtained from a paste event
 * @param {string} html  HTML content obtained from a paste event
 * @return {boolean}     True if the files should be dismissed
 */
function shouldDismissPastedFiles(files, html /*, plainText */) {
  // The question is only relevant when there is actual HTML content and when
  // there is exactly one image file.
  if (html &amp;&amp; files?.length === 1 &amp;&amp; files[0].type.indexOf(&#039;image/&#039;) === 0) {
    // A single &lt;img&gt; tag found in the HTML source suggests that the
    // content being pasted revolves around an image. Sometimes there are
    // other elements found, like &lt;figure&gt;, but we assume that the user&#039;s
    // intention is to paste the actual image file.
    const IMAGE_TAG = /&lt;\s*img\b/gi;
    if (html.match(IMAGE_TAG)?.length !== 1) {
      return true;
    }

    // Even when there is exactly one &lt;img&gt; tag in the HTML payload, we
    // choose to weed out local images, i.e. those whose source starts with
    // &quot;file://&quot;. These payloads occur in specific configurations, such as
    // when copying an entire document from Microsoft Word, that contains
    // text and exactly one image, and pasting that content using Google
    // Chrome.
    const IMG_WITH_LOCAL_SRC = /&lt;\s*img\b[^&gt;]*\bsrc=&quot;file:\/\//i;
    if (html.match(IMG_WITH_LOCAL_SRC)) {
      return true;
    }
  }
  return false;
}

;// ./node_modules/@wordpress/block-editor/build-module/components/writing-flow/utils.js
/**
 * WordPress dependencies
 */



/**
 * Internal dependencies
 */


const requiresWrapperOnCopy = Symbol(&#039;requiresWrapperOnCopy&#039;);

/**
 * Sets the clipboard data for the provided blocks, with both HTML and plain
 * text representations.
 *
 * @param {ClipboardEvent} event    Clipboard event.
 * @param {WPBlock[]}      blocks   Blocks to set as clipboard data.
 * @param {Object}         registry The registry to select from.
 */
function setClipboardBlocks(event, blocks, registry) {
  let _blocks = blocks;
  const [firstBlock] = blocks;
  if (firstBlock) {
    const firstBlockType = registry.select(external_wp_blocks_namespaceObject.store).getBlockType(firstBlock.name);
    if (firstBlockType[requiresWrapperOnCopy]) {
      const {
        getBlockRootClientId,
        getBlockName,
        getBlockAttributes
      } = registry.select(store);
      const wrapperBlockClientId = getBlockRootClientId(firstBlock.clientId);
      const wrapperBlockName = getBlockName(wrapperBlockClientId);
      if (wrapperBlockName) {
        _blocks = (0,external_wp_blocks_namespaceObject.createBlock)(wrapperBlockName, getBlockAttributes(wrapperBlockClientId), _blocks);
      }
    }
  }
  const serialized = (0,external_wp_blocks_namespaceObject.serialize)(_blocks);
  event.clipboardData.setData(&#039;text/plain&#039;, toPlainText(serialized));
  event.clipboardData.setData(&#039;text/html&#039;, serialized);
}

/**
 * Returns the blocks to be pasted from the clipboard event.
 *
 * @param {ClipboardEvent} event                    The clipboard event.
 * @param {boolean}        canUserUseUnfilteredHTML Whether the user can or can&#039;t post unfiltered HTML.
 * @return {Array|string} A list of blocks or a string, depending on `handlerMode`.
 */
function getPasteBlocks(event, canUserUseUnfilteredHTML) {
  const {
    plainText,
    html,
    files
  } = getPasteEventData(event);
  let blocks = [];
  if (files.length) {
    const fromTransforms = (0,external_wp_blocks_namespaceObject.getBlockTransforms)(&#039;from&#039;);
    blocks = files.reduce((accumulator, file) =&gt; {
      const transformation = (0,external_wp_blocks_namespaceObject.findTransform)(fromTransforms, transform =&gt; transform.type === &#039;files&#039; &amp;&amp; transform.isMatch([file]));
      if (transformation) {
        accumulator.push(transformation.transform([file]));
      }
      return accumulator;
    }, []).flat();
  } else {
    blocks = (0,external_wp_blocks_namespaceObject.pasteHandler)({
      HTML: html,
      plainText,
      mode: &#039;BLOCKS&#039;,
      canUserUseUnfilteredHTML
    });
  }
  return blocks;
}

/**
 * Given a string of HTML representing serialized blocks, returns the plain
 * text extracted after stripping the HTML of any tags and fixing line breaks.
 *
 * @param {string} html Serialized blocks.
 * @return {string} The plain-text content with any html removed.
 */
function toPlainText(html) {
  // Manually handle BR tags as line breaks prior to `stripHTML` call
  html = html.replace(/&lt;br&gt;/g, &#039;\n&#039;);
  const plainText = (0,external_wp_dom_namespaceObject.__unstableStripHTML)(html).trim();

  // Merge any consecutive line breaks
  return plainText.replace(/\n\n+/g, &#039;\n\n&#039;);
}

;// ./node_modules/@wordpress/block-editor/build-module/components/writing-flow/use-clipboard-handler.js
/**
 * WordPress dependencies
 */





/**
 * Internal dependencies
 */




function useClipboardHandler() {
  const registry = (0,external_wp_data_namespaceObject.useRegistry)();
  const {
    getBlocksByClientId,
    getSelectedBlockClientIds,
    hasMultiSelection,
    getSettings,
    getBlockName,
    __unstableIsFullySelected,
    __unstableIsSelectionCollapsed,
    __unstableIsSelectionMergeable,
    __unstableGetSelectedBlocksWithPartialSelection,
    canInsertBlockType,
    getBlockRootClientId
  } = (0,external_wp_data_namespaceObject.useSelect)(store);
  const {
    flashBlock,
    removeBlocks,
    replaceBlocks,
    __unstableDeleteSelection,
    __unstableExpandSelection,
    __unstableSplitSelection
  } = (0,external_wp_data_namespaceObject.useDispatch)(store);
  const notifyCopy = useNotifyCopy();
  return (0,external_wp_compose_namespaceObject.useRefEffect)(node =&gt; {
    function handler(event) {
      if (event.defaultPrevented) {
        // This was likely already handled in rich-text/use-paste-handler.js.
        return;
      }
      const selectedBlockClientIds = getSelectedBlockClientIds();
      if (selectedBlockClientIds.length === 0) {
        return;
      }

      // Let native copy/paste behaviour take over in input fields.
      // But always handle multiple selected blocks.
      if (!hasMultiSelection()) {
        const {
          target
        } = event;
        const {
          ownerDocument
        } = target;
        // If copying, only consider actual text selection as selection.
        // Otherwise, any focus on an input field is considered.
        const hasSelection = event.type === &#039;copy&#039; || event.type === &#039;cut&#039; ? (0,external_wp_dom_namespaceObject.documentHasUncollapsedSelection)(ownerDocument) : (0,external_wp_dom_namespaceObject.documentHasSelection)(ownerDocument) &amp;&amp; !ownerDocument.activeElement.isContentEditable;

        // Let native copy behaviour take over in input fields.
        if (hasSelection) {
          return;
        }
      }
      const {
        activeElement
      } = event.target.ownerDocument;
      if (!node.contains(activeElement)) {
        return;
      }
      const isSelectionMergeable = __unstableIsSelectionMergeable();
      const shouldHandleWholeBlocks = __unstableIsSelectionCollapsed() || __unstableIsFullySelected();
      const expandSelectionIsNeeded = !shouldHandleWholeBlocks &amp;&amp; !isSelectionMergeable;
      if (event.type === &#039;copy&#039; || event.type === &#039;cut&#039;) {
        event.preventDefault();
        if (selectedBlockClientIds.length === 1) {
          flashBlock(selectedBlockClientIds[0]);
        }
        // If we have a partial selection that is not mergeable, just
        // expand the selection to the whole blocks.
        if (expandSelectionIsNeeded) {
          __unstableExpandSelection();
        } else {
          notifyCopy(event.type, selectedBlockClientIds);
          let blocks;
          // Check if we have partial selection.
          if (shouldHandleWholeBlocks) {
            blocks = getBlocksByClientId(selectedBlockClientIds);
          } else {
            const [head, tail] = __unstableGetSelectedBlocksWithPartialSelection();
            const inBetweenBlocks = getBlocksByClientId(selectedBlockClientIds.slice(1, selectedBlockClientIds.length - 1));
            blocks = [head, ...inBetweenBlocks, tail];
          }
          setClipboardBlocks(event, blocks, registry);
        }
      }
      if (event.type === &#039;cut&#039;) {
        // We need to also check if at the start we needed to
        // expand the selection, as in this point we might have
        // programmatically fully selected the blocks above.
        if (shouldHandleWholeBlocks &amp;&amp; !expandSelectionIsNeeded) {
          removeBlocks(selectedBlockClientIds);
        } else {
          event.target.ownerDocument.activeElement.contentEditable = false;
          __unstableDeleteSelection();
        }
      } else if (event.type === &#039;paste&#039;) {
        const {
          __experimentalCanUserUseUnfilteredHTML: canUserUseUnfilteredHTML
        } = getSettings();
        const isInternal = event.clipboardData.getData(&#039;rich-text&#039;) === &#039;true&#039;;
        if (isInternal) {
          return;
        }
        const {
          plainText,
          html,
          files
        } = getPasteEventData(event);
        const isFullySelected = __unstableIsFullySelected();
        let blocks = [];
        if (files.length) {
          const fromTransforms = (0,external_wp_blocks_namespaceObject.getBlockTransforms)(&#039;from&#039;);
          blocks = files.reduce((accumulator, file) =&gt; {
            const transformation = (0,external_wp_blocks_namespaceObject.findTransform)(fromTransforms, transform =&gt; transform.type === &#039;files&#039; &amp;&amp; transform.isMatch([file]));
            if (transformation) {
              accumulator.push(transformation.transform([file]));
            }
            return accumulator;
          }, []).flat();
        } else {
          blocks = (0,external_wp_blocks_namespaceObject.pasteHandler)({
            HTML: html,
            plainText,
            mode: isFullySelected ? &#039;BLOCKS&#039; : &#039;AUTO&#039;,
            canUserUseUnfilteredHTML
          });
        }

        // Inline paste: let rich text handle it.
        if (typeof blocks === &#039;string&#039;) {
          return;
        }
        if (isFullySelected) {
          replaceBlocks(selectedBlockClientIds, blocks, blocks.length - 1, -1);
          event.preventDefault();
          return;
        }

        // If a block doesn&#039;t support splitting, let rich text paste
        // inline.
        if (!hasMultiSelection() &amp;&amp; !(0,external_wp_blocks_namespaceObject.hasBlockSupport)(getBlockName(selectedBlockClientIds[0]), &#039;splitting&#039;, false) &amp;&amp; !event.__deprecatedOnSplit) {
          return;
        }
        const [firstSelectedClientId] = selectedBlockClientIds;
        const rootClientId = getBlockRootClientId(firstSelectedClientId);
        const newBlocks = [];
        for (const block of blocks) {
          if (canInsertBlockType(block.name, rootClientId)) {
            newBlocks.push(block);
          } else {
            // If a block cannot be inserted in a root block, try
            // converting it to that root block type and insert the
            // inner blocks.
            // Example: paragraphs cannot be inserted into a list,
            // so convert the paragraphs to a list for list items.
            const rootBlockName = getBlockName(rootClientId);
            const switchedBlocks = block.name !== rootBlockName ? (0,external_wp_blocks_namespaceObject.switchToBlockType)(block, rootBlockName) : [block];
            if (!switchedBlocks) {
              return;
            }
            for (const switchedBlock of switchedBlocks) {
              for (const innerBlock of switchedBlock.innerBlocks) {
                newBlocks.push(innerBlock);
              }
            }
          }
        }
        __unstableSplitSelection(newBlocks);
        event.preventDefault();
      }
    }
    node.ownerDocument.addEventListener(&#039;copy&#039;, handler);
    node.ownerDocument.addEventListener(&#039;cut&#039;, handler);
    node.ownerDocument.addEventListener(&#039;paste&#039;, handler);
    return () =&gt; {
      node.ownerDocument.removeEventListener(&#039;copy&#039;, handler);
      node.ownerDocument.removeEventListener(&#039;cut&#039;, handler);
      node.ownerDocument.removeEventListener(&#039;paste&#039;, handler);
    };
  }, []);
}

;// ./node_modules/@wordpress/block-editor/build-module/components/writing-flow/index.js
/**
 * External dependencies
 */


/**
 * WordPress dependencies
 */





/**
 * Internal dependencies
 */











function useWritingFlow() {
  const [before, ref, after] = useTabNav();
  const hasMultiSelection = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; select(store).hasMultiSelection(), []);
  return [before, (0,external_wp_compose_namespaceObject.useMergeRefs)([ref, useClipboardHandler(), useInput(), useDragSelection(), useSelectionObserver(), useClickSelection(), useMultiSelection(), useSelectAll(), useArrowNav(), (0,external_wp_compose_namespaceObject.useRefEffect)(node =&gt; {
    node.tabIndex = 0;
    node.dataset.hasMultiSelection = hasMultiSelection;
    if (!hasMultiSelection) {
      return () =&gt; {
        delete node.dataset.hasMultiSelection;
      };
    }
    node.setAttribute(&#039;aria-label&#039;, (0,external_wp_i18n_namespaceObject.__)(&#039;Multiple selected blocks&#039;));
    return () =&gt; {
      delete node.dataset.hasMultiSelection;
      node.removeAttribute(&#039;aria-label&#039;);
    };
  }, [hasMultiSelection])]), after];
}
function WritingFlow({
  children,
  ...props
}, forwardedRef) {
  const [before, ref, after] = useWritingFlow();
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
    children: [before, /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
      ...props,
      ref: (0,external_wp_compose_namespaceObject.useMergeRefs)([ref, forwardedRef]),
      className: dist_clsx(props.className, &#039;block-editor-writing-flow&#039;),
      children: children
    }), after]
  });
}

/**
 * Handles selection and navigation across blocks. This component should be
 * wrapped around BlockList.
 *
 * @param {Object}  props          Component properties.
 * @param {Element} props.children Children to be rendered.
 */
/* harmony default export */ const writing_flow = ((0,external_wp_element_namespaceObject.forwardRef)(WritingFlow));

;// ./node_modules/@wordpress/block-editor/build-module/components/iframe/get-compatibility-styles.js
let compatibilityStyles = null;

/**
 * Returns a list of stylesheets that target the editor canvas. A stylesheet is
 * considered targeting the editor a canvas if it contains the
 * `editor-styles-wrapper`, `wp-block`, or `wp-block-*` class selectors.
 *
 * Ideally, this hook should be removed in the future and styles should be added
 * explicitly as editor styles.
 */
function getCompatibilityStyles() {
  if (compatibilityStyles) {
    return compatibilityStyles;
  }

  // Only memoize the result once on load, since these stylesheets should not
  // change.
  compatibilityStyles = Array.from(document.styleSheets).reduce((accumulator, styleSheet) =&gt; {
    try {
      // May fail for external styles.
      // eslint-disable-next-line no-unused-expressions
      styleSheet.cssRules;
    } catch (e) {
      return accumulator;
    }
    const {
      ownerNode,
      cssRules
    } = styleSheet;

    // Stylesheet is added by another stylesheet. See
    // https://developer.mozilla.org/en-US/docs/Web/API/StyleSheet/ownerNode#notes.
    if (ownerNode === null) {
      return accumulator;
    }
    if (!cssRules) {
      return accumulator;
    }

    // Don&#039;t try to add core WP styles. We are responsible for adding
    // them. This compatibility layer is only meant to add styles added
    // by plugins or themes.
    if (ownerNode.id.startsWith(&#039;wp-&#039;)) {
      return accumulator;
    }

    // Don&#039;t try to add styles without ID. Styles enqueued via the WP dependency system will always have IDs.
    if (!ownerNode.id) {
      return accumulator;
    }
    function matchFromRules(_cssRules) {
      return Array.from(_cssRules).find(({
        selectorText,
        conditionText,
        cssRules: __cssRules
      }) =&gt; {
        // If the rule is conditional then it will not have selector text.
        // Recurse into child CSS ruleset to determine selector eligibility.
        if (conditionText) {
          return matchFromRules(__cssRules);
        }
        return selectorText &amp;&amp; (selectorText.includes(&#039;.editor-styles-wrapper&#039;) || selectorText.includes(&#039;.wp-block&#039;));
      });
    }
    if (matchFromRules(cssRules)) {
      const isInline = ownerNode.tagName === &#039;STYLE&#039;;
      if (isInline) {
        // If the current target is inline,
        // it could be a dependency of an existing stylesheet.
        // Look for that dependency and add it BEFORE the current target.
        const mainStylesCssId = ownerNode.id.replace(&#039;-inline-css&#039;, &#039;-css&#039;);
        const mainStylesElement = document.getElementById(mainStylesCssId);
        if (mainStylesElement) {
          accumulator.push(mainStylesElement.cloneNode(true));
        }
      }
      accumulator.push(ownerNode.cloneNode(true));
      if (!isInline) {
        // If the current target is not inline,
        // we still look for inline styles that could be relevant for the current target.
        // If they exist, add them AFTER the current target.
        const inlineStylesCssId = ownerNode.id.replace(&#039;-css&#039;, &#039;-inline-css&#039;);
        const inlineStylesElement = document.getElementById(inlineStylesCssId);
        if (inlineStylesElement) {
          accumulator.push(inlineStylesElement.cloneNode(true));
        }
      }
    }
    return accumulator;
  }, []);
  return compatibilityStyles;
}

;// ./node_modules/@wordpress/block-editor/build-module/components/iframe/use-scale-canvas.js
/**
 * WordPress dependencies
 */



/**
 * @typedef {Object} TransitionState
 * @property {number} scaleValue      Scale of the canvas.
 * @property {number} frameSize       Size of the frame/offset around the canvas.
 * @property {number} containerHeight containerHeight of the iframe.
 * @property {number} scrollTop       ScrollTop of the iframe.
 * @property {number} scrollHeight    ScrollHeight of the iframe.
 */

/**
 * Calculate the scale of the canvas.
 *
 * @param {Object} options                     Object of options
 * @param {number} options.frameSize           Size of the frame/offset around the canvas
 * @param {number} options.containerWidth      Actual width of the canvas container
 * @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.
 * @param {number} options.scaleContainerWidth Width the of the container wrapping the canvas container
 * @return {number} Scale value between 0 and/or equal to 1
 */
function calculateScale({
  frameSize,
  containerWidth,
  maxContainerWidth,
  scaleContainerWidth
}) {
  return (Math.min(containerWidth, maxContainerWidth) - frameSize * 2) / scaleContainerWidth;
}

/**
 * Compute the next scrollHeight based on the transition states.
 *
 * @param {TransitionState} transitionFrom Starting point of the transition
 * @param {TransitionState} transitionTo   Ending state of the transition
 * @return {number} Next scrollHeight based on scale and frame value changes.
 */
function computeScrollHeightNext(transitionFrom, transitionTo) {
  const {
    scaleValue: prevScale,
    scrollHeight: prevScrollHeight
  } = transitionFrom;
  const {
    frameSize,
    scaleValue
  } = transitionTo;
  return prevScrollHeight * (scaleValue / prevScale) + frameSize * 2;
}

/**
 * Compute the next scrollTop position after scaling the iframe content.
 *
 * @param {TransitionState} transitionFrom Starting point of the transition
 * @param {TransitionState} transitionTo   Ending state of the transition
 * @return {number} Next scrollTop position after scaling the iframe content.
 */
function computeScrollTopNext(transitionFrom, transitionTo) {
  const {
    containerHeight: prevContainerHeight,
    frameSize: prevFrameSize,
    scaleValue: prevScale,
    scrollTop: prevScrollTop
  } = transitionFrom;
  const {
    containerHeight,
    frameSize,
    scaleValue,
    scrollHeight
  } = transitionTo;
  // Step 0: Start with the current scrollTop.
  let scrollTopNext = prevScrollTop;
  // Step 1: Undo the effects of the previous scale and frame around the
  // midpoint of the visible area.
  scrollTopNext = (scrollTopNext + prevContainerHeight / 2 - prevFrameSize) / prevScale - prevContainerHeight / 2;

  // Step 2: Apply the new scale and frame around the midpoint of the
  // visible area.
  scrollTopNext = (scrollTopNext + containerHeight / 2) * scaleValue + frameSize - containerHeight / 2;

  // Step 3: Handle an edge case so that you scroll to the top of the
  // iframe if the top of the iframe content is visible in the container.
  // The same edge case for the bottom is skipped because changing content
  // makes calculating it impossible.
  scrollTopNext = prevScrollTop &lt;= prevFrameSize ? 0 : scrollTopNext;

  // This is the scrollTop value if you are scrolled to the bottom of the
  // iframe. We can&#039;t just let the browser handle it because we need to
  // animate the scaling.
  const maxScrollTop = scrollHeight - containerHeight;

  // Step 4: Clamp the scrollTopNext between the minimum and maximum
  // possible scrollTop positions. Round the value to avoid subpixel
  // truncation by the browser which sometimes causes a 1px error.
  return Math.round(Math.min(Math.max(0, scrollTopNext), Math.max(0, maxScrollTop)));
}

/**
 * Generate the keyframes to use for the zoom out animation.
 *
 * @param {TransitionState} transitionFrom Starting transition state.
 * @param {TransitionState} transitionTo   Ending transition state.
 * @return {Object[]} An array of keyframes to use for the animation.
 */
function getAnimationKeyframes(transitionFrom, transitionTo) {
  const {
    scaleValue: prevScale,
    frameSize: prevFrameSize,
    scrollTop
  } = transitionFrom;
  const {
    scaleValue,
    frameSize,
    scrollTop: scrollTopNext
  } = transitionTo;
  return [{
    translate: `0 0`,
    scale: prevScale,
    paddingTop: `${prevFrameSize / prevScale}px`,
    paddingBottom: `${prevFrameSize / prevScale}px`
  }, {
    translate: `0 ${scrollTop - scrollTopNext}px`,
    scale: scaleValue,
    paddingTop: `${frameSize / scaleValue}px`,
    paddingBottom: `${frameSize / scaleValue}px`
  }];
}

/**
 * @typedef {Object} ScaleCanvasResult
 * @property {boolean} isZoomedOut             A boolean indicating if the canvas is zoomed out.
 * @property {number}  scaleContainerWidth     The width of the container used to calculate the scale.
 * @property {Object}  contentResizeListener   A resize observer for the content.
 * @property {Object}  containerResizeListener A resize observer for the container.
 */

/**
 * Handles scaling the canvas for the zoom out mode and animating between
 * the states.
 *
 * @param {Object}        options                   Object of options.
 * @param {number}        options.frameSize         Size of the frame around the content.
 * @param {Document}      options.iframeDocument    Document of the iframe.
 * @param {number}        options.maxContainerWidth Max width of the canvas to use as the starting scale point. Defaults to 750.
 * @param {number|string} options.scale             Scale of the canvas. Can be an decimal between 0 and 1, 1, or &#039;auto-scaled&#039;.
 * @return {ScaleCanvasResult} Properties of the result.
 */
function useScaleCanvas({
  frameSize,
  iframeDocument,
  maxContainerWidth = 750,
  scale
}) {
  const [contentResizeListener, {
    height: contentHeight
  }] = (0,external_wp_compose_namespaceObject.useResizeObserver)();
  const [containerResizeListener, {
    width: containerWidth,
    height: containerHeight
  }] = (0,external_wp_compose_namespaceObject.useResizeObserver)();
  const initialContainerWidthRef = (0,external_wp_element_namespaceObject.useRef)(0);
  const isZoomedOut = scale !== 1;
  const prefersReducedMotion = (0,external_wp_compose_namespaceObject.useReducedMotion)();
  const isAutoScaled = scale === &#039;auto-scaled&#039;;
  // Track if the animation should start when the useEffect runs.
  const startAnimationRef = (0,external_wp_element_namespaceObject.useRef)(false);
  // Track the animation so we know if we have an animation running,
  // and can cancel it, reverse it, call a finish event, etc.
  const animationRef = (0,external_wp_element_namespaceObject.useRef)(null);
  (0,external_wp_element_namespaceObject.useEffect)(() =&gt; {
    if (!isZoomedOut) {
      initialContainerWidthRef.current = containerWidth;
    }
  }, [containerWidth, isZoomedOut]);
  const scaleContainerWidth = Math.max(initialContainerWidthRef.current, containerWidth);
  const scaleValue = isAutoScaled ? calculateScale({
    frameSize,
    containerWidth,
    maxContainerWidth,
    scaleContainerWidth
  }) : scale;

  /**
   * The starting transition state for the zoom out animation.
   * @type {import(&#039;react&#039;).RefObject&lt;TransitionState&gt;}
   */
  const transitionFromRef = (0,external_wp_element_namespaceObject.useRef)({
    scaleValue,
    frameSize,
    containerHeight: 0,
    scrollTop: 0,
    scrollHeight: 0
  });

  /**
   * The ending transition state for the zoom out animation.
   * @type {import(&#039;react&#039;).RefObject&lt;TransitionState&gt;}
   */
  const transitionToRef = (0,external_wp_element_namespaceObject.useRef)({
    scaleValue,
    frameSize,
    containerHeight: 0,
    scrollTop: 0,
    scrollHeight: 0
  });

  /**
   * Start the zoom out animation. This sets the necessary CSS variables
   * for animating the canvas and returns the Animation object.
   *
   * @return {Animation} The animation object for the zoom out animation.
   */
  const startZoomOutAnimation = (0,external_wp_element_namespaceObject.useCallback)(() =&gt; {
    const {
      scrollTop
    } = transitionFromRef.current;
    const {
      scrollTop: scrollTopNext
    } = transitionToRef.current;
    iframeDocument.documentElement.style.setProperty(&#039;--wp-block-editor-iframe-zoom-out-scroll-top&#039;, `${scrollTop}px`);
    iframeDocument.documentElement.style.setProperty(&#039;--wp-block-editor-iframe-zoom-out-scroll-top-next&#039;, `${scrollTopNext}px`);

    // If the container has a scrolllbar, force a scrollbar to prevent the content from shifting while animating.
    iframeDocument.documentElement.style.setProperty(&#039;--wp-block-editor-iframe-zoom-out-overflow-behavior&#039;, transitionFromRef.current.scrollHeight === transitionFromRef.current.containerHeight ? &#039;auto&#039; : &#039;scroll&#039;);
    iframeDocument.documentElement.classList.add(&#039;zoom-out-animation&#039;);
    return iframeDocument.documentElement.animate(getAnimationKeyframes(transitionFromRef.current, transitionToRef.current), {
      easing: &#039;cubic-bezier(0.46, 0.03, 0.52, 0.96)&#039;,
      duration: 400
    });
  }, [iframeDocument]);

  /**
   * Callback when the zoom out animation is finished.
   * - Cleans up animations refs.
   * - Adds final CSS vars for scale and frame size to preserve the state.
   * - Removes the &#039;zoom-out-animation&#039; class (which has the fixed positioning).
   * - Sets the final scroll position after the canvas is no longer in fixed position.
   * - Removes CSS vars related to the animation.
   * - Sets the transitionFrom to the transitionTo state to be ready for the next animation.
   */
  const finishZoomOutAnimation = (0,external_wp_element_namespaceObject.useCallback)(() =&gt; {
    startAnimationRef.current = false;
    animationRef.current = null;

    // Add our final scale and frame size now that the animation is done.
    iframeDocument.documentElement.style.setProperty(&#039;--wp-block-editor-iframe-zoom-out-scale&#039;, transitionToRef.current.scaleValue);
    iframeDocument.documentElement.style.setProperty(&#039;--wp-block-editor-iframe-zoom-out-frame-size&#039;, `${transitionToRef.current.frameSize}px`);
    iframeDocument.documentElement.classList.remove(&#039;zoom-out-animation&#039;);

    // Set the final scroll position that was just animated to.
    // Disable reason: Eslint isn&#039;t smart enough to know that this is a
    // DOM element. https://github.com/facebook/react/issues/31483
    // eslint-disable-next-line react-compiler/react-compiler
    iframeDocument.documentElement.scrollTop = transitionToRef.current.scrollTop;
    iframeDocument.documentElement.style.removeProperty(&#039;--wp-block-editor-iframe-zoom-out-scroll-top&#039;);
    iframeDocument.documentElement.style.removeProperty(&#039;--wp-block-editor-iframe-zoom-out-scroll-top-next&#039;);
    iframeDocument.documentElement.style.removeProperty(&#039;--wp-block-editor-iframe-zoom-out-overflow-behavior&#039;);

    // Update previous values.
    transitionFromRef.current = transitionToRef.current;
  }, [iframeDocument]);
  const previousIsZoomedOut = (0,external_wp_element_namespaceObject.useRef)(false);

  /**
   * Runs when zoom out mode is toggled, and sets the startAnimation flag
   * so the animation will start when the next useEffect runs. We _only_
   * want to animate when the zoom out mode is toggled, not when the scale
   * changes due to the container resizing.
   */
  (0,external_wp_element_namespaceObject.useEffect)(() =&gt; {
    const trigger = iframeDocument &amp;&amp; previousIsZoomedOut.current !== isZoomedOut;
    previousIsZoomedOut.current = isZoomedOut;
    if (!trigger) {
      return;
    }
    startAnimationRef.current = true;
    if (!isZoomedOut) {
      return;
    }
    iframeDocument.documentElement.classList.add(&#039;is-zoomed-out&#039;);
    return () =&gt; {
      iframeDocument.documentElement.classList.remove(&#039;is-zoomed-out&#039;);
    };
  }, [iframeDocument, isZoomedOut]);

  /**
   * This handles:
   * 1. Setting the correct scale and vars of the canvas when zoomed out
   * 2. If zoom out mode has been toggled, runs the animation of zooming in/out
   */
  (0,external_wp_element_namespaceObject.useEffect)(() =&gt; {
    if (!iframeDocument) {
      return;
    }

    // We need to update the appropriate scale to exit from. If sidebars have been opened since setting the
    // original scale, we will snap to a much smaller scale due to the scale container immediately changing sizes when exiting.
    if (isAutoScaled &amp;&amp; transitionFromRef.current.scaleValue !== 1) {
      // We use containerWidth as the divisor, as scaleContainerWidth will always match the containerWidth when
      // exiting.
      transitionFromRef.current.scaleValue = calculateScale({
        frameSize: transitionFromRef.current.frameSize,
        containerWidth,
        maxContainerWidth,
        scaleContainerWidth: containerWidth
      });
    }
    if (scaleValue &lt; 1) {
      // If we are not going to animate the transition, set the scale and frame size directly.
      // If we are animating, these values will be set when the animation is finished.
      // Example: Opening sidebars that reduce the scale of the canvas, but we don&#039;t want to
      // animate the transition.
      if (!startAnimationRef.current) {
        iframeDocument.documentElement.style.setProperty(&#039;--wp-block-editor-iframe-zoom-out-scale&#039;, scaleValue);
        iframeDocument.documentElement.style.setProperty(&#039;--wp-block-editor-iframe-zoom-out-frame-size&#039;, `${frameSize}px`);
      }
      iframeDocument.documentElement.style.setProperty(&#039;--wp-block-editor-iframe-zoom-out-content-height&#039;, `${contentHeight}px`);
      iframeDocument.documentElement.style.setProperty(&#039;--wp-block-editor-iframe-zoom-out-inner-height&#039;, `${containerHeight}px`);
      iframeDocument.documentElement.style.setProperty(&#039;--wp-block-editor-iframe-zoom-out-container-width&#039;, `${containerWidth}px`);
      iframeDocument.documentElement.style.setProperty(&#039;--wp-block-editor-iframe-zoom-out-scale-container-width&#039;, `${scaleContainerWidth}px`);
    }

    /**
     * Handle the zoom out animation:
     *
     * - Get the current scrollTop position.
     * - Calculate where the same scroll position is after scaling.
     * - Apply fixed positioning to the canvas with a transform offset
     *   to keep the canvas centered.
     * - Animate the scale and padding to the new scale and frame size.
     * - After the animation is complete, remove the fixed positioning
     *   and set the scroll position that keeps everything centered.
     */
    if (startAnimationRef.current) {
      // Don&#039;t allow a new transition to start again unless it was started by the zoom out mode changing.
      startAnimationRef.current = false;

      /**
       * If we already have an animation running, reverse it.
       */
      if (animationRef.current) {
        animationRef.current.reverse();
        // Swap the transition to/from refs so that we set the correct values when
        // finishZoomOutAnimation runs.
        const tempTransitionFrom = transitionFromRef.current;
        const tempTransitionTo = transitionToRef.current;
        transitionFromRef.current = tempTransitionTo;
        transitionToRef.current = tempTransitionFrom;
      } else {
        /**
         * Start a new zoom animation.
         */

        // We can&#039;t trust the set value from contentHeight, as it was measured
        // before the zoom out mode was changed. After zoom out mode is changed,
        // appenders may appear or disappear, so we need to get the height from
        // the iframe at this point when we&#039;re about to animate the zoom out.
        // The iframe scrollTop, scrollHeight, and clientHeight will all be
        // the most accurate.
        transitionFromRef.current.scrollTop = iframeDocument.documentElement.scrollTop;
        transitionFromRef.current.scrollHeight = iframeDocument.documentElement.scrollHeight;
        // Use containerHeight, as it&#039;s the previous container height before the zoom out animation starts.
        transitionFromRef.current.containerHeight = containerHeight;
        transitionToRef.current = {
          scaleValue,
          frameSize,
          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.
        };
        transitionToRef.current.scrollHeight = computeScrollHeightNext(transitionFromRef.current, transitionToRef.current);
        transitionToRef.current.scrollTop = computeScrollTopNext(transitionFromRef.current, transitionToRef.current);
        animationRef.current = startZoomOutAnimation();

        // If the user prefers reduced motion, finish the animation immediately and set the final state.
        if (prefersReducedMotion) {
          finishZoomOutAnimation();
        } else {
          animationRef.current.onfinish = finishZoomOutAnimation;
        }
      }
    }
  }, [startZoomOutAnimation, finishZoomOutAnimation, prefersReducedMotion, isAutoScaled, scaleValue, frameSize, iframeDocument, contentHeight, containerWidth, containerHeight, maxContainerWidth, scaleContainerWidth]);
  return {
    isZoomedOut,
    scaleContainerWidth,
    contentResizeListener,
    containerResizeListener
  };
}

;// ./node_modules/@wordpress/block-editor/build-module/components/iframe/index.js
/* wp:polyfill */
/**
 * External dependencies
 */


/**
 * WordPress dependencies
 */






/**
 * Internal dependencies
 */






function bubbleEvent(event, Constructor, frame) {
  const init = {};
  for (const key in event) {
    init[key] = event[key];
  }

  // Check if the event is a MouseEvent generated within the iframe.
  // If so, adjust the coordinates to be relative to the position of
  // the iframe. This ensures that components such as Draggable
  // receive coordinates relative to the window, instead of relative
  // to the iframe. Without this, the Draggable event handler would
  // result in components &quot;jumping&quot; position as soon as the user
  // drags over the iframe.
  if (event instanceof frame.contentDocument.defaultView.MouseEvent) {
    const rect = frame.getBoundingClientRect();
    init.clientX += rect.left;
    init.clientY += rect.top;
  }
  const newEvent = new Constructor(event.type, init);
  if (init.defaultPrevented) {
    newEvent.preventDefault();
  }
  const cancelled = !frame.dispatchEvent(newEvent);
  if (cancelled) {
    event.preventDefault();
  }
}

/**
 * Bubbles some event types (keydown, keypress, and dragover) to parent document
 * document to ensure that the keyboard shortcuts and drag and drop work.
 *
 * Ideally, we should remove event bubbling in the future. Keyboard shortcuts
 * should be context dependent, e.g. actions on blocks like Cmd+A should not
 * work globally outside the block editor.
 *
 * @param {Document} iframeDocument Document to attach listeners to.
 */
function useBubbleEvents(iframeDocument) {
  return (0,external_wp_compose_namespaceObject.useRefEffect)(() =&gt; {
    const {
      defaultView
    } = iframeDocument;
    if (!defaultView) {
      return;
    }
    const {
      frameElement
    } = defaultView;
    const html = iframeDocument.documentElement;
    const eventTypes = [&#039;dragover&#039;, &#039;mousemove&#039;];
    const handlers = {};
    for (const name of eventTypes) {
      handlers[name] = event =&gt; {
        const prototype = Object.getPrototypeOf(event);
        const constructorName = prototype.constructor.name;
        const Constructor = window[constructorName];
        bubbleEvent(event, Constructor, frameElement);
      };
      html.addEventListener(name, handlers[name]);
    }
    return () =&gt; {
      for (const name of eventTypes) {
        html.removeEventListener(name, handlers[name]);
      }
    };
  });
}
function Iframe({
  contentRef,
  children,
  tabIndex = 0,
  scale = 1,
  frameSize = 0,
  readonly,
  forwardedRef: ref,
  title = (0,external_wp_i18n_namespaceObject.__)(&#039;Editor canvas&#039;),
  ...props
}) {
  const {
    resolvedAssets,
    isPreviewMode
  } = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      getSettings
    } = select(store);
    const settings = getSettings();
    return {
      resolvedAssets: settings.__unstableResolvedAssets,
      isPreviewMode: settings.isPreviewMode
    };
  }, []);
  const {
    styles = &#039;&#039;,
    scripts = &#039;&#039;
  } = resolvedAssets;
  /** @type {[Document, import(&#039;react&#039;).Dispatch&lt;Document&gt;]} */
  const [iframeDocument, setIframeDocument] = (0,external_wp_element_namespaceObject.useState)();
  const [bodyClasses, setBodyClasses] = (0,external_wp_element_namespaceObject.useState)([]);
  const clearerRef = useBlockSelectionClearer();
  const [before, writingFlowRef, after] = useWritingFlow();
  const setRef = (0,external_wp_compose_namespaceObject.useRefEffect)(node =&gt; {
    node._load = () =&gt; {
      setIframeDocument(node.contentDocument);
    };
    let iFrameDocument;
    // Prevent the default browser action for files dropped outside of dropzones.
    function preventFileDropDefault(event) {
      event.preventDefault();
    }
    const {
      ownerDocument
    } = node;

    // Ideally ALL classes that are added through get_body_class should
    // be added in the editor too, which we&#039;ll somehow have to get from
    // the server in the future (which will run the PHP filters).
    setBodyClasses(Array.from(ownerDocument.body.classList).filter(name =&gt; name.startsWith(&#039;admin-color-&#039;) || name.startsWith(&#039;post-type-&#039;) || name === &#039;wp-embed-responsive&#039;));
    function onLoad() {
      const {
        contentDocument
      } = node;
      const {
        documentElement
      } = contentDocument;
      iFrameDocument = contentDocument;
      documentElement.classList.add(&#039;block-editor-iframe__html&#039;);
      clearerRef(documentElement);
      contentDocument.dir = ownerDocument.dir;
      for (const compatStyle of getCompatibilityStyles()) {
        if (contentDocument.getElementById(compatStyle.id)) {
          continue;
        }
        contentDocument.head.appendChild(compatStyle.cloneNode(true));
        if (!isPreviewMode) {
          // eslint-disable-next-line no-console
          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);
        }
      }
      iFrameDocument.addEventListener(&#039;dragover&#039;, preventFileDropDefault, false);
      iFrameDocument.addEventListener(&#039;drop&#039;, preventFileDropDefault, false);
      // Prevent clicks on links from navigating away. Note that links
      // inside `contenteditable` are already disabled by the browser, so
      // this is for links in blocks outside of `contenteditable`.
      iFrameDocument.addEventListener(&#039;click&#039;, event =&gt; {
        if (event.target.tagName === &#039;A&#039;) {
          event.preventDefault();

          // Appending a hash to the current URL will not reload the
          // page. This is useful for e.g. footnotes.
          const href = event.target.getAttribute(&#039;href&#039;);
          if (href?.startsWith(&#039;#&#039;)) {
            iFrameDocument.defaultView.location.hash = href.slice(1);
          }
        }
      });
    }
    node.addEventListener(&#039;load&#039;, onLoad);
    return () =&gt; {
      delete node._load;
      node.removeEventListener(&#039;load&#039;, onLoad);
      iFrameDocument?.removeEventListener(&#039;dragover&#039;, preventFileDropDefault);
      iFrameDocument?.removeEventListener(&#039;drop&#039;, preventFileDropDefault);
    };
  }, []);
  const {
    contentResizeListener,
    containerResizeListener,
    isZoomedOut,
    scaleContainerWidth
  } = useScaleCanvas({
    scale,
    frameSize: parseInt(frameSize),
    iframeDocument
  });
  const disabledRef = (0,external_wp_compose_namespaceObject.useDisabled)({
    isDisabled: !readonly
  });
  const bodyRef = (0,external_wp_compose_namespaceObject.useMergeRefs)([useBubbleEvents(iframeDocument), contentRef, clearerRef, writingFlowRef, disabledRef]);

  // Correct doctype is required to enable rendering in standards
  // mode. Also preload the styles to avoid a flash of unstyled
  // content.
  const html = `&lt;!doctype html&gt;
&lt;html&gt;
	&lt;head&gt;
		&lt;meta charset=&quot;utf-8&quot;&gt;
		&lt;base href=&quot;${window.location.origin}&quot;&gt;
		&lt;script&gt;window.frameElement._load()&lt;/script&gt;
		&lt;style&gt;
			html{
				height: auto !important;
				min-height: 100%;
			}
			/* Lowest specificity to not override global styles */
			:where(body) {
				margin: 0;
				/* Default background color in case zoom out mode background
				colors the html element */
				background-color: white;
			}
		&lt;/style&gt;
		${styles}
		${scripts}
	&lt;/head&gt;
	&lt;body&gt;
		&lt;script&gt;document.currentScript.parentElement.remove()&lt;/script&gt;
	&lt;/body&gt;
&lt;/html&gt;`;
  const [src, cleanup] = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; {
    const _src = URL.createObjectURL(new window.Blob([html], {
      type: &#039;text/html&#039;
    }));
    return [_src, () =&gt; URL.revokeObjectURL(_src)];
  }, [html]);
  (0,external_wp_element_namespaceObject.useEffect)(() =&gt; cleanup, [cleanup]);

  // Make sure to not render the before and after focusable div elements in view
  // mode. They&#039;re only needed to capture focus in edit mode.
  const shouldRenderFocusCaptureElements = tabIndex &gt;= 0 &amp;&amp; !isPreviewMode;
  const iframe = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
    children: [shouldRenderFocusCaptureElements &amp;&amp; before, /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;iframe&quot;, {
      ...props,
      style: {
        ...props.style,
        height: props.style?.height,
        border: 0
      },
      ref: (0,external_wp_compose_namespaceObject.useMergeRefs)([ref, setRef]),
      tabIndex: tabIndex
      // Correct doctype is required to enable rendering in standards
      // mode. Also preload the styles to avoid a flash of unstyled
      // content.
      ,
      src: src,
      title: title,
      onKeyDown: event =&gt; {
        if (props.onKeyDown) {
          props.onKeyDown(event);
        }
        // If the event originates from inside the iframe, it means
        // it bubbled through the portal, but only with React
        // events. We need to to bubble native events as well,
        // though by doing so we also trigger another React event,
        // so we need to stop the propagation of this event to avoid
        // duplication.
        if (event.currentTarget.ownerDocument !== event.target.ownerDocument) {
          // We should only stop propagation of the React event,
          // the native event should further bubble inside the
          // iframe to the document and window.
          // Alternatively, we could consider redispatching the
          // native event in the iframe.
          const {
            stopPropagation
          } = event.nativeEvent;
          event.nativeEvent.stopPropagation = () =&gt; {};
          event.stopPropagation();
          event.nativeEvent.stopPropagation = stopPropagation;
          bubbleEvent(event, window.KeyboardEvent, event.currentTarget);
        }
      },
      children: iframeDocument &amp;&amp; (0,external_wp_element_namespaceObject.createPortal)(
      /*#__PURE__*/
      // We want to prevent React events from bubbling through the iframe
      // we bubble these manually.
      /* eslint-disable-next-line jsx-a11y/no-noninteractive-element-interactions */
      (0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;body&quot;, {
        ref: bodyRef,
        className: dist_clsx(&#039;block-editor-iframe__body&#039;, &#039;editor-styles-wrapper&#039;, ...bodyClasses),
        children: [contentResizeListener, /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalStyleProvider, {
          document: iframeDocument,
          children: children
        })]
      }), iframeDocument.documentElement)
    }), shouldRenderFocusCaptureElements &amp;&amp; after]
  });
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;div&quot;, {
    className: &quot;block-editor-iframe__container&quot;,
    children: [containerResizeListener, /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
      className: dist_clsx(&#039;block-editor-iframe__scale-container&#039;, isZoomedOut &amp;&amp; &#039;is-zoomed-out&#039;),
      style: {
        &#039;--wp-block-editor-iframe-zoom-out-scale-container-width&#039;: isZoomedOut &amp;&amp; `${scaleContainerWidth}px`
      },
      children: iframe
    })]
  });
}
function IframeIfReady(props, ref) {
  const isInitialised = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; select(store).getSettings().__internalIsInitialized, []);

  // We shouldn&#039;t render the iframe until the editor settings are initialised.
  // The initial settings are needed to get the styles for the srcDoc, which
  // cannot be changed after the iframe is mounted. srcDoc is used to to set
  // the initial iframe HTML, which is required to avoid a flash of unstyled
  // content.
  if (!isInitialised) {
    return null;
  }
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Iframe, {
    ...props,
    forwardedRef: ref
  });
}
/* harmony default export */ const iframe = ((0,external_wp_element_namespaceObject.forwardRef)(IframeIfReady));

;// ./node_modules/parsel-js/dist/parsel.js
const TOKENS = {
    attribute: /\[\s*(?:(?&lt;namespace&gt;\*|[-\w\P{ASCII}]*)\|)?(?&lt;name&gt;[-\w\P{ASCII}]+)\s*(?:(?&lt;operator&gt;\W?=)\s*(?&lt;value&gt;.+?)\s*(\s(?&lt;caseSensitive&gt;[iIsS]))?\s*)?\]/gu,
    id: /#(?&lt;name&gt;[-\w\P{ASCII}]+)/gu,
    class: /\.(?&lt;name&gt;[-\w\P{ASCII}]+)/gu,
    comma: /\s*,\s*/g,
    combinator: /\s*[\s&gt;+~]\s*/g,
    &#039;pseudo-element&#039;: /::(?&lt;name&gt;[-\w\P{ASCII}]+)(?:\((?&lt;argument&gt;Âĥ*)\))?/gu,
    &#039;pseudo-class&#039;: /:(?&lt;name&gt;[-\w\P{ASCII}]+)(?:\((?&lt;argument&gt;Âĥ*)\))?/gu,
    universal: /(?:(?&lt;namespace&gt;\*|[-\w\P{ASCII}]*)\|)?\*/gu,
    type: /(?:(?&lt;namespace&gt;\*|[-\w\P{ASCII}]*)\|)?(?&lt;name&gt;[-\w\P{ASCII}]+)/gu, // this must be last
};
const TRIM_TOKENS = new Set([&#039;combinator&#039;, &#039;comma&#039;]);
const RECURSIVE_PSEUDO_CLASSES = new Set([
    &#039;not&#039;,
    &#039;is&#039;,
    &#039;where&#039;,
    &#039;has&#039;,
    &#039;matches&#039;,
    &#039;-moz-any&#039;,
    &#039;-webkit-any&#039;,
    &#039;nth-child&#039;,
    &#039;nth-last-child&#039;,
]);
const nthChildRegExp = /(?&lt;index&gt;[\dn+-]+)\s+of\s+(?&lt;subtree&gt;.+)/;
const RECURSIVE_PSEUDO_CLASSES_ARGS = {
    &#039;nth-child&#039;: nthChildRegExp,
    &#039;nth-last-child&#039;: nthChildRegExp,
};
const getArgumentPatternByType = (type) =&gt; {
    switch (type) {
        case &#039;pseudo-element&#039;:
        case &#039;pseudo-class&#039;:
            return new RegExp(TOKENS[type].source.replace(&#039;(?&lt;argument&gt;Âĥ*)&#039;, &#039;(?&lt;argument&gt;.*)&#039;), &#039;gu&#039;);
        default:
            return TOKENS[type];
    }
};
function gobbleParens(text, offset) {
    let nesting = 0;
    let result = &#039;&#039;;
    for (; offset &lt; text.length; offset++) {
        const char = text[offset];
        switch (char) {
            case &#039;(&#039;:
                ++nesting;
                break;
            case &#039;)&#039;:
                --nesting;
                break;
        }
        result += char;
        if (nesting === 0) {
            return result;
        }
    }
    return result;
}
function tokenizeBy(text, grammar = TOKENS) {
    if (!text) {
        return [];
    }
    const tokens = [text];
    for (const [type, pattern] of Object.entries(grammar)) {
        for (let i = 0; i &lt; tokens.length; i++) {
            const token = tokens[i];
            if (typeof token !== &#039;string&#039;) {
                continue;
            }
            pattern.lastIndex = 0;
            const match = pattern.exec(token);
            if (!match) {
                continue;
            }
            const from = match.index - 1;
            const args = [];
            const content = match[0];
            const before = token.slice(0, from + 1);
            if (before) {
                args.push(before);
            }
            args.push({
                ...match.groups,
                type,
                content,
            });
            const after = token.slice(from + content.length + 1);
            if (after) {
                args.push(after);
            }
            tokens.splice(i, 1, ...args);
        }
    }
    let offset = 0;
    for (const token of tokens) {
        switch (typeof token) {
            case &#039;string&#039;:
                throw new Error(`Unexpected sequence ${token} found at index ${offset}`);
            case &#039;object&#039;:
                offset += token.content.length;
                token.pos = [offset - token.content.length, offset];
                if (TRIM_TOKENS.has(token.type)) {
                    token.content = token.content.trim() || &#039; &#039;;
                }
                break;
        }
    }
    return tokens;
}
const STRING_PATTERN = /([&#039;&quot;])([^\\\n]+?)\1/g;
const ESCAPE_PATTERN = /\\./g;
function parsel_tokenize(selector, grammar = TOKENS) {
    // Prevent leading/trailing whitespaces from being interpreted as combinators
    selector = selector.trim();
    if (selector === &#039;&#039;) {
        return [];
    }
    const replacements = [];
    // Replace escapes with placeholders.
    selector = selector.replace(ESCAPE_PATTERN, (value, offset) =&gt; {
        replacements.push({ value, offset });
        return &#039;\uE000&#039;.repeat(value.length);
    });
    // Replace strings with placeholders.
    selector = selector.replace(STRING_PATTERN, (value, quote, content, offset) =&gt; {
        replacements.push({ value, offset });
        return `${quote}${&#039;\uE001&#039;.repeat(content.length)}${quote}`;
    });
    // Replace parentheses with placeholders.
    {
        let pos = 0;
        let offset;
        while ((offset = selector.indexOf(&#039;(&#039;, pos)) &gt; -1) {
            const value = gobbleParens(selector, offset);
            replacements.push({ value, offset });
            selector = `${selector.substring(0, offset)}(${&#039;Âĥ&#039;.repeat(value.length - 2)})${selector.substring(offset + value.length)}`;
            pos = offset + value.length;
        }
    }
    // Now we have no nested structures and we can parse with regexes
    const tokens = tokenizeBy(selector, grammar);
    // Replace placeholders in reverse order.
    const changedTokens = new Set();
    for (const replacement of replacements.reverse()) {
        for (const token of tokens) {
            const { offset, value } = replacement;
            if (!(token.pos[0] &lt;= offset &amp;&amp;
                offset + value.length &lt;= token.pos[1])) {
                continue;
            }
            const { content } = token;
            const tokenOffset = offset - token.pos[0];
            token.content =
                content.slice(0, tokenOffset) +
                    value +
                    content.slice(tokenOffset + value.length);
            if (token.content !== content) {
                changedTokens.add(token);
            }
        }
    }
    // Update changed tokens.
    for (const token of changedTokens) {
        const pattern = getArgumentPatternByType(token.type);
        if (!pattern) {
            throw new Error(`Unknown token type: ${token.type}`);
        }
        pattern.lastIndex = 0;
        const match = pattern.exec(token.content);
        if (!match) {
            throw new Error(`Unable to parse content for ${token.type}: ${token.content}`);
        }
        Object.assign(token, match.groups);
    }
    return tokens;
}
/**
 *  Convert a flat list of tokens into a tree of complex &amp; compound selectors
 */
function nestTokens(tokens, { list = true } = {}) {
    if (list &amp;&amp; tokens.find((t) =&gt; t.type === &#039;comma&#039;)) {
        const selectors = [];
        const temp = [];
        for (let i = 0; i &lt; tokens.length; i++) {
            if (tokens[i].type === &#039;comma&#039;) {
                if (temp.length === 0) {
                    throw new Error(&#039;Incorrect comma at &#039; + i);
                }
                selectors.push(nestTokens(temp, { list: false }));
                temp.length = 0;
            }
            else {
                temp.push(tokens[i]);
            }
        }
        if (temp.length === 0) {
            throw new Error(&#039;Trailing comma&#039;);
        }
        else {
            selectors.push(nestTokens(temp, { list: false }));
        }
        return { type: &#039;list&#039;, list: selectors };
    }
    for (let i = tokens.length - 1; i &gt;= 0; i--) {
        let token = tokens[i];
        if (token.type === &#039;combinator&#039;) {
            let left = tokens.slice(0, i);
            let right = tokens.slice(i + 1);
            return {
                type: &#039;complex&#039;,
                combinator: token.content,
                left: nestTokens(left),
                right: nestTokens(right),
            };
        }
    }
    switch (tokens.length) {
        case 0:
            throw new Error(&#039;Could not build AST.&#039;);
        case 1:
            // If we&#039;re here, there are no combinators, so it&#039;s just a list.
            return tokens[0];
        default:
            return {
                type: &#039;compound&#039;,
                list: [...tokens], // clone to avoid pointers messing up the AST
            };
    }
}
/**
 * Traverse an AST in depth-first order
 */
function* flatten(node, 
/**
 * @internal
 */
parent) {
    switch (node.type) {
        case &#039;list&#039;:
            for (let child of node.list) {
                yield* flatten(child, node);
            }
            break;
        case &#039;complex&#039;:
            yield* flatten(node.left, node);
            yield* flatten(node.right, node);
            break;
        case &#039;compound&#039;:
            yield* node.list.map((token) =&gt; [token, node]);
            break;
        default:
            yield [node, parent];
    }
}
/**
 * Traverse an AST (or part thereof), in depth-first order
 */
function walk(node, visit, 
/**
 * @internal
 */
parent) {
    if (!node) {
        return;
    }
    for (const [token, ast] of flatten(node, parent)) {
        visit(token, ast);
    }
}
/**
 * Parse a CSS selector
 *
 * @param selector - The selector to parse
 * @param options.recursive - Whether to parse the arguments of pseudo-classes like :is(), :has() etc. Defaults to true.
 * @param options.list - Whether this can be a selector list (A, B, C etc). Defaults to true.
 */
function parse(selector, { recursive = true, list = true } = {}) {
    const tokens = parsel_tokenize(selector);
    if (!tokens) {
        return;
    }
    const ast = nestTokens(tokens, { list });
    if (!recursive) {
        return ast;
    }
    for (const [token] of flatten(ast)) {
        if (token.type !== &#039;pseudo-class&#039; || !token.argument) {
            continue;
        }
        if (!RECURSIVE_PSEUDO_CLASSES.has(token.name)) {
            continue;
        }
        let argument = token.argument;
        const childArg = RECURSIVE_PSEUDO_CLASSES_ARGS[token.name];
        if (childArg) {
            const match = childArg.exec(argument);
            if (!match) {
                continue;
            }
            Object.assign(token, match.groups);
            argument = match.groups[&#039;subtree&#039;];
        }
        if (!argument) {
            continue;
        }
        Object.assign(token, {
            subtree: parse(argument, {
                recursive: true,
                list: true,
            }),
        });
    }
    return ast;
}
/**
 * Converts the given list or (sub)tree to a string.
 */
function parsel_stringify(listOrNode) {
    let tokens;
    if (Array.isArray(listOrNode)) {
        tokens = listOrNode;
    }
    else {
        tokens = [...flatten(listOrNode)].map(([token]) =&gt; token);
    }
    return tokens.map(token =&gt; token.content).join(&#039;&#039;);
}
/**
 * To convert the specificity array to a number
 */
function specificityToNumber(specificity, base) {
    base = base || Math.max(...specificity) + 1;
    return (specificity[0] * (base &lt;&lt; 1) + specificity[1] * base + specificity[2]);
}
/**
 * Calculate specificity of a selector.
 *
 * If the selector is a list, the max specificity is returned.
 */
function specificity(selector) {
    let ast = selector;
    if (typeof ast === &#039;string&#039;) {
        ast = parse(ast, { recursive: true });
    }
    if (!ast) {
        return [];
    }
    if (ast.type === &#039;list&#039; &amp;&amp; &#039;list&#039; in ast) {
        let base = 10;
        const specificities = ast.list.map((ast) =&gt; {
            const sp = specificity(ast);
            base = Math.max(base, ...specificity(ast));
            return sp;
        });
        const numbers = specificities.map((ast) =&gt; specificityToNumber(ast, base));
        return specificities[numbers.indexOf(Math.max(...numbers))];
    }
    const ret = [0, 0, 0];
    for (const [token] of flatten(ast)) {
        switch (token.type) {
            case &#039;id&#039;:
                ret[0]++;
                break;
            case &#039;class&#039;:
            case &#039;attribute&#039;:
                ret[1]++;
                break;
            case &#039;pseudo-element&#039;:
            case &#039;type&#039;:
                ret[2]++;
                break;
            case &#039;pseudo-class&#039;:
                if (token.name === &#039;where&#039;) {
                    break;
                }
                if (!RECURSIVE_PSEUDO_CLASSES.has(token.name) ||
                    !token.subtree) {
                    ret[1]++;
                    break;
                }
                const sub = specificity(token.subtree);
                sub.forEach((s, i) =&gt; (ret[i] += s));
                // :nth-child() &amp; :nth-last-child() add (0, 1, 0) to the specificity of their most complex selector
                if (token.name === &#039;nth-child&#039; ||
                    token.name === &#039;nth-last-child&#039;) {
                    ret[1]++;
                }
        }
    }
    return ret;
}



// EXTERNAL MODULE: ./node_modules/postcss/lib/processor.js
var processor = __webpack_require__(9656);
var processor_default = /*#__PURE__*/__webpack_require__.n(processor);
// EXTERNAL MODULE: ./node_modules/postcss/lib/css-syntax-error.js
var css_syntax_error = __webpack_require__(356);
var css_syntax_error_default = /*#__PURE__*/__webpack_require__.n(css_syntax_error);
// EXTERNAL MODULE: ./node_modules/postcss-prefix-selector/index.js
var postcss_prefix_selector = __webpack_require__(1443);
var postcss_prefix_selector_default = /*#__PURE__*/__webpack_require__.n(postcss_prefix_selector);
// EXTERNAL MODULE: ./node_modules/postcss-urlrebase/index.js
var postcss_urlrebase = __webpack_require__(5404);
var postcss_urlrebase_default = /*#__PURE__*/__webpack_require__.n(postcss_urlrebase);
;// ./node_modules/@wordpress/block-editor/build-module/utils/transform-styles/index.js
/**
 * External dependencies
 */





const cacheByWrapperSelector = new Map();
const ROOT_SELECTOR_TOKENS = [{
  type: &#039;type&#039;,
  content: &#039;body&#039;
}, {
  type: &#039;type&#039;,
  content: &#039;html&#039;
}, {
  type: &#039;pseudo-class&#039;,
  content: &#039;:root&#039;
}, {
  type: &#039;pseudo-class&#039;,
  content: &#039;:where(body)&#039;
}, {
  type: &#039;pseudo-class&#039;,
  content: &#039;:where(:root)&#039;
}, {
  type: &#039;pseudo-class&#039;,
  content: &#039;:where(html)&#039;
}];

/**
 * Prefixes root selectors in a way that ensures consistent specificity.
 * This requires special handling, since prefixing a classname before
 * html, body, or :root will generally result in an invalid selector.
 *
 * Some libraries will simply replace the root selector with the prefix
 * instead, but this results in inconsistent specificity.
 *
 * This function instead inserts the prefix after the root tags but before
 * any other part of the selector. This results in consistent specificity:
 * - If a `:where()` selector is used for the prefix, all selectors output
 *   by `transformStyles` will have no specificity increase.
 * - If a classname, id, or something else is used as the prefix, all selectors
 *   will have the same specificity bump when transformed.
 *
 * @param {string} prefix   The prefix.
 * @param {string} selector The selector.
 *
 * @return {string} The prefixed root selector.
 */
function prefixRootSelector(prefix, selector) {
  // Use a tokenizer, since regular expressions are unreliable.
  const tokenized = parsel_tokenize(selector);

  // Find the last token that contains a root selector by walking back
  // through the tokens.
  const lastRootIndex = tokenized.findLastIndex(({
    content,
    type
  }) =&gt; {
    return ROOT_SELECTOR_TOKENS.some(rootSelector =&gt; content === rootSelector.content &amp;&amp; type === rootSelector.type);
  });

  // Walk forwards to find the combinator after the last root.
  // This is where the root ends and the rest of the selector begins,
  // and the index to insert before.
  // Doing it this way takes into account that a root selector like
  // &#039;body&#039; may have additional id/class/pseudo-class/attribute-selector
  // parts chained to it, which is difficult to quantify using a regex.
  let insertionPoint = -1;
  for (let i = lastRootIndex + 1; i &lt; tokenized.length; i++) {
    if (tokenized[i].type === &#039;combinator&#039;) {
      insertionPoint = i;
      break;
    }
  }

  // Tokenize and insert the prefix with a &#039; &#039; combinator before it.
  const tokenizedPrefix = parsel_tokenize(prefix);
  tokenized.splice(
  // Insert at the insertion point, or the end.
  insertionPoint === -1 ? tokenized.length : insertionPoint, 0, {
    type: &#039;combinator&#039;,
    content: &#039; &#039;
  }, ...tokenizedPrefix);
  return parsel_stringify(tokenized);
}
function transformStyle({
  css,
  ignoredSelectors = [],
  baseURL
}, wrapperSelector = &#039;&#039;, transformOptions) {
  // When there is no wrapper selector and no base URL, there is no need
  // to transform the CSS. This is most cases because in the default
  // iframed editor, no wrapping is needed, and not many styles
  // provide a base URL.
  if (!wrapperSelector &amp;&amp; !baseURL) {
    return css;
  }
  try {
    var _transformOptions$ign;
    const excludedSelectors = [...ignoredSelectors, ...((_transformOptions$ign = transformOptions?.ignoredSelectors) !== null &amp;&amp; _transformOptions$ign !== void 0 ? _transformOptions$ign : []), wrapperSelector];
    return new (processor_default())([wrapperSelector &amp;&amp; postcss_prefix_selector_default()({
      prefix: wrapperSelector,
      transform(prefix, selector, prefixedSelector) {
        // For backwards compatibility, don&#039;t use the `exclude` option
        // of postcss-prefix-selector, instead handle it here to match
        // the behavior of the old library (postcss-prefix-wrap) that
        // `transformStyle` previously used.
        if (excludedSelectors.some(excludedSelector =&gt; excludedSelector instanceof RegExp ? selector.match(excludedSelector) : selector.includes(excludedSelector))) {
          return selector;
        }
        const hasRootSelector = ROOT_SELECTOR_TOKENS.some(rootSelector =&gt; selector.startsWith(rootSelector.content));

        // Reorganize root selectors such that the root part comes before the prefix,
        // but the prefix still comes before the remaining part of the selector.
        if (hasRootSelector) {
          return prefixRootSelector(prefix, selector);
        }
        return prefixedSelector;
      }
    }), baseURL &amp;&amp; postcss_urlrebase_default()({
      rootUrl: baseURL
    })].filter(Boolean)).process(css, {}).css; // use sync PostCSS API
  } catch (error) {
    if (error instanceof (css_syntax_error_default())) {
      // eslint-disable-next-line no-console
      console.warn(&#039;wp.blockEditor.transformStyles Failed to transform CSS.&#039;, error.message + &#039;\n&#039; + error.showSourceCode(false));
    } else {
      // eslint-disable-next-line no-console
      console.warn(&#039;wp.blockEditor.transformStyles Failed to transform CSS.&#039;, error);
    }
    return null;
  }
}

/**
 * @typedef {Object} EditorStyle
 * @property {string}    css              the CSS block(s), as a single string.
 * @property {?string}   baseURL          the base URL to be used as the reference when rewriting urls.
 * @property {?string[]} ignoredSelectors the selectors not to wrap.
 */

/**
 * @typedef {Object} TransformOptions
 * @property {?string[]} ignoredSelectors the selectors not to wrap.
 */

/**
 * Applies a series of CSS rule transforms to wrap selectors inside a given class and/or rewrite URLs depending on the parameters passed.
 *
 * @param {EditorStyle[]}    styles           CSS rules.
 * @param {string}           wrapperSelector  Wrapper selector.
 * @param {TransformOptions} transformOptions Additional options for style transformation.
 * @return {Array} converted rules.
 */
const transform_styles_transformStyles = (styles, wrapperSelector = &#039;&#039;, transformOptions) =&gt; {
  let cache = cacheByWrapperSelector.get(wrapperSelector);
  if (!cache) {
    cache = new WeakMap();
    cacheByWrapperSelector.set(wrapperSelector, cache);
  }
  return styles.map(style =&gt; {
    let css = cache.get(style);
    if (!css) {
      css = transformStyle(style, wrapperSelector, transformOptions);
      cache.set(style, css);
    }
    return css;
  });
};
/* harmony default export */ const transform_styles = (transform_styles_transformStyles);

;// ./node_modules/@wordpress/block-editor/build-module/components/editor-styles/index.js
/**
 * External dependencies
 */




/**
 * WordPress dependencies
 */




/**
 * Internal dependencies
 */




k([names, a11y]);
function useDarkThemeBodyClassName(styles, scope) {
  return (0,external_wp_element_namespaceObject.useCallback)(node =&gt; {
    if (!node) {
      return;
    }
    const {
      ownerDocument
    } = node;
    const {
      defaultView,
      body
    } = ownerDocument;
    const canvas = scope ? ownerDocument.querySelector(scope) : body;
    let backgroundColor;
    if (!canvas) {
      // The real .editor-styles-wrapper element might not exist in the
      // DOM, so calculate the background color by creating a fake
      // wrapper.
      const tempCanvas = ownerDocument.createElement(&#039;div&#039;);
      tempCanvas.classList.add(&#039;editor-styles-wrapper&#039;);
      body.appendChild(tempCanvas);
      backgroundColor = defaultView?.getComputedStyle(tempCanvas, null).getPropertyValue(&#039;background-color&#039;);
      body.removeChild(tempCanvas);
    } else {
      backgroundColor = defaultView?.getComputedStyle(canvas, null).getPropertyValue(&#039;background-color&#039;);
    }
    const colordBackgroundColor = w(backgroundColor);
    // If background is transparent, it should be treated as light color.
    if (colordBackgroundColor.luminance() &gt; 0.5 || colordBackgroundColor.alpha() === 0) {
      body.classList.remove(&#039;is-dark-theme&#039;);
    } else {
      body.classList.add(&#039;is-dark-theme&#039;);
    }
  }, [styles, scope]);
}
function EditorStyles({
  styles,
  scope,
  transformOptions
}) {
  const overrides = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; unlock(select(store)).getStyleOverrides(), []);
  const [transformedStyles, transformedSvgs] = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; {
    const _styles = Object.values(styles !== null &amp;&amp; styles !== void 0 ? styles : []);
    for (const [id, override] of overrides) {
      const index = _styles.findIndex(({
        id: _id
      }) =&gt; id === _id);
      const overrideWithId = {
        ...override,
        id
      };
      if (index === -1) {
        _styles.push(overrideWithId);
      } else {
        _styles[index] = overrideWithId;
      }
    }
    return [transform_styles(_styles.filter(style =&gt; style?.css), scope, transformOptions), _styles.filter(style =&gt; style.__unstableType === &#039;svgs&#039;).map(style =&gt; style.assets).join(&#039;&#039;)];
  }, [styles, overrides, scope, transformOptions]);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;style&quot;, {
      ref: useDarkThemeBodyClassName(transformedStyles, scope)
    }), transformedStyles.map((css, index) =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;style&quot;, {
      children: css
    }, index)), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.SVG, {
      xmlns: &quot;http://www.w3.org/2000/svg&quot;,
      viewBox: &quot;0 0 0 0&quot;,
      width: &quot;0&quot;,
      height: &quot;0&quot;,
      role: &quot;none&quot;,
      style: {
        visibility: &#039;hidden&#039;,
        position: &#039;absolute&#039;,
        left: &#039;-9999px&#039;,
        overflow: &#039;hidden&#039;
      },
      dangerouslySetInnerHTML: {
        __html: transformedSvgs
      }
    })]
  });
}
/* harmony default export */ const editor_styles = ((0,external_wp_element_namespaceObject.memo)(EditorStyles));

;// ./node_modules/@wordpress/block-editor/build-module/components/block-preview/auto.js
/**
 * WordPress dependencies
 */





/**
 * Internal dependencies
 */





// This is used to avoid rendering the block list if the sizes change.

const MemoizedBlockList = (0,external_wp_element_namespaceObject.memo)(BlockList);
const MAX_HEIGHT = 2000;
const EMPTY_ADDITIONAL_STYLES = [];
function ScaledBlockPreview({
  viewportWidth,
  containerWidth,
  minHeight,
  additionalStyles = EMPTY_ADDITIONAL_STYLES
}) {
  if (!viewportWidth) {
    viewportWidth = containerWidth;
  }
  const [contentResizeListener, {
    height: contentHeight
  }] = (0,external_wp_compose_namespaceObject.useResizeObserver)();
  const {
    styles
  } = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const settings = select(store).getSettings();
    return {
      styles: settings.styles
    };
  }, []);

  // Avoid scrollbars for pattern previews.
  const editorStyles = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; {
    if (styles) {
      return [...styles, {
        css: &#039;body{height:auto;overflow:hidden;border:none;padding:0;}&#039;,
        __unstableType: &#039;presets&#039;
      }, ...additionalStyles];
    }
    return styles;
  }, [styles, additionalStyles]);
  const scale = containerWidth / viewportWidth;
  const aspectRatio = contentHeight ? containerWidth / (contentHeight * scale) : 0;
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Disabled, {
    className: &quot;block-editor-block-preview__content&quot;,
    style: {
      transform: `scale(${scale})`,
      // Using width + aspect-ratio instead of height here triggers browsers&#039; native
      // handling of scrollbar&#039;s visibility. It prevents the flickering issue seen
      // in https://github.com/WordPress/gutenberg/issues/52027.
      // See https://github.com/WordPress/gutenberg/pull/52921 for more info.
      aspectRatio,
      maxHeight: contentHeight &gt; MAX_HEIGHT ? MAX_HEIGHT * scale : undefined,
      minHeight
    },
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(iframe, {
      contentRef: (0,external_wp_compose_namespaceObject.useRefEffect)(bodyElement =&gt; {
        const {
          ownerDocument: {
            documentElement
          }
        } = bodyElement;
        documentElement.classList.add(&#039;block-editor-block-preview__content-iframe&#039;);
        documentElement.style.position = &#039;absolute&#039;;
        documentElement.style.width = &#039;100%&#039;;

        // Necessary for contentResizeListener to work.
        bodyElement.style.boxSizing = &#039;border-box&#039;;
        bodyElement.style.position = &#039;absolute&#039;;
        bodyElement.style.width = &#039;100%&#039;;
      }, []),
      &quot;aria-hidden&quot;: true,
      tabIndex: -1,
      style: {
        position: &#039;absolute&#039;,
        width: viewportWidth,
        height: contentHeight,
        pointerEvents: &#039;none&#039;,
        // This is a catch-all max-height for patterns.
        // See: https://github.com/WordPress/gutenberg/pull/38175.
        maxHeight: MAX_HEIGHT,
        minHeight: scale !== 0 &amp;&amp; scale &lt; 1 &amp;&amp; minHeight ? minHeight / scale : minHeight
      },
      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(editor_styles, {
        styles: editorStyles
      }), contentResizeListener, /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(MemoizedBlockList, {
        renderAppender: false
      })]
    })
  });
}
function AutoBlockPreview(props) {
  const [containerResizeListener, {
    width: containerWidth
  }] = (0,external_wp_compose_namespaceObject.useResizeObserver)();
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
      style: {
        position: &#039;relative&#039;,
        width: &#039;100%&#039;,
        height: 0
      },
      children: containerResizeListener
    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
      className: &quot;block-editor-block-preview__container&quot;,
      children: !!containerWidth &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ScaledBlockPreview, {
        ...props,
        containerWidth: containerWidth
      })
    })]
  });
}

;// external [&quot;wp&quot;,&quot;priorityQueue&quot;]
const external_wp_priorityQueue_namespaceObject = window[&quot;wp&quot;][&quot;priorityQueue&quot;];
;// ./node_modules/@wordpress/block-editor/build-module/components/block-preview/async.js
/**
 * WordPress dependencies
 */


const blockPreviewQueue = (0,external_wp_priorityQueue_namespaceObject.createQueue)();

/**
 * Renders a component at the next idle time.
 * @param {*} props
 */
function Async({
  children,
  placeholder
}) {
  const [shouldRender, setShouldRender] = (0,external_wp_element_namespaceObject.useState)(false);

  // In the future, we could try to use startTransition here, but currently
  // react will batch all transitions, which means all previews will be
  // rendered at the same time.
  // https://react.dev/reference/react/startTransition#caveats
  // &gt; If there are multiple ongoing Transitions, React currently batches them
  // &gt; together. This is a limitation that will likely be removed in a future
  // &gt; release.

  (0,external_wp_element_namespaceObject.useEffect)(() =&gt; {
    const context = {};
    blockPreviewQueue.add(context, () =&gt; {
      // Synchronously run all renders so it consumes timeRemaining.
      // See https://github.com/WordPress/gutenberg/pull/48238
      (0,external_wp_element_namespaceObject.flushSync)(() =&gt; {
        setShouldRender(true);
      });
    });
    return () =&gt; {
      blockPreviewQueue.cancel(context);
    };
  }, []);
  if (!shouldRender) {
    return placeholder;
  }
  return children;
}

;// ./node_modules/@wordpress/block-editor/build-module/components/block-preview/index.js
/**
 * External dependencies
 */


/**
 * WordPress dependencies
 */





/**
 * Internal dependencies
 */







const block_preview_EMPTY_ADDITIONAL_STYLES = [];
function BlockPreview({
  blocks,
  viewportWidth = 1200,
  minHeight,
  additionalStyles = block_preview_EMPTY_ADDITIONAL_STYLES,
  // Deprecated props:
  __experimentalMinHeight,
  __experimentalPadding
}) {
  if (__experimentalMinHeight) {
    minHeight = __experimentalMinHeight;
    external_wp_deprecated_default()(&#039;The __experimentalMinHeight prop&#039;, {
      since: &#039;6.2&#039;,
      version: &#039;6.4&#039;,
      alternative: &#039;minHeight&#039;
    });
  }
  if (__experimentalPadding) {
    additionalStyles = [...additionalStyles, {
      css: `body { padding: ${__experimentalPadding}px; }`
    }];
    external_wp_deprecated_default()(&#039;The __experimentalPadding prop of BlockPreview&#039;, {
      since: &#039;6.2&#039;,
      version: &#039;6.4&#039;,
      alternative: &#039;additionalStyles&#039;
    });
  }
  const originalSettings = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; select(store).getSettings(), []);
  const settings = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; ({
    ...originalSettings,
    focusMode: false,
    // Disable &quot;Spotlight mode&quot;.
    isPreviewMode: true
  }), [originalSettings]);
  const renderedBlocks = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; Array.isArray(blocks) ? blocks : [blocks], [blocks]);
  if (!blocks || blocks.length === 0) {
    return null;
  }
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ExperimentalBlockEditorProvider, {
    value: renderedBlocks,
    settings: settings,
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(AutoBlockPreview, {
      viewportWidth: viewportWidth,
      minHeight: minHeight,
      additionalStyles: additionalStyles
    })
  });
}
const MemoizedBlockPreview = (0,external_wp_element_namespaceObject.memo)(BlockPreview);
MemoizedBlockPreview.Async = Async;

/**
 * BlockPreview renders a preview of a block or array of blocks.
 *
 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/block-preview/README.md
 *
 * @param {Object}       preview               options for how the preview should be shown
 * @param {Array|Object} preview.blocks        A block instance (object) or an array of blocks to be previewed.
 * @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.
 *
 * @return {Component} The component to be rendered.
 */
/* harmony default export */ const block_preview = (MemoizedBlockPreview);

/**
 * This hook is used to lightly mark an element as a block preview wrapper
 * element. Call this hook and pass the returned props to the element to mark as
 * a block preview wrapper, automatically rendering inner blocks as children. If
 * you define a ref for the element, it is important to pass the ref to this
 * hook, which the hook in turn will pass to the component through the props it
 * returns. Optionally, you can also pass any other props through this hook, and
 * they will be merged and returned.
 *
 * @param {Object}    options        Preview options.
 * @param {WPBlock[]} options.blocks Block objects.
 * @param {Object}    options.props  Optional. Props to pass to the element. Must contain
 *                                   the ref if one is defined.
 * @param {Object}    options.layout Layout settings to be used in the preview.
 */
function useBlockPreview({
  blocks,
  props = {},
  layout
}) {
  const originalSettings = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; select(store).getSettings(), []);
  const settings = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; ({
    ...originalSettings,
    styles: undefined,
    // Clear styles included by the parent settings, as they are already output by the parent&#039;s EditorStyles.
    focusMode: false,
    // Disable &quot;Spotlight mode&quot;.
    isPreviewMode: true
  }), [originalSettings]);
  const disabledRef = (0,external_wp_compose_namespaceObject.useDisabled)();
  const ref = (0,external_wp_compose_namespaceObject.useMergeRefs)([props.ref, disabledRef]);
  const renderedBlocks = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; Array.isArray(blocks) ? blocks : [blocks], [blocks]);
  const children = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(ExperimentalBlockEditorProvider, {
    value: renderedBlocks,
    settings: settings,
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(editor_styles, {}), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockListItems, {
      renderAppender: false,
      layout: layout
    })]
  });
  return {
    ...props,
    ref,
    className: dist_clsx(props.className, &#039;block-editor-block-preview__live-content&#039;, &#039;components-disabled&#039;),
    children: blocks?.length ? children : null
  };
}

;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/preview-panel.js
/**
 * WordPress dependencies
 */




/**
 * Internal dependencies
 */



function InserterPreviewPanel({
  item
}) {
  var _example$viewportWidt;
  const {
    name,
    title,
    icon,
    description,
    initialAttributes,
    example
  } = item;
  const isReusable = (0,external_wp_blocks_namespaceObject.isReusableBlock)(item);
  const blocks = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; {
    if (!example) {
      return (0,external_wp_blocks_namespaceObject.createBlock)(name, initialAttributes);
    }
    return (0,external_wp_blocks_namespaceObject.getBlockFromExample)(name, {
      attributes: {
        ...example.attributes,
        ...initialAttributes
      },
      innerBlocks: example.innerBlocks
    });
  }, [name, example, initialAttributes]);
  // Same as height of BlockPreviewPanel.
  const previewHeight = 144;
  const sidebarWidth = 280;
  const viewportWidth = (_example$viewportWidt = example?.viewportWidth) !== null &amp;&amp; _example$viewportWidt !== void 0 ? _example$viewportWidt : 500;
  const scale = sidebarWidth / viewportWidth;
  const minHeight = scale !== 0 &amp;&amp; scale &lt; 1 &amp;&amp; previewHeight ? previewHeight / scale : previewHeight;
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;div&quot;, {
    className: &quot;block-editor-inserter__preview-container&quot;,
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
      className: &quot;block-editor-inserter__preview&quot;,
      children: isReusable || example ? /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
        className: &quot;block-editor-inserter__preview-content&quot;,
        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_preview, {
          blocks: blocks,
          viewportWidth: viewportWidth,
          minHeight: previewHeight,
          additionalStyles:
          //We want this CSS to be in sync with the one in BlockPreviewPanel.
          [{
            css: `
										body { 
											padding: 24px;
											min-height:${Math.round(minHeight)}px;
											display:flex;
											align-items:center;
										}
										.is-root-container { width: 100%; }
									`
          }]
        })
      }) : /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
        className: &quot;block-editor-inserter__preview-content-missing&quot;,
        children: (0,external_wp_i18n_namespaceObject.__)(&#039;No preview available.&#039;)
      })
    }), !isReusable &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_card, {
      title: title,
      icon: icon,
      description: description
    })]
  });
}
/* harmony default export */ const preview_panel = (InserterPreviewPanel);

;// ./node_modules/@wordpress/block-editor/build-module/components/inserter-listbox/item.js
/**
 * WordPress dependencies
 */



function InserterListboxItem({
  isFirst,
  as: Component,
  children,
  ...props
}, ref) {
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Composite.Item, {
    ref: ref,
    role: &quot;option&quot;
    // Use the Composite.Item `accessibleWhenDisabled` prop
    // over Button&#039;s `isFocusable`. The latter was shown to
    // cause an issue with tab order in the inserter list.
    ,
    accessibleWhenDisabled: true,
    ...props,
    render: htmlProps =&gt; {
      const propsWithTabIndex = {
        ...htmlProps,
        tabIndex: isFirst ? 0 : htmlProps.tabIndex
      };
      if (Component) {
        return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Component, {
          ...propsWithTabIndex,
          children: children
        });
      }
      if (typeof children === &#039;function&#039;) {
        return children(propsWithTabIndex);
      }
      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
        __next40pxDefaultSize: true,
        ...propsWithTabIndex,
        children: children
      });
    }
  });
}
/* harmony default export */ const inserter_listbox_item = ((0,external_wp_element_namespaceObject.forwardRef)(InserterListboxItem));

;// ./node_modules/@wordpress/block-editor/build-module/components/inserter-draggable-blocks/index.js
/**
 * WordPress dependencies
 */





/**
 * Internal dependencies
 */





const InserterDraggableBlocks = ({
  isEnabled,
  blocks,
  icon,
  children,
  pattern
}) =&gt; {
  const blockTypeIcon = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      getBlockType
    } = select(external_wp_blocks_namespaceObject.store);
    return blocks.length === 1 &amp;&amp; getBlockType(blocks[0].name)?.icon;
  }, [blocks]);
  const {
    startDragging,
    stopDragging
  } = unlock((0,external_wp_data_namespaceObject.useDispatch)(store));
  const patternBlock = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; {
    return pattern?.type === INSERTER_PATTERN_TYPES.user &amp;&amp; pattern?.syncStatus !== &#039;unsynced&#039; ? [(0,external_wp_blocks_namespaceObject.createBlock)(&#039;core/block&#039;, {
      ref: pattern.id
    })] : undefined;
  }, [pattern?.type, pattern?.syncStatus, pattern?.id]);
  if (!isEnabled) {
    return children({
      draggable: false,
      onDragStart: undefined,
      onDragEnd: undefined
    });
  }
  const draggableBlocks = patternBlock !== null &amp;&amp; patternBlock !== void 0 ? patternBlock : blocks;
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Draggable, {
    __experimentalTransferDataType: &quot;wp-blocks&quot;,
    transferData: {
      type: &#039;inserter&#039;,
      blocks: draggableBlocks
    },
    onDragStart: event =&gt; {
      startDragging();
      for (const block of draggableBlocks) {
        const type = `wp-block:${block.name}`;
        // This will fill in the dataTransfer.types array so that
        // the drop zone can check if the draggable is eligible.
        // Unfortuantely, on drag start, we don&#039;t have access to the
        // actual data, only the data keys/types.
        event.dataTransfer.items.add(&#039;&#039;, type);
      }
    },
    onDragEnd: () =&gt; {
      stopDragging();
    },
    __experimentalDragComponent: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockDraggableChip, {
      count: blocks.length,
      icon: icon || !pattern &amp;&amp; blockTypeIcon,
      isPattern: !!pattern
    }),
    children: ({
      onDraggableStart,
      onDraggableEnd
    }) =&gt; {
      return children({
        draggable: true,
        onDragStart: onDraggableStart,
        onDragEnd: onDraggableEnd
      });
    }
  });
};
/* harmony default export */ const inserter_draggable_blocks = (InserterDraggableBlocks);

;// ./node_modules/@wordpress/block-editor/build-module/components/inserter-list-item/index.js
/**
 * External dependencies
 */


/**
 * WordPress dependencies
 */





/**
 * Internal dependencies
 */




function InserterListItem({
  className,
  isFirst,
  item,
  onSelect,
  onHover,
  isDraggable,
  ...props
}) {
  const isDraggingRef = (0,external_wp_element_namespaceObject.useRef)(false);
  const itemIconStyle = item.icon ? {
    backgroundColor: item.icon.background,
    color: item.icon.foreground
  } : {};
  const blocks = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; [(0,external_wp_blocks_namespaceObject.createBlock)(item.name, item.initialAttributes, (0,external_wp_blocks_namespaceObject.createBlocksFromInnerBlocksTemplate)(item.innerBlocks))], [item.name, item.initialAttributes, item.innerBlocks]);
  const isSynced = (0,external_wp_blocks_namespaceObject.isReusableBlock)(item) &amp;&amp; item.syncStatus !== &#039;unsynced&#039; || (0,external_wp_blocks_namespaceObject.isTemplatePart)(item);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inserter_draggable_blocks, {
    isEnabled: isDraggable &amp;&amp; !item.isDisabled,
    blocks: blocks,
    icon: item.icon,
    children: ({
      draggable,
      onDragStart,
      onDragEnd
    }) =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
      className: dist_clsx(&#039;block-editor-block-types-list__list-item&#039;, {
        &#039;is-synced&#039;: isSynced
      }),
      draggable: draggable,
      onDragStart: event =&gt; {
        isDraggingRef.current = true;
        if (onDragStart) {
          onHover(null);
          onDragStart(event);
        }
      },
      onDragEnd: event =&gt; {
        isDraggingRef.current = false;
        if (onDragEnd) {
          onDragEnd(event);
        }
      },
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(inserter_listbox_item, {
        isFirst: isFirst,
        className: dist_clsx(&#039;block-editor-block-types-list__item&#039;, className),
        disabled: item.isDisabled,
        onClick: event =&gt; {
          event.preventDefault();
          onSelect(item, (0,external_wp_keycodes_namespaceObject.isAppleOS)() ? event.metaKey : event.ctrlKey);
          onHover(null);
        },
        onKeyDown: event =&gt; {
          const {
            keyCode
          } = event;
          if (keyCode === external_wp_keycodes_namespaceObject.ENTER) {
            event.preventDefault();
            onSelect(item, (0,external_wp_keycodes_namespaceObject.isAppleOS)() ? event.metaKey : event.ctrlKey);
            onHover(null);
          }
        },
        onMouseEnter: () =&gt; {
          if (isDraggingRef.current) {
            return;
          }
          onHover(item);
        },
        onMouseLeave: () =&gt; onHover(null),
        ...props,
        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;span&quot;, {
          className: &quot;block-editor-block-types-list__item-icon&quot;,
          style: itemIconStyle,
          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_icon, {
            icon: item.icon,
            showColors: true
          })
        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;span&quot;, {
          className: &quot;block-editor-block-types-list__item-title&quot;,
          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalTruncate, {
            numberOfLines: 3,
            children: item.title
          })
        })]
      })
    })
  });
}
/* harmony default export */ const inserter_list_item = ((0,external_wp_element_namespaceObject.memo)(InserterListItem));

;// ./node_modules/@wordpress/block-editor/build-module/components/inserter-listbox/group.js
/**
 * WordPress dependencies
 */




function InserterListboxGroup(props, ref) {
  const [shouldSpeak, setShouldSpeak] = (0,external_wp_element_namespaceObject.useState)(false);
  (0,external_wp_element_namespaceObject.useEffect)(() =&gt; {
    if (shouldSpeak) {
      (0,external_wp_a11y_namespaceObject.speak)((0,external_wp_i18n_namespaceObject.__)(&#039;Use left and right arrow keys to move through blocks&#039;));
    }
  }, [shouldSpeak]);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
    ref: ref,
    role: &quot;listbox&quot;,
    &quot;aria-orientation&quot;: &quot;horizontal&quot;,
    onFocus: () =&gt; {
      setShouldSpeak(true);
    },
    onBlur: event =&gt; {
      const focusingOutsideGroup = !event.currentTarget.contains(event.relatedTarget);
      if (focusingOutsideGroup) {
        setShouldSpeak(false);
      }
    },
    ...props
  });
}
/* harmony default export */ const group = ((0,external_wp_element_namespaceObject.forwardRef)(InserterListboxGroup));

;// ./node_modules/@wordpress/block-editor/build-module/components/inserter-listbox/row.js
/**
 * WordPress dependencies
 */



function InserterListboxRow(props, ref) {
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Composite.Group, {
    role: &quot;presentation&quot;,
    ref: ref,
    ...props
  });
}
/* harmony default export */ const inserter_listbox_row = ((0,external_wp_element_namespaceObject.forwardRef)(InserterListboxRow));

;// ./node_modules/@wordpress/block-editor/build-module/components/block-types-list/index.js
/**
 * WordPress dependencies
 */



/**
 * Internal dependencies
 */



function chunk(array, size) {
  const chunks = [];
  for (let i = 0, j = array.length; i &lt; j; i += size) {
    chunks.push(array.slice(i, i + size));
  }
  return chunks;
}
function BlockTypesList({
  items = [],
  onSelect,
  onHover = () =&gt; {},
  children,
  label,
  isDraggable = true
}) {
  const className = &#039;block-editor-block-types-list&#039;;
  const listId = (0,external_wp_compose_namespaceObject.useInstanceId)(BlockTypesList, className);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(group, {
    className: className,
    &quot;aria-label&quot;: label,
    children: [chunk(items, 3).map((row, i) =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inserter_listbox_row, {
      children: row.map((item, j) =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inserter_list_item, {
        item: item,
        className: (0,external_wp_blocks_namespaceObject.getBlockMenuDefaultClassName)(item.id),
        onSelect: onSelect,
        onHover: onHover,
        isDraggable: isDraggable &amp;&amp; !item.isDisabled,
        isFirst: i === 0 &amp;&amp; j === 0,
        rowId: `${listId}-${i}`
      }, item.id))
    }, i)), children]
  });
}
/* harmony default export */ const block_types_list = (BlockTypesList);

;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/panel.js
/**
 * WordPress dependencies
 */


function InserterPanel({
  title,
  icon,
  children
}) {
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;div&quot;, {
      className: &quot;block-editor-inserter__panel-header&quot;,
      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;h2&quot;, {
        className: &quot;block-editor-inserter__panel-title&quot;,
        children: title
      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Icon, {
        icon: icon
      })]
    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
      className: &quot;block-editor-inserter__panel-content&quot;,
      children: children
    })]
  });
}
/* harmony default export */ const panel = (InserterPanel);

;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/hooks/use-block-types-state.js
/**
 * WordPress dependencies
 */






/**
 * Internal dependencies
 */




/**
 * Retrieves the block types inserter state.
 *
 * @param {string=}  rootClientId Insertion&#039;s root client ID.
 * @param {Function} onInsert     function called when inserter a list of blocks.
 * @param {boolean}  isQuick
 * @return {Array} Returns the block types state. (block types, categories, collections, onSelect handler)
 */
const useBlockTypesState = (rootClientId, onInsert, isQuick) =&gt; {
  const options = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; ({
    [isFiltered]: !!isQuick
  }), [isQuick]);
  const [items] = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; [select(store).getInserterItems(rootClientId, options)], [rootClientId, options]);
  const {
    getClosestAllowedInsertionPoint
  } = unlock((0,external_wp_data_namespaceObject.useSelect)(store));
  const {
    createErrorNotice
  } = (0,external_wp_data_namespaceObject.useDispatch)(external_wp_notices_namespaceObject.store);
  const [categories, collections] = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      getCategories,
      getCollections
    } = select(external_wp_blocks_namespaceObject.store);
    return [getCategories(), getCollections()];
  }, []);
  const onSelectItem = (0,external_wp_element_namespaceObject.useCallback)(({
    name,
    initialAttributes,
    innerBlocks,
    syncStatus,
    content
  }, shouldFocusBlock) =&gt; {
    const destinationClientId = getClosestAllowedInsertionPoint(name, rootClientId);
    if (destinationClientId === null) {
      var _getBlockType$title;
      const title = (_getBlockType$title = (0,external_wp_blocks_namespaceObject.getBlockType)(name)?.title) !== null &amp;&amp; _getBlockType$title !== void 0 ? _getBlockType$title : name;
      createErrorNotice((0,external_wp_i18n_namespaceObject.sprintf)(/* translators: %s: block pattern title. */
      (0,external_wp_i18n_namespaceObject.__)(&#039;Block &quot;%s&quot; can\&#039;t be inserted.&#039;), title), {
        type: &#039;snackbar&#039;,
        id: &#039;inserter-notice&#039;
      });
      return;
    }
    const insertedBlock = syncStatus === &#039;unsynced&#039; ? (0,external_wp_blocks_namespaceObject.parse)(content, {
      __unstableSkipMigrationLogs: true
    }) : (0,external_wp_blocks_namespaceObject.createBlock)(name, initialAttributes, (0,external_wp_blocks_namespaceObject.createBlocksFromInnerBlocksTemplate)(innerBlocks));
    onInsert(insertedBlock, undefined, shouldFocusBlock, destinationClientId);
  }, [getClosestAllowedInsertionPoint, rootClientId, onInsert, createErrorNotice]);
  return [items, categories, collections, onSelectItem];
};
/* harmony default export */ const use_block_types_state = (useBlockTypesState);

;// ./node_modules/@wordpress/block-editor/build-module/components/inserter-listbox/index.js
/**
 * WordPress dependencies
 */


/**
 * Internal dependencies
 */




function InserterListbox({
  children
}) {
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Composite, {
    focusShift: true,
    focusWrap: &quot;horizontal&quot;,
    render: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_ReactJSXRuntime_namespaceObject.Fragment, {}),
    children: children
  });
}
/* harmony default export */ const inserter_listbox = (InserterListbox);

;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/no-results.js
/**
 * WordPress dependencies
 */


function InserterNoResults() {
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
    className: &quot;block-editor-inserter__no-results&quot;,
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;p&quot;, {
      children: (0,external_wp_i18n_namespaceObject.__)(&#039;No results found.&#039;)
    })
  });
}
/* harmony default export */ const no_results = (InserterNoResults);

;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/block-types-tab.js
/**
 * WordPress dependencies
 */




/**
 * Internal dependencies
 */







const getBlockNamespace = item =&gt; item.name.split(&#039;/&#039;)[0];
const MAX_SUGGESTED_ITEMS = 6;

/**
 * Shared reference to an empty array for cases where it is important to avoid
 * returning a new array reference on every invocation and rerendering the component.
 *
 * @type {Array}
 */
const block_types_tab_EMPTY_ARRAY = [];
function BlockTypesTabPanel({
  items,
  collections,
  categories,
  onSelectItem,
  onHover,
  showMostUsedBlocks,
  className
}) {
  const suggestedItems = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; {
    return orderBy(items, &#039;frecency&#039;, &#039;desc&#039;).slice(0, MAX_SUGGESTED_ITEMS);
  }, [items]);
  const uncategorizedItems = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; {
    return items.filter(item =&gt; !item.category);
  }, [items]);
  const itemsPerCollection = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; {
    // Create a new Object to avoid mutating collection.
    const result = {
      ...collections
    };
    Object.keys(collections).forEach(namespace =&gt; {
      result[namespace] = items.filter(item =&gt; getBlockNamespace(item) === namespace);
      if (result[namespace].length === 0) {
        delete result[namespace];
      }
    });
    return result;
  }, [items, collections]);

  // Hide block preview on unmount.
  (0,external_wp_element_namespaceObject.useEffect)(() =&gt; () =&gt; onHover(null), []);

  /**
   * The inserter contains a big number of blocks and opening it is a costful operation.
   * The rendering is the most costful part of it, in order to improve the responsiveness
   * of the &quot;opening&quot; action, these lazy lists allow us to render the inserter category per category,
   * once all the categories are rendered, we start rendering the collections and the uncategorized block types.
   */
  const currentlyRenderedCategories = (0,external_wp_compose_namespaceObject.useAsyncList)(categories);
  const didRenderAllCategories = categories.length === currentlyRenderedCategories.length;

  // Async List requires an array.
  const collectionEntries = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; {
    return Object.entries(collections);
  }, [collections]);
  const currentlyRenderedCollections = (0,external_wp_compose_namespaceObject.useAsyncList)(didRenderAllCategories ? collectionEntries : block_types_tab_EMPTY_ARRAY);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;div&quot;, {
    className: className,
    children: [showMostUsedBlocks &amp;&amp;
    // Only show the most used blocks if the total amount of block
    // is larger than 1 row, otherwise it is not so useful.
    items.length &gt; 3 &amp;&amp; !!suggestedItems.length &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(panel, {
      title: (0,external_wp_i18n_namespaceObject._x)(&#039;Most used&#039;, &#039;blocks&#039;),
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_types_list, {
        items: suggestedItems,
        onSelect: onSelectItem,
        onHover: onHover,
        label: (0,external_wp_i18n_namespaceObject._x)(&#039;Most used&#039;, &#039;blocks&#039;)
      })
    }), currentlyRenderedCategories.map(category =&gt; {
      const categoryItems = items.filter(item =&gt; item.category === category.slug);
      if (!categoryItems || !categoryItems.length) {
        return null;
      }
      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(panel, {
        title: category.title,
        icon: category.icon,
        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_types_list, {
          items: categoryItems,
          onSelect: onSelectItem,
          onHover: onHover,
          label: category.title
        })
      }, category.slug);
    }), didRenderAllCategories &amp;&amp; uncategorizedItems.length &gt; 0 &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(panel, {
      className: &quot;block-editor-inserter__uncategorized-blocks-panel&quot;,
      title: (0,external_wp_i18n_namespaceObject.__)(&#039;Uncategorized&#039;),
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_types_list, {
        items: uncategorizedItems,
        onSelect: onSelectItem,
        onHover: onHover,
        label: (0,external_wp_i18n_namespaceObject.__)(&#039;Uncategorized&#039;)
      })
    }), currentlyRenderedCollections.map(([namespace, collection]) =&gt; {
      const collectionItems = itemsPerCollection[namespace];
      if (!collectionItems || !collectionItems.length) {
        return null;
      }
      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(panel, {
        title: collection.title,
        icon: collection.icon,
        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_types_list, {
          items: collectionItems,
          onSelect: onSelectItem,
          onHover: onHover,
          label: collection.title
        })
      }, namespace);
    })]
  });
}
function BlockTypesTab({
  rootClientId,
  onInsert,
  onHover,
  showMostUsedBlocks
}, ref) {
  const [items, categories, collections, onSelectItem] = use_block_types_state(rootClientId, onInsert);
  if (!items.length) {
    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(no_results, {});
  }
  const itemsForCurrentRoot = [];
  const itemsRemaining = [];
  for (const item of items) {
    // Skip reusable blocks, they moved to the patterns tab.
    if (item.category === &#039;reusable&#039;) {
      continue;
    }
    if (item.isAllowedInCurrentRoot) {
      itemsForCurrentRoot.push(item);
    } else {
      itemsRemaining.push(item);
    }
  }
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inserter_listbox, {
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;div&quot;, {
      ref: ref,
      children: [!!itemsForCurrentRoot.length &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_ReactJSXRuntime_namespaceObject.Fragment, {
        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockTypesTabPanel, {
          items: itemsForCurrentRoot,
          categories: categories,
          collections: collections,
          onSelectItem: onSelectItem,
          onHover: onHover,
          showMostUsedBlocks: showMostUsedBlocks,
          className: &quot;block-editor-inserter__insertable-blocks-at-selection&quot;
        })
      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockTypesTabPanel, {
        items: itemsRemaining,
        categories: categories,
        collections: collections,
        onSelectItem: onSelectItem,
        onHover: onHover,
        showMostUsedBlocks: showMostUsedBlocks,
        className: &quot;block-editor-inserter__all-blocks&quot;
      })]
    })
  });
}
/* harmony default export */ const block_types_tab = ((0,external_wp_element_namespaceObject.forwardRef)(BlockTypesTab));

;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/block-patterns-explorer/pattern-explorer-sidebar.js
/**
 * WordPress dependencies
 */



function PatternCategoriesList({
  selectedCategory,
  patternCategories,
  onClickCategory
}) {
  const baseClassName = &#039;block-editor-block-patterns-explorer__sidebar&#039;;
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
    className: `${baseClassName}__categories-list`,
    children: patternCategories.map(({
      name,
      label
    }) =&gt; {
      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
        __next40pxDefaultSize: true,
        label: label,
        className: `${baseClassName}__categories-list__item`,
        isPressed: selectedCategory === name,
        onClick: () =&gt; {
          onClickCategory(name);
        },
        children: label
      }, name);
    })
  });
}
function PatternsExplorerSearch({
  searchValue,
  setSearchValue
}) {
  const baseClassName = &#039;block-editor-block-patterns-explorer__search&#039;;
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
    className: baseClassName,
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.SearchControl, {
      __nextHasNoMarginBottom: true,
      onChange: setSearchValue,
      value: searchValue,
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Search&#039;),
      placeholder: (0,external_wp_i18n_namespaceObject.__)(&#039;Search&#039;)
    })
  });
}
function PatternExplorerSidebar({
  selectedCategory,
  patternCategories,
  onClickCategory,
  searchValue,
  setSearchValue
}) {
  const baseClassName = &#039;block-editor-block-patterns-explorer__sidebar&#039;;
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;div&quot;, {
    className: baseClassName,
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PatternsExplorerSearch, {
      searchValue: searchValue,
      setSearchValue: setSearchValue
    }), !searchValue &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PatternCategoriesList, {
      selectedCategory: selectedCategory,
      patternCategories: patternCategories,
      onClickCategory: onClickCategory
    })]
  });
}
/* harmony default export */ const pattern_explorer_sidebar = (PatternExplorerSidebar);

;// ./node_modules/@wordpress/block-editor/build-module/components/block-patterns-paging/index.js
/**
 * WordPress dependencies
 */



function Pagination({
  currentPage,
  numPages,
  changePage,
  totalItems
}) {
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalVStack, {
    className: &quot;block-editor-patterns__grid-pagination-wrapper&quot;,
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalText, {
      variant: &quot;muted&quot;,
      children: (0,external_wp_i18n_namespaceObject.sprintf)(
      // translators: %s: Total number of patterns.
      (0,external_wp_i18n_namespaceObject._n)(&#039;%s item&#039;, &#039;%s items&#039;, totalItems), totalItems)
    }), numPages &gt; 1 &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalHStack, {
      expanded: false,
      spacing: 3,
      justify: &quot;flex-start&quot;,
      className: &quot;block-editor-patterns__grid-pagination&quot;,
      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalHStack, {
        expanded: false,
        spacing: 1,
        className: &quot;block-editor-patterns__grid-pagination-previous&quot;,
        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
          variant: &quot;tertiary&quot;,
          onClick: () =&gt; changePage(1),
          disabled: currentPage === 1,
          &quot;aria-label&quot;: (0,external_wp_i18n_namespaceObject.__)(&#039;First page&#039;),
          size: &quot;compact&quot;,
          accessibleWhenDisabled: true,
          className: &quot;block-editor-patterns__grid-pagination-button&quot;,
          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;span&quot;, {
            children: &quot;\xAB&quot;
          })
        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
          variant: &quot;tertiary&quot;,
          onClick: () =&gt; changePage(currentPage - 1),
          disabled: currentPage === 1,
          &quot;aria-label&quot;: (0,external_wp_i18n_namespaceObject.__)(&#039;Previous page&#039;),
          size: &quot;compact&quot;,
          accessibleWhenDisabled: true,
          className: &quot;block-editor-patterns__grid-pagination-button&quot;,
          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;span&quot;, {
            children: &quot;\u2039&quot;
          })
        })]
      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalText, {
        variant: &quot;muted&quot;,
        children: (0,external_wp_i18n_namespaceObject.sprintf)(
        // translators: 1: Current page number. 2: Total number of pages.
        (0,external_wp_i18n_namespaceObject._x)(&#039;%1$s of %2$s&#039;, &#039;paging&#039;), currentPage, numPages)
      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalHStack, {
        expanded: false,
        spacing: 1,
        className: &quot;block-editor-patterns__grid-pagination-next&quot;,
        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
          variant: &quot;tertiary&quot;,
          onClick: () =&gt; changePage(currentPage + 1),
          disabled: currentPage === numPages,
          &quot;aria-label&quot;: (0,external_wp_i18n_namespaceObject.__)(&#039;Next page&#039;),
          size: &quot;compact&quot;,
          accessibleWhenDisabled: true,
          className: &quot;block-editor-patterns__grid-pagination-button&quot;,
          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;span&quot;, {
            children: &quot;\u203A&quot;
          })
        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
          variant: &quot;tertiary&quot;,
          onClick: () =&gt; changePage(numPages),
          disabled: currentPage === numPages,
          &quot;aria-label&quot;: (0,external_wp_i18n_namespaceObject.__)(&#039;Last page&#039;),
          size: &quot;compact&quot;,
          accessibleWhenDisabled: true,
          className: &quot;block-editor-patterns__grid-pagination-button&quot;,
          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;span&quot;, {
            children: &quot;\xBB&quot;
          })
        })]
      })]
    })]
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/block-patterns-list/index.js
/**
 * External dependencies
 */


/**
 * WordPress dependencies
 */







/**
 * Internal dependencies
 */





const WithToolTip = ({
  showTooltip,
  title,
  children
}) =&gt; {
  if (showTooltip) {
    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Tooltip, {
      text: title,
      children: children
    });
  }
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_ReactJSXRuntime_namespaceObject.Fragment, {
    children: children
  });
};
function BlockPattern({
  id,
  isDraggable,
  pattern,
  onClick,
  onHover,
  showTitlesAsTooltip,
  category,
  isSelected
}) {
  const [isDragging, setIsDragging] = (0,external_wp_element_namespaceObject.useState)(false);
  const {
    blocks,
    viewportWidth
  } = pattern;
  const instanceId = (0,external_wp_compose_namespaceObject.useInstanceId)(BlockPattern);
  const descriptionId = `block-editor-block-patterns-list__item-description-${instanceId}`;
  const isUserPattern = pattern.type === INSERTER_PATTERN_TYPES.user;

  // When we have a selected category and the pattern is draggable, we need to update the
  // pattern&#039;s categories in metadata to only contain the selected category, and pass this to
  // InserterDraggableBlocks component. We do that because we use this information for pattern
  // shuffling and it makes more sense to show only the ones from the initially selected category during insertion.
  const patternBlocks = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; {
    if (!category || !isDraggable) {
      return blocks;
    }
    return (blocks !== null &amp;&amp; blocks !== void 0 ? blocks : []).map(block =&gt; {
      const clonedBlock = (0,external_wp_blocks_namespaceObject.cloneBlock)(block);
      if (clonedBlock.attributes.metadata?.categories?.includes(category)) {
        clonedBlock.attributes.metadata.categories = [category];
      }
      return clonedBlock;
    });
  }, [blocks, isDraggable, category]);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inserter_draggable_blocks, {
    isEnabled: isDraggable,
    blocks: patternBlocks,
    pattern: pattern,
    children: ({
      draggable,
      onDragStart,
      onDragEnd
    }) =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
      className: &quot;block-editor-block-patterns-list__list-item&quot;,
      draggable: draggable,
      onDragStart: event =&gt; {
        setIsDragging(true);
        if (onDragStart) {
          onHover?.(null);
          onDragStart(event);
        }
      },
      onDragEnd: event =&gt; {
        setIsDragging(false);
        if (onDragEnd) {
          onDragEnd(event);
        }
      },
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(WithToolTip, {
        showTooltip: showTitlesAsTooltip &amp;&amp; !isUserPattern,
        title: pattern.title,
        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.Composite.Item, {
          render: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
            role: &quot;option&quot;,
            &quot;aria-label&quot;: pattern.title,
            &quot;aria-describedby&quot;: pattern.description ? descriptionId : undefined,
            className: dist_clsx(&#039;block-editor-block-patterns-list__item&#039;, {
              &#039;block-editor-block-patterns-list__list-item-synced&#039;: pattern.type === INSERTER_PATTERN_TYPES.user &amp;&amp; !pattern.syncStatus,
              &#039;is-selected&#039;: isSelected
            })
          }),
          id: id,
          onClick: () =&gt; {
            onClick(pattern, blocks);
            onHover?.(null);
          },
          onMouseEnter: () =&gt; {
            if (isDragging) {
              return;
            }
            onHover?.(pattern);
          },
          onMouseLeave: () =&gt; onHover?.(null),
          children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_preview.Async, {
            placeholder: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockPatternPlaceholder, {}),
            children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_preview, {
              blocks: blocks,
              viewportWidth: viewportWidth
            })
          }), (!showTitlesAsTooltip || isUserPattern) &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalHStack, {
            className: &quot;block-editor-patterns__pattern-details&quot;,
            spacing: 2,
            children: [isUserPattern &amp;&amp; !pattern.syncStatus &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
              className: &quot;block-editor-patterns__pattern-icon-wrapper&quot;,
              children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(build_module_icon, {
                className: &quot;block-editor-patterns__pattern-icon&quot;,
                icon: library_symbol
              })
            }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
              className: &quot;block-editor-block-patterns-list__item-title&quot;,
              children: pattern.title
            })]
          }), !!pattern.description &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.VisuallyHidden, {
            id: descriptionId,
            children: pattern.description
          })]
        })
      })
    })
  });
}
function BlockPatternPlaceholder() {
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
    className: &quot;block-editor-block-patterns-list__item is-placeholder&quot;
  });
}
function BlockPatternsList({
  isDraggable,
  blockPatterns,
  onHover,
  onClickPattern,
  orientation,
  label = (0,external_wp_i18n_namespaceObject.__)(&#039;Block patterns&#039;),
  category,
  showTitlesAsTooltip,
  pagingProps
}, ref) {
  const [activeCompositeId, setActiveCompositeId] = (0,external_wp_element_namespaceObject.useState)(undefined);
  const [activePattern, setActivePattern] = (0,external_wp_element_namespaceObject.useState)(null); // State to track active pattern

  (0,external_wp_element_namespaceObject.useEffect)(() =&gt; {
    // Reset the active composite item whenever the available patterns change,
    // to make sure that Composite widget can receive focus correctly when its
    // composite items change. The first composite item will receive focus.
    const firstCompositeItemId = blockPatterns[0]?.name;
    setActiveCompositeId(firstCompositeItemId);
  }, [blockPatterns]);
  const handleClickPattern = (pattern, blocks) =&gt; {
    setActivePattern(pattern.name);
    onClickPattern(pattern, blocks);
  };
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.Composite, {
    orientation: orientation,
    activeId: activeCompositeId,
    setActiveId: setActiveCompositeId,
    role: &quot;listbox&quot;,
    className: &quot;block-editor-block-patterns-list&quot;,
    &quot;aria-label&quot;: label,
    ref: ref,
    children: [blockPatterns.map(pattern =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockPattern, {
      id: pattern.name,
      pattern: pattern,
      onClick: handleClickPattern,
      onHover: onHover,
      isDraggable: isDraggable,
      showTitlesAsTooltip: showTitlesAsTooltip,
      category: category,
      isSelected: !!activePattern &amp;&amp; activePattern === pattern.name
    }, pattern.name)), pagingProps &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Pagination, {
      ...pagingProps
    })]
  });
}
/* harmony default export */ const block_patterns_list = ((0,external_wp_element_namespaceObject.forwardRef)(BlockPatternsList));

;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/hooks/use-insertion-point.js
/**
 * WordPress dependencies
 */






/**
 * Internal dependencies
 */


function getIndex({
  destinationRootClientId,
  destinationIndex,
  rootClientId,
  registry
}) {
  if (rootClientId === destinationRootClientId) {
    return destinationIndex;
  }
  const parents = [&#039;&#039;, ...registry.select(store).getBlockParents(destinationRootClientId), destinationRootClientId];
  const parentIndex = parents.indexOf(rootClientId);
  if (parentIndex !== -1) {
    return registry.select(store).getBlockIndex(parents[parentIndex + 1]) + 1;
  }
  return registry.select(store).getBlockOrder(rootClientId).length;
}

/**
 * @typedef WPInserterConfig
 *
 * @property {string=}   rootClientId   If set, insertion will be into the
 *                                      block with this ID.
 * @property {number=}   insertionIndex If set, insertion will be into this
 *                                      explicit position.
 * @property {string=}   clientId       If set, insertion will be after the
 *                                      block with this ID.
 * @property {boolean=}  isAppender     Whether the inserter is an appender
 *                                      or not.
 * @property {Function=} onSelect       Called after insertion.
 */

/**
 * Returns the insertion point state given the inserter config.
 *
 * @param {WPInserterConfig} config Inserter Config.
 * @return {Array} Insertion Point State (rootClientID, onInsertBlocks and onToggle).
 */
function useInsertionPoint({
  rootClientId = &#039;&#039;,
  insertionIndex,
  clientId,
  isAppender,
  onSelect,
  shouldFocusBlock = true,
  selectBlockOnInsert = true
}) {
  const registry = (0,external_wp_data_namespaceObject.useRegistry)();
  const {
    getSelectedBlock,
    getClosestAllowedInsertionPoint,
    isBlockInsertionPointVisible
  } = unlock((0,external_wp_data_namespaceObject.useSelect)(store));
  const {
    destinationRootClientId,
    destinationIndex
  } = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      getSelectedBlockClientId,
      getBlockRootClientId,
      getBlockIndex,
      getBlockOrder,
      getInsertionPoint
    } = unlock(select(store));
    const selectedBlockClientId = getSelectedBlockClientId();
    let _destinationRootClientId = rootClientId;
    let _destinationIndex;
    const insertionPoint = getInsertionPoint();
    if (insertionIndex !== undefined) {
      // Insert into a specific index.
      _destinationIndex = insertionIndex;
    } else if (insertionPoint &amp;&amp; insertionPoint.hasOwnProperty(&#039;index&#039;)) {
      _destinationRootClientId = insertionPoint?.rootClientId ? insertionPoint.rootClientId : rootClientId;
      _destinationIndex = insertionPoint.index;
    } else if (clientId) {
      // Insert after a specific client ID.
      _destinationIndex = getBlockIndex(clientId);
    } else if (!isAppender &amp;&amp; selectedBlockClientId) {
      _destinationRootClientId = getBlockRootClientId(selectedBlockClientId);
      _destinationIndex = getBlockIndex(selectedBlockClientId) + 1;
    } else {
      // Insert at the end of the list.
      _destinationIndex = getBlockOrder(_destinationRootClientId).length;
    }
    return {
      destinationRootClientId: _destinationRootClientId,
      destinationIndex: _destinationIndex
    };
  }, [rootClientId, insertionIndex, clientId, isAppender]);
  const {
    replaceBlocks,
    insertBlocks,
    showInsertionPoint,
    hideInsertionPoint,
    setLastFocus
  } = unlock((0,external_wp_data_namespaceObject.useDispatch)(store));
  const onInsertBlocks = (0,external_wp_element_namespaceObject.useCallback)((blocks, meta, shouldForceFocusBlock = false, _rootClientId) =&gt; {
    // When we are trying to move focus or select a new block on insert, we also
    // need to clear the last focus to avoid the focus being set to the wrong block
    // when tabbing back into the canvas if the block was added from outside the
    // editor canvas.
    if (shouldForceFocusBlock || shouldFocusBlock || selectBlockOnInsert) {
      setLastFocus(null);
    }
    const selectedBlock = getSelectedBlock();
    if (!isAppender &amp;&amp; selectedBlock &amp;&amp; (0,external_wp_blocks_namespaceObject.isUnmodifiedDefaultBlock)(selectedBlock)) {
      replaceBlocks(selectedBlock.clientId, blocks, null, shouldFocusBlock || shouldForceFocusBlock ? 0 : null, meta);
    } else {
      insertBlocks(blocks, isAppender || _rootClientId === undefined ? destinationIndex : getIndex({
        destinationRootClientId,
        destinationIndex,
        rootClientId: _rootClientId,
        registry
      }), isAppender || _rootClientId === undefined ? destinationRootClientId : _rootClientId, selectBlockOnInsert, shouldFocusBlock || shouldForceFocusBlock ? 0 : null, meta);
    }
    const blockLength = Array.isArray(blocks) ? blocks.length : 1;
    const message = (0,external_wp_i18n_namespaceObject.sprintf)(
    // translators: %d: the name of the block that has been added
    (0,external_wp_i18n_namespaceObject._n)(&#039;%d block added.&#039;, &#039;%d blocks added.&#039;, blockLength), blockLength);
    (0,external_wp_a11y_namespaceObject.speak)(message);
    if (onSelect) {
      onSelect(blocks);
    }
  }, [isAppender, getSelectedBlock, replaceBlocks, insertBlocks, destinationRootClientId, destinationIndex, onSelect, shouldFocusBlock, selectBlockOnInsert]);
  const onToggleInsertionPoint = (0,external_wp_element_namespaceObject.useCallback)(item =&gt; {
    if (item &amp;&amp; !isBlockInsertionPointVisible()) {
      const allowedDestinationRootClientId = getClosestAllowedInsertionPoint(item.name, destinationRootClientId);
      if (allowedDestinationRootClientId !== null) {
        showInsertionPoint(allowedDestinationRootClientId, getIndex({
          destinationRootClientId,
          destinationIndex,
          rootClientId: allowedDestinationRootClientId,
          registry
        }));
      }
    } else {
      hideInsertionPoint();
    }
  }, [getClosestAllowedInsertionPoint, isBlockInsertionPointVisible, showInsertionPoint, hideInsertionPoint, destinationRootClientId, destinationIndex]);
  return [destinationRootClientId, onInsertBlocks, onToggleInsertionPoint];
}
/* harmony default export */ const use_insertion_point = (useInsertionPoint);

;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/hooks/use-patterns-state.js
/**
 * WordPress dependencies
 */






/**
 * Internal dependencies
 */





/**
 * Retrieves the block patterns inserter state.
 *
 * @param {Function} onInsert         function called when inserter a list of blocks.
 * @param {string=}  rootClientId     Insertion&#039;s root client ID.
 * @param {string}   selectedCategory The selected pattern category.
 * @param {boolean}  isQuick          For the quick inserter render only allowed patterns.
 *
 * @return {Array} Returns the patterns state. (patterns, categories, onSelect handler)
 */
const usePatternsState = (onInsert, rootClientId, selectedCategory, isQuick) =&gt; {
  const options = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; ({
    [isFiltered]: !!isQuick
  }), [isQuick]);
  const {
    patternCategories,
    patterns,
    userPatternCategories
  } = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      getSettings,
      __experimentalGetAllowedPatterns
    } = unlock(select(store));
    const {
      __experimentalUserPatternCategories,
      __experimentalBlockPatternCategories
    } = getSettings();
    return {
      patterns: __experimentalGetAllowedPatterns(rootClientId, options),
      userPatternCategories: __experimentalUserPatternCategories,
      patternCategories: __experimentalBlockPatternCategories
    };
  }, [rootClientId, options]);
  const {
    getClosestAllowedInsertionPointForPattern
  } = unlock((0,external_wp_data_namespaceObject.useSelect)(store));
  const allCategories = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; {
    const categories = [...patternCategories];
    userPatternCategories?.forEach(userCategory =&gt; {
      if (!categories.find(existingCategory =&gt; existingCategory.name === userCategory.name)) {
        categories.push(userCategory);
      }
    });
    return categories;
  }, [patternCategories, userPatternCategories]);
  const {
    createSuccessNotice
  } = (0,external_wp_data_namespaceObject.useDispatch)(external_wp_notices_namespaceObject.store);
  const onClickPattern = (0,external_wp_element_namespaceObject.useCallback)((pattern, blocks) =&gt; {
    const destinationRootClientId = isQuick ? rootClientId : getClosestAllowedInsertionPointForPattern(pattern, rootClientId);
    if (destinationRootClientId === null) {
      return;
    }
    const patternBlocks = pattern.type === INSERTER_PATTERN_TYPES.user &amp;&amp; pattern.syncStatus !== &#039;unsynced&#039; ? [(0,external_wp_blocks_namespaceObject.createBlock)(&#039;core/block&#039;, {
      ref: pattern.id
    })] : blocks;
    onInsert((patternBlocks !== null &amp;&amp; patternBlocks !== void 0 ? patternBlocks : []).map(block =&gt; {
      const clonedBlock = (0,external_wp_blocks_namespaceObject.cloneBlock)(block);
      if (clonedBlock.attributes.metadata?.categories?.includes(selectedCategory)) {
        clonedBlock.attributes.metadata.categories = [selectedCategory];
      }
      return clonedBlock;
    }), pattern.name, false, destinationRootClientId);
    createSuccessNotice((0,external_wp_i18n_namespaceObject.sprintf)(/* translators: %s: block pattern title. */
    (0,external_wp_i18n_namespaceObject.__)(&#039;Block pattern &quot;%s&quot; inserted.&#039;), pattern.title), {
      type: &#039;snackbar&#039;,
      id: &#039;inserter-notice&#039;
    });
  }, [createSuccessNotice, onInsert, selectedCategory, rootClientId, getClosestAllowedInsertionPointForPattern, isQuick]);
  return [patterns, allCategories, onClickPattern];
};
/* harmony default export */ const use_patterns_state = (usePatternsState);

// EXTERNAL MODULE: ./node_modules/remove-accents/index.js
var remove_accents = __webpack_require__(9681);
var remove_accents_default = /*#__PURE__*/__webpack_require__.n(remove_accents);
;// ./node_modules/lower-case/dist.es2015/index.js
/**
 * Source: ftp://ftp.unicode.org/Public/UCD/latest/ucd/SpecialCasing.txt
 */
var SUPPORTED_LOCALE = {
    tr: {
        regexp: /\u0130|\u0049|\u0049\u0307/g,
        map: {
            Ä°: &quot;\u0069&quot;,
            I: &quot;\u0131&quot;,
            İ: &quot;\u0069&quot;,
        },
    },
    az: {
        regexp: /\u0130/g,
        map: {
            Ä°: &quot;\u0069&quot;,
            I: &quot;\u0131&quot;,
            İ: &quot;\u0069&quot;,
        },
    },
    lt: {
        regexp: /\u0049|\u004A|\u012E|\u00CC|\u00CD|\u0128/g,
        map: {
            I: &quot;\u0069\u0307&quot;,
            J: &quot;\u006A\u0307&quot;,
            �: &quot;\u012F\u0307&quot;,
            �Œ: &quot;\u0069\u0307\u0300&quot;,
            �: &quot;\u0069\u0307\u0301&quot;,
            Ĩ: &quot;\u0069\u0307\u0303&quot;,
        },
    },
};
/**
 * Localized lower case.
 */
function localeLowerCase(str, locale) {
    var lang = SUPPORTED_LOCALE[locale.toLowerCase()];
    if (lang)
        return lowerCase(str.replace(lang.regexp, function (m) { return lang.map[m]; }));
    return lowerCase(str);
}
/**
 * Lower case as a function.
 */
function lowerCase(str) {
    return str.toLowerCase();
}

;// ./node_modules/no-case/dist.es2015/index.js

// Support camel case (&quot;camelCase&quot; -&gt; &quot;camel Case&quot; and &quot;CAMELCase&quot; -&gt; &quot;CAMEL Case&quot;).
var DEFAULT_SPLIT_REGEXP = [/([a-z0-9])([A-Z])/g, /([A-Z])([A-Z][a-z])/g];
// Remove all non-word characters.
var DEFAULT_STRIP_REGEXP = /[^A-Z0-9]+/gi;
/**
 * Normalize the string into something other libraries can manipulate easier.
 */
function noCase(input, options) {
    if (options === void 0) { options = {}; }
    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 ? &quot; &quot; : _d;
    var result = dist_es2015_replace(dist_es2015_replace(input, splitRegexp, &quot;$1\0$2&quot;), stripRegexp, &quot;\0&quot;);
    var start = 0;
    var end = result.length;
    // Trim the delimiter from around the output string.
    while (result.charAt(start) === &quot;\0&quot;)
        start++;
    while (result.charAt(end - 1) === &quot;\0&quot;)
        end--;
    // Transform each token independently.
    return result.slice(start, end).split(&quot;\0&quot;).map(transform).join(delimiter);
}
/**
 * Replace `re` in the input string with the replacement value.
 */
function dist_es2015_replace(input, re, value) {
    if (re instanceof RegExp)
        return input.replace(re, value);
    return re.reduce(function (input, re) { return input.replace(re, value); }, input);
}

;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/search-items.js
/**
 * External dependencies
 */



// Default search helpers.
const defaultGetName = item =&gt; item.name || &#039;&#039;;
const defaultGetTitle = item =&gt; item.title;
const defaultGetDescription = item =&gt; item.description || &#039;&#039;;
const defaultGetKeywords = item =&gt; item.keywords || [];
const defaultGetCategory = item =&gt; item.category;
const defaultGetCollection = () =&gt; null;

// Normalization regexes
const splitRegexp = [/([\p{Ll}\p{Lo}\p{N}])([\p{Lu}\p{Lt}])/gu,
// One lowercase or digit, followed by one uppercase.
/([\p{Lu}\p{Lt}])([\p{Lu}\p{Lt}][\p{Ll}\p{Lo}])/gu // One uppercase followed by one uppercase and one lowercase.
];
const stripRegexp = /(\p{C}|\p{P}|\p{S})+/giu; // Anything that&#039;s not a punctuation, symbol or control/format character.

// Normalization cache
const extractedWords = new Map();
const normalizedStrings = new Map();

/**
 * Extracts words from an input string.
 *
 * @param {string} input The input string.
 *
 * @return {Array} Words, extracted from the input string.
 */
function extractWords(input = &#039;&#039;) {
  if (extractedWords.has(input)) {
    return extractedWords.get(input);
  }
  const result = noCase(input, {
    splitRegexp,
    stripRegexp
  }).split(&#039; &#039;).filter(Boolean);
  extractedWords.set(input, result);
  return result;
}

/**
 * Sanitizes the search input string.
 *
 * @param {string} input The search input to normalize.
 *
 * @return {string} The normalized search input.
 */
function normalizeString(input = &#039;&#039;) {
  if (normalizedStrings.has(input)) {
    return normalizedStrings.get(input);
  }

  // Disregard diacritics.
  //  Input: &quot;m�İdia&quot;
  let result = remove_accents_default()(input);

  // Accommodate leading slash, matching autocomplete expectations.
  //  Input: &quot;/media&quot;
  result = result.replace(/^\//, &#039;&#039;);

  // Lowercase.
  //  Input: &quot;MEDIA&quot;
  result = result.toLowerCase();
  normalizedStrings.set(input, result);
  return result;
}

/**
 * Converts the search term into a list of normalized terms.
 *
 * @param {string} input The search term to normalize.
 *
 * @return {string[]} The normalized list of search terms.
 */
const getNormalizedSearchTerms = (input = &#039;&#039;) =&gt; {
  return extractWords(normalizeString(input));
};
const removeMatchingTerms = (unmatchedTerms, unprocessedTerms) =&gt; {
  return unmatchedTerms.filter(term =&gt; !getNormalizedSearchTerms(unprocessedTerms).some(unprocessedTerm =&gt; unprocessedTerm.includes(term)));
};
const searchBlockItems = (items, categories, collections, searchInput) =&gt; {
  const normalizedSearchTerms = getNormalizedSearchTerms(searchInput);
  if (normalizedSearchTerms.length === 0) {
    return items;
  }
  const config = {
    getCategory: item =&gt; categories.find(({
      slug
    }) =&gt; slug === item.category)?.title,
    getCollection: item =&gt; collections[item.name.split(&#039;/&#039;)[0]]?.title
  };
  return searchItems(items, searchInput, config);
};

/**
 * Filters an item list given a search term.
 *
 * @param {Array}  items       Item list
 * @param {string} searchInput Search input.
 * @param {Object} config      Search Config.
 *
 * @return {Array} Filtered item list.
 */
const searchItems = (items = [], searchInput = &#039;&#039;, config = {}) =&gt; {
  const normalizedSearchTerms = getNormalizedSearchTerms(searchInput);
  if (normalizedSearchTerms.length === 0) {
    return items;
  }
  const rankedItems = items.map(item =&gt; {
    return [item, getItemSearchRank(item, searchInput, config)];
  }).filter(([, rank]) =&gt; rank &gt; 0);
  rankedItems.sort(([, rank1], [, rank2]) =&gt; rank2 - rank1);
  return rankedItems.map(([item]) =&gt; item);
};

/**
 * Get the search rank for a given item and a specific search term.
 * The better the match, the higher the rank.
 * If the rank equals 0, it should be excluded from the results.
 *
 * @param {Object} item       Item to filter.
 * @param {string} searchTerm Search term.
 * @param {Object} config     Search Config.
 *
 * @return {number} Search Rank.
 */
function getItemSearchRank(item, searchTerm, config = {}) {
  const {
    getName = defaultGetName,
    getTitle = defaultGetTitle,
    getDescription = defaultGetDescription,
    getKeywords = defaultGetKeywords,
    getCategory = defaultGetCategory,
    getCollection = defaultGetCollection
  } = config;
  const name = getName(item);
  const title = getTitle(item);
  const description = getDescription(item);
  const keywords = getKeywords(item);
  const category = getCategory(item);
  const collection = getCollection(item);
  const normalizedSearchInput = normalizeString(searchTerm);
  const normalizedTitle = normalizeString(title);
  let rank = 0;

  // Prefers exact matches
  // Then prefers if the beginning of the title matches the search term
  // name, keywords, categories, collection, variations match come later.
  if (normalizedSearchInput === normalizedTitle) {
    rank += 30;
  } else if (normalizedTitle.startsWith(normalizedSearchInput)) {
    rank += 20;
  } else {
    const terms = [name, title, description, ...keywords, category, collection].join(&#039; &#039;);
    const normalizedSearchTerms = extractWords(normalizedSearchInput);
    const unmatchedTerms = removeMatchingTerms(normalizedSearchTerms, terms);
    if (unmatchedTerms.length === 0) {
      rank += 10;
    }
  }

  // Give a better rank to &quot;core&quot; namespaced items.
  if (rank !== 0 &amp;&amp; name.startsWith(&#039;core/&#039;)) {
    const isCoreBlockVariation = name !== item.id;
    // Give a bit better rank to &quot;core&quot; blocks over &quot;core&quot; block variations.
    rank += isCoreBlockVariation ? 1 : 2;
  }
  return rank;
}

;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/hooks/use-patterns-paging.js
/**
 * WordPress dependencies
 */



const PAGE_SIZE = 20;

/**
 * Supplies values needed to page the patterns list client side.
 *
 * @param {Array}  currentCategoryPatterns An array of the current patterns to display.
 * @param {string} currentCategory         The currently selected category.
 * @param {Object} scrollContainerRef      Ref of container to to find scroll container for when moving between pages.
 * @param {string} currentFilter           The currently search filter.
 *
 * @return {Object} Returns the relevant paging values. (totalItems, categoryPatternsList, numPages, changePage, currentPage)
 */
function usePatternsPaging(currentCategoryPatterns, currentCategory, scrollContainerRef, currentFilter = &#039;&#039;) {
  const [currentPage, setCurrentPage] = (0,external_wp_element_namespaceObject.useState)(1);
  const previousCategory = (0,external_wp_compose_namespaceObject.usePrevious)(currentCategory);
  const previousFilter = (0,external_wp_compose_namespaceObject.usePrevious)(currentFilter);
  if ((previousCategory !== currentCategory || previousFilter !== currentFilter) &amp;&amp; currentPage !== 1) {
    setCurrentPage(1);
  }
  const totalItems = currentCategoryPatterns.length;
  const pageIndex = currentPage - 1;
  const categoryPatterns = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; {
    return currentCategoryPatterns.slice(pageIndex * PAGE_SIZE, pageIndex * PAGE_SIZE + PAGE_SIZE);
  }, [pageIndex, currentCategoryPatterns]);
  const numPages = Math.ceil(currentCategoryPatterns.length / PAGE_SIZE);
  const changePage = page =&gt; {
    const scrollContainer = (0,external_wp_dom_namespaceObject.getScrollContainer)(scrollContainerRef?.current);
    scrollContainer?.scrollTo(0, 0);
    setCurrentPage(page);
  };
  (0,external_wp_element_namespaceObject.useEffect)(function scrollToTopOnCategoryChange() {
    const scrollContainer = (0,external_wp_dom_namespaceObject.getScrollContainer)(scrollContainerRef?.current);
    scrollContainer?.scrollTo(0, 0);
  }, [currentCategory, scrollContainerRef]);
  return {
    totalItems,
    categoryPatterns,
    numPages,
    changePage,
    currentPage
  };
}

;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/block-patterns-explorer/pattern-list.js
/**
 * WordPress dependencies
 */






/**
 * Internal dependencies
 */









function PatternsListHeader({
  filterValue,
  filteredBlockPatternsLength
}) {
  if (!filterValue) {
    return null;
  }
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalHeading, {
    level: 2,
    lineHeight: &quot;48px&quot;,
    className: &quot;block-editor-block-patterns-explorer__search-results-count&quot;,
    children: (0,external_wp_i18n_namespaceObject.sprintf)(/* translators: %d: number of patterns. */
    (0,external_wp_i18n_namespaceObject._n)(&#039;%d pattern found&#039;, &#039;%d patterns found&#039;, filteredBlockPatternsLength), filteredBlockPatternsLength)
  });
}
function PatternList({
  searchValue,
  selectedCategory,
  patternCategories,
  rootClientId,
  onModalClose
}) {
  const container = (0,external_wp_element_namespaceObject.useRef)();
  const debouncedSpeak = (0,external_wp_compose_namespaceObject.useDebounce)(external_wp_a11y_namespaceObject.speak, 500);
  const [destinationRootClientId, onInsertBlocks] = use_insertion_point({
    rootClientId,
    shouldFocusBlock: true
  });
  const [patterns,, onClickPattern] = use_patterns_state(onInsertBlocks, destinationRootClientId, selectedCategory);
  const registeredPatternCategories = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; patternCategories.map(patternCategory =&gt; patternCategory.name), [patternCategories]);
  const filteredBlockPatterns = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; {
    const filteredPatterns = patterns.filter(pattern =&gt; {
      if (selectedCategory === allPatternsCategory.name) {
        return true;
      }
      if (selectedCategory === myPatternsCategory.name &amp;&amp; pattern.type === INSERTER_PATTERN_TYPES.user) {
        return true;
      }
      if (selectedCategory === starterPatternsCategory.name &amp;&amp; pattern.blockTypes?.includes(&#039;core/post-content&#039;)) {
        return true;
      }
      if (selectedCategory === &#039;uncategorized&#039;) {
        var _pattern$categories$s;
        const hasKnownCategory = (_pattern$categories$s = pattern.categories?.some(category =&gt; registeredPatternCategories.includes(category))) !== null &amp;&amp; _pattern$categories$s !== void 0 ? _pattern$categories$s : false;
        return !pattern.categories?.length || !hasKnownCategory;
      }
      return pattern.categories?.includes(selectedCategory);
    });
    if (!searchValue) {
      return filteredPatterns;
    }
    return searchItems(filteredPatterns, searchValue);
  }, [searchValue, patterns, selectedCategory, registeredPatternCategories]);

  // Announce search results on change.
  (0,external_wp_element_namespaceObject.useEffect)(() =&gt; {
    if (!searchValue) {
      return;
    }
    const count = filteredBlockPatterns.length;
    const resultsFoundMessage = (0,external_wp_i18n_namespaceObject.sprintf)(/* translators: %d: number of results. */
    (0,external_wp_i18n_namespaceObject._n)(&#039;%d result found.&#039;, &#039;%d results found.&#039;, count), count);
    debouncedSpeak(resultsFoundMessage);
  }, [searchValue, debouncedSpeak, filteredBlockPatterns.length]);
  const pagingProps = usePatternsPaging(filteredBlockPatterns, selectedCategory, container);

  // Reset page when search value changes.
  const [previousSearchValue, setPreviousSearchValue] = (0,external_wp_element_namespaceObject.useState)(searchValue);
  if (searchValue !== previousSearchValue) {
    setPreviousSearchValue(searchValue);
    pagingProps.changePage(1);
  }
  const hasItems = !!filteredBlockPatterns?.length;
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;div&quot;, {
    className: &quot;block-editor-block-patterns-explorer__list&quot;,
    ref: container,
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PatternsListHeader, {
      filterValue: searchValue,
      filteredBlockPatternsLength: filteredBlockPatterns.length
    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inserter_listbox, {
      children: hasItems &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_patterns_list, {
          blockPatterns: pagingProps.categoryPatterns,
          onClickPattern: (pattern, blocks) =&gt; {
            onClickPattern(pattern, blocks);
            onModalClose();
          },
          isDraggable: false
        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Pagination, {
          ...pagingProps
        })]
      })
    })]
  });
}
/* harmony default export */ const pattern_list = (PatternList);

;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/block-patterns-tab/use-pattern-categories.js
/**
 * WordPress dependencies
 */




/**
 * Internal dependencies
 */


function hasRegisteredCategory(pattern, allCategories) {
  if (!pattern.categories || !pattern.categories.length) {
    return false;
  }
  return pattern.categories.some(cat =&gt; allCategories.some(category =&gt; category.name === cat));
}
function usePatternCategories(rootClientId, sourceFilter = &#039;all&#039;) {
  const [patterns, allCategories] = use_patterns_state(undefined, rootClientId);
  const filteredPatterns = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; sourceFilter === &#039;all&#039; ? patterns : patterns.filter(pattern =&gt; !isPatternFiltered(pattern, sourceFilter)), [sourceFilter, patterns]);

  // Remove any empty categories.
  const populatedCategories = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; {
    const categories = allCategories.filter(category =&gt; filteredPatterns.some(pattern =&gt; pattern.categories?.includes(category.name))).sort((a, b) =&gt; a.label.localeCompare(b.label));
    if (filteredPatterns.some(pattern =&gt; !hasRegisteredCategory(pattern, allCategories)) &amp;&amp; !categories.find(category =&gt; category.name === &#039;uncategorized&#039;)) {
      categories.push({
        name: &#039;uncategorized&#039;,
        label: (0,external_wp_i18n_namespaceObject._x)(&#039;Uncategorized&#039;)
      });
    }
    if (filteredPatterns.some(pattern =&gt; pattern.blockTypes?.includes(&#039;core/post-content&#039;))) {
      categories.unshift(starterPatternsCategory);
    }
    if (filteredPatterns.some(pattern =&gt; pattern.type === INSERTER_PATTERN_TYPES.user)) {
      categories.unshift(myPatternsCategory);
    }
    if (filteredPatterns.length &gt; 0) {
      categories.unshift({
        name: allPatternsCategory.name,
        label: allPatternsCategory.label
      });
    }
    (0,external_wp_a11y_namespaceObject.speak)((0,external_wp_i18n_namespaceObject.sprintf)(/* translators: %d: number of categories . */
    (0,external_wp_i18n_namespaceObject._n)(&#039;%d category button displayed.&#039;, &#039;%d category buttons displayed.&#039;, categories.length), categories.length));
    return categories;
  }, [allCategories, filteredPatterns]);
  return populatedCategories;
}

;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/block-patterns-explorer/index.js
/**
 * WordPress dependencies
 */




/**
 * Internal dependencies
 */




function PatternsExplorer({
  initialCategory,
  rootClientId,
  onModalClose
}) {
  const [searchValue, setSearchValue] = (0,external_wp_element_namespaceObject.useState)(&#039;&#039;);
  const [selectedCategory, setSelectedCategory] = (0,external_wp_element_namespaceObject.useState)(initialCategory?.name);
  const patternCategories = usePatternCategories(rootClientId);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;div&quot;, {
    className: &quot;block-editor-block-patterns-explorer&quot;,
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(pattern_explorer_sidebar, {
      selectedCategory: selectedCategory,
      patternCategories: patternCategories,
      onClickCategory: setSelectedCategory,
      searchValue: searchValue,
      setSearchValue: setSearchValue
    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(pattern_list, {
      searchValue: searchValue,
      selectedCategory: selectedCategory,
      patternCategories: patternCategories,
      rootClientId: rootClientId,
      onModalClose: onModalClose
    })]
  });
}
function PatternsExplorerModal({
  onModalClose,
  ...restProps
}) {
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Modal, {
    title: (0,external_wp_i18n_namespaceObject.__)(&#039;Patterns&#039;),
    onRequestClose: onModalClose,
    isFullScreen: true,
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PatternsExplorer, {
      onModalClose: onModalClose,
      ...restProps
    })
  });
}
/* harmony default export */ const block_patterns_explorer = (PatternsExplorerModal);

;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/mobile-tab-navigation.js
/**
 * WordPress dependencies
 */




function ScreenHeader({
  title
}) {
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalVStack, {
    spacing: 0,
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalView, {
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalSpacer, {
        marginBottom: 0,
        paddingX: 4,
        paddingY: 3,
        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalHStack, {
          spacing: 2,
          children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Navigator.BackButton, {
            style:
            // TODO: This style override is also used in ToolsPanelHeader.
            // It should be supported out-of-the-box by Button.
            {
              minWidth: 24,
              padding: 0
            },
            icon: (0,external_wp_i18n_namespaceObject.isRTL)() ? chevron_right : chevron_left,
            size: &quot;small&quot;,
            label: (0,external_wp_i18n_namespaceObject.__)(&#039;Back&#039;)
          }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalSpacer, {
            children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalHeading, {
              level: 5,
              children: title
            })
          })]
        })
      })
    })
  });
}
function MobileTabNavigation({
  categories,
  children
}) {
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.Navigator, {
    initialPath: &quot;/&quot;,
    className: &quot;block-editor-inserter__mobile-tab-navigation&quot;,
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Navigator.Screen, {
      path: &quot;/&quot;,
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalItemGroup, {
        children: categories.map(category =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Navigator.Button, {
          path: `/category/${category.name}`,
          as: external_wp_components_namespaceObject.__experimentalItem,
          isAction: true,
          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalHStack, {
            children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FlexBlock, {
              children: category.label
            }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(build_module_icon, {
              icon: (0,external_wp_i18n_namespaceObject.isRTL)() ? chevron_left : chevron_right
            })]
          })
        }, category.name))
      })
    }), categories.map(category =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.Navigator.Screen, {
      path: `/category/${category.name}`,
      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ScreenHeader, {
        title: (0,external_wp_i18n_namespaceObject.__)(&#039;Back&#039;)
      }), children(category)]
    }, category.name))]
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/block-patterns-tab/patterns-filter.js
/**
 * WordPress dependencies
 */





/**
 * Internal dependencies
 */


const getShouldDisableSyncFilter = sourceFilter =&gt; sourceFilter !== &#039;all&#039; &amp;&amp; sourceFilter !== &#039;user&#039;;
const getShouldHideSourcesFilter = category =&gt; {
  return category.name === myPatternsCategory.name;
};
const PATTERN_SOURCE_MENU_OPTIONS = [{
  value: &#039;all&#039;,
  label: (0,external_wp_i18n_namespaceObject._x)(&#039;All&#039;, &#039;patterns&#039;)
}, {
  value: INSERTER_PATTERN_TYPES.directory,
  label: (0,external_wp_i18n_namespaceObject.__)(&#039;Pattern Directory&#039;)
}, {
  value: INSERTER_PATTERN_TYPES.theme,
  label: (0,external_wp_i18n_namespaceObject.__)(&#039;Theme &amp; Plugins&#039;)
}, {
  value: INSERTER_PATTERN_TYPES.user,
  label: (0,external_wp_i18n_namespaceObject.__)(&#039;User&#039;)
}];
function PatternsFilter({
  setPatternSyncFilter,
  setPatternSourceFilter,
  patternSyncFilter,
  patternSourceFilter,
  scrollContainerRef,
  category
}) {
  // If the category is `myPatterns` then we need to set the source filter to `user`, but
  // we do this by deriving from props rather than calling setPatternSourceFilter otherwise
  // the user may be confused when switching to another category if the haven&#039;t explicitly set
  // this filter themselves.
  const currentPatternSourceFilter = category.name === myPatternsCategory.name ? INSERTER_PATTERN_TYPES.user : patternSourceFilter;

  // We need to disable the sync filter option if the source filter is not &#039;all&#039; or &#039;user&#039;
  // otherwise applying them will just result in no patterns being shown.
  const shouldDisableSyncFilter = getShouldDisableSyncFilter(currentPatternSourceFilter);

  // We also hide the directory and theme source filter if the category is `myPatterns`
  // otherwise there will only be one option available.
  const shouldHideSourcesFilter = getShouldHideSourcesFilter(category);
  const patternSyncMenuOptions = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; [{
    value: &#039;all&#039;,
    label: (0,external_wp_i18n_namespaceObject._x)(&#039;All&#039;, &#039;patterns&#039;)
  }, {
    value: INSERTER_SYNC_TYPES.full,
    label: (0,external_wp_i18n_namespaceObject._x)(&#039;Synced&#039;, &#039;patterns&#039;),
    disabled: shouldDisableSyncFilter
  }, {
    value: INSERTER_SYNC_TYPES.unsynced,
    label: (0,external_wp_i18n_namespaceObject._x)(&#039;Not synced&#039;, &#039;patterns&#039;),
    disabled: shouldDisableSyncFilter
  }], [shouldDisableSyncFilter]);
  function handleSetSourceFilterChange(newSourceFilter) {
    setPatternSourceFilter(newSourceFilter);
    if (getShouldDisableSyncFilter(newSourceFilter)) {
      setPatternSyncFilter(&#039;all&#039;);
    }
  }
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_ReactJSXRuntime_namespaceObject.Fragment, {
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.DropdownMenu, {
      popoverProps: {
        placement: &#039;right-end&#039;
      },
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Filter patterns&#039;),
      toggleProps: {
        size: &#039;compact&#039;
      },
      icon: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(build_module_icon, {
        icon: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.SVG, {
          width: &quot;24&quot;,
          height: &quot;24&quot;,
          viewBox: &quot;0 0 24 24&quot;,
          fill: &quot;none&quot;,
          xmlns: &quot;http://www.w3.org/2000/svg&quot;,
          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Path, {
            d: &quot;M10 17.5H14V16H10V17.5ZM6 6V7.5H18V6H6ZM8 12.5H16V11H8V12.5Z&quot;,
            fill: &quot;currentColor&quot;
          })
        })
      }),
      children: () =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
        children: [!shouldHideSourcesFilter &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuGroup, {
          label: (0,external_wp_i18n_namespaceObject.__)(&#039;Source&#039;),
          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItemsChoice, {
            choices: PATTERN_SOURCE_MENU_OPTIONS,
            onSelect: value =&gt; {
              handleSetSourceFilterChange(value);
              scrollContainerRef.current?.scrollTo(0, 0);
            },
            value: currentPatternSourceFilter
          })
        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuGroup, {
          label: (0,external_wp_i18n_namespaceObject.__)(&#039;Type&#039;),
          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItemsChoice, {
            choices: patternSyncMenuOptions,
            onSelect: value =&gt; {
              setPatternSyncFilter(value);
              scrollContainerRef.current?.scrollTo(0, 0);
            },
            value: patternSyncFilter
          })
        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
          className: &quot;block-editor-inserter__patterns-filter-help&quot;,
          children: (0,external_wp_element_namespaceObject.createInterpolateElement)((0,external_wp_i18n_namespaceObject.__)(&#039;Patterns are available from the &lt;Link&gt;WordPress.org Pattern Directory&lt;/Link&gt;, bundled in the active theme, or created by users on this site. Only patterns created on this site can be synced.&#039;), {
            Link: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ExternalLink, {
              href: (0,external_wp_i18n_namespaceObject.__)(&#039;https://wordpress.org/patterns/&#039;)
            })
          })
        })]
      })
    })
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/block-patterns-tab/pattern-category-previews.js
/**
 * WordPress dependencies
 */




/**
 * Internal dependencies
 */







const pattern_category_previews_noop = () =&gt; {};
function PatternCategoryPreviews({
  rootClientId,
  onInsert,
  onHover = pattern_category_previews_noop,
  category,
  showTitlesAsTooltip
}) {
  const [allPatterns,, onClickPattern] = use_patterns_state(onInsert, rootClientId, category?.name);
  const [patternSyncFilter, setPatternSyncFilter] = (0,external_wp_element_namespaceObject.useState)(&#039;all&#039;);
  const [patternSourceFilter, setPatternSourceFilter] = (0,external_wp_element_namespaceObject.useState)(&#039;all&#039;);
  const availableCategories = usePatternCategories(rootClientId, patternSourceFilter);
  const scrollContainerRef = (0,external_wp_element_namespaceObject.useRef)();
  const currentCategoryPatterns = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; allPatterns.filter(pattern =&gt; {
    if (isPatternFiltered(pattern, patternSourceFilter, patternSyncFilter)) {
      return false;
    }
    if (category.name === allPatternsCategory.name) {
      return true;
    }
    if (category.name === myPatternsCategory.name &amp;&amp; pattern.type === INSERTER_PATTERN_TYPES.user) {
      return true;
    }
    if (category.name === starterPatternsCategory.name &amp;&amp; pattern.blockTypes?.includes(&#039;core/post-content&#039;)) {
      return true;
    }
    if (category.name === &#039;uncategorized&#039;) {
      // The uncategorized category should show all the patterns without any category...
      if (!pattern.categories) {
        return true;
      }

      // ...or with no available category.
      return !pattern.categories.some(catName =&gt; availableCategories.some(c =&gt; c.name === catName));
    }
    return pattern.categories?.includes(category.name);
  }), [allPatterns, availableCategories, category.name, patternSourceFilter, patternSyncFilter]);
  const pagingProps = usePatternsPaging(currentCategoryPatterns, category, scrollContainerRef);
  const {
    changePage
  } = pagingProps;

  // Hide block pattern preview on unmount.
  (0,external_wp_element_namespaceObject.useEffect)(() =&gt; () =&gt; onHover(null), []);
  const onSetPatternSyncFilter = (0,external_wp_element_namespaceObject.useCallback)(value =&gt; {
    setPatternSyncFilter(value);
    changePage(1);
  }, [setPatternSyncFilter, changePage]);
  const onSetPatternSourceFilter = (0,external_wp_element_namespaceObject.useCallback)(value =&gt; {
    setPatternSourceFilter(value);
    changePage(1);
  }, [setPatternSourceFilter, changePage]);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalVStack, {
      spacing: 2,
      className: &quot;block-editor-inserter__patterns-category-panel-header&quot;,
      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalHStack, {
        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FlexBlock, {
          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalHeading, {
            className: &quot;block-editor-inserter__patterns-category-panel-title&quot;,
            size: 13,
            level: 4,
            as: &quot;div&quot;,
            children: category.label
          })
        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PatternsFilter, {
          patternSyncFilter: patternSyncFilter,
          patternSourceFilter: patternSourceFilter,
          setPatternSyncFilter: onSetPatternSyncFilter,
          setPatternSourceFilter: onSetPatternSourceFilter,
          scrollContainerRef: scrollContainerRef,
          category: category
        })]
      }), !currentCategoryPatterns.length &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalText, {
        variant: &quot;muted&quot;,
        className: &quot;block-editor-inserter__patterns-category-no-results&quot;,
        children: (0,external_wp_i18n_namespaceObject.__)(&#039;No results found&#039;)
      })]
    }), currentCategoryPatterns.length &gt; 0 &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalText, {
        size: &quot;12&quot;,
        as: &quot;p&quot;,
        className: &quot;block-editor-inserter__help-text&quot;,
        children: (0,external_wp_i18n_namespaceObject.__)(&#039;Drag and drop patterns into the canvas.&#039;)
      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_patterns_list, {
        ref: scrollContainerRef,
        blockPatterns: pagingProps.categoryPatterns,
        onClickPattern: onClickPattern,
        onHover: onHover,
        label: category.label,
        orientation: &quot;vertical&quot;,
        category: category.name,
        isDraggable: true,
        showTitlesAsTooltip: showTitlesAsTooltip,
        patternFilter: patternSourceFilter,
        pagingProps: pagingProps
      })]
    })]
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/category-tabs/index.js
/**
 * WordPress dependencies
 */




/**
 * Internal dependencies
 */


const {
  Tabs: category_tabs_Tabs
} = unlock(external_wp_components_namespaceObject.privateApis);
function CategoryTabs({
  categories,
  selectedCategory,
  onSelectCategory,
  children
}) {
  // Copied from InterfaceSkeleton.
  const ANIMATION_DURATION = 0.25;
  const disableMotion = (0,external_wp_compose_namespaceObject.useReducedMotion)();
  const defaultTransition = {
    type: &#039;tween&#039;,
    duration: disableMotion ? 0 : ANIMATION_DURATION,
    ease: [0.6, 0, 0.4, 1]
  };
  const previousSelectedCategory = (0,external_wp_compose_namespaceObject.usePrevious)(selectedCategory);
  const selectedTabId = selectedCategory ? selectedCategory.name : null;
  const [activeTabId, setActiveId] = (0,external_wp_element_namespaceObject.useState)();
  const firstTabId = categories?.[0]?.name;

  // If there is no active tab, make the first tab the active tab, so that
  // when focus is moved to the tablist, the first tab will be focused
  // despite not being selected
  if (selectedTabId === null &amp;&amp; !activeTabId &amp;&amp; firstTabId) {
    setActiveId(firstTabId);
  }
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(category_tabs_Tabs, {
    selectOnMove: false,
    selectedTabId: selectedTabId,
    orientation: &quot;vertical&quot;,
    onSelect: categoryId =&gt; {
      // Pass the full category object
      onSelectCategory(categories.find(category =&gt; category.name === categoryId));
    },
    activeTabId: activeTabId,
    onActiveTabIdChange: setActiveId,
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(category_tabs_Tabs.TabList, {
      className: &quot;block-editor-inserter__category-tablist&quot;,
      children: categories.map(category =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(category_tabs_Tabs.Tab, {
        tabId: category.name,
        &quot;aria-current&quot;: category === selectedCategory ? &#039;true&#039; : undefined,
        children: category.label
      }, category.name))
    }), categories.map(category =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(category_tabs_Tabs.TabPanel, {
      tabId: category.name,
      focusable: false,
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__unstableMotion.div, {
        className: &quot;block-editor-inserter__category-panel&quot;,
        initial: !previousSelectedCategory ? &#039;closed&#039; : &#039;open&#039;,
        animate: &quot;open&quot;,
        variants: {
          open: {
            transform: &#039;translateX( 0 )&#039;,
            transitionEnd: {
              zIndex: &#039;1&#039;
            }
          },
          closed: {
            transform: &#039;translateX( -100% )&#039;,
            zIndex: &#039;-1&#039;
          }
        },
        transition: defaultTransition,
        children: children
      })
    }, category.name))]
  });
}
/* harmony default export */ const category_tabs = (CategoryTabs);

;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/block-patterns-tab/index.js
/**
 * WordPress dependencies
 */





/**
 * Internal dependencies
 */







function BlockPatternsTab({
  onSelectCategory,
  selectedCategory,
  onInsert,
  rootClientId,
  children
}) {
  const [showPatternsExplorer, setShowPatternsExplorer] = (0,external_wp_element_namespaceObject.useState)(false);
  const categories = usePatternCategories(rootClientId);
  const isMobile = (0,external_wp_compose_namespaceObject.useViewportMatch)(&#039;medium&#039;, &#039;&lt;&#039;);
  if (!categories.length) {
    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(no_results, {});
  }
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
    children: [!isMobile &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;div&quot;, {
      className: &quot;block-editor-inserter__block-patterns-tabs-container&quot;,
      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(category_tabs, {
        categories: categories,
        selectedCategory: selectedCategory,
        onSelectCategory: onSelectCategory,
        children: children
      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
        __next40pxDefaultSize: true,
        className: &quot;block-editor-inserter__patterns-explore-button&quot;,
        onClick: () =&gt; setShowPatternsExplorer(true),
        variant: &quot;secondary&quot;,
        children: (0,external_wp_i18n_namespaceObject.__)(&#039;Explore all patterns&#039;)
      })]
    }), isMobile &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(MobileTabNavigation, {
      categories: categories,
      children: category =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
        className: &quot;block-editor-inserter__category-panel&quot;,
        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PatternCategoryPreviews, {
          onInsert: onInsert,
          rootClientId: rootClientId,
          category: category
        }, category.name)
      })
    }), showPatternsExplorer &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_patterns_explorer, {
      initialCategory: selectedCategory || categories[0],
      patternCategories: categories,
      onModalClose: () =&gt; setShowPatternsExplorer(false),
      rootClientId: rootClientId
    })]
  });
}
/* harmony default export */ const block_patterns_tab = (BlockPatternsTab);

;// ./node_modules/@wordpress/icons/build-module/library/external.js
/**
 * WordPress dependencies
 */


const external = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;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&quot;
  })
});
/* harmony default export */ const library_external = (external);

;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/media-tab/utils.js
/**
 * WordPress dependencies
 */


const mediaTypeTag = {
  image: &#039;img&#039;,
  video: &#039;video&#039;,
  audio: &#039;audio&#039;
};

/** @typedef {import(&#039;./hooks&#039;).InserterMediaItem} InserterMediaItem */

/**
 * Creates a block and a preview element from a media object.
 *
 * @param {InserterMediaItem}         media     The media object to create the block from.
 * @param {(&#039;image&#039;|&#039;audio&#039;|&#039;video&#039;)} mediaType The media type to create the block for.
 * @return {[WPBlock, JSX.Element]} An array containing the block and the preview element.
 */
function getBlockAndPreviewFromMedia(media, mediaType) {
  // Add the common attributes between the different media types.
  const attributes = {
    id: media.id || undefined,
    caption: media.caption || undefined
  };
  const mediaSrc = media.url;
  const alt = media.alt || undefined;
  if (mediaType === &#039;image&#039;) {
    attributes.url = mediaSrc;
    attributes.alt = alt;
  } else if ([&#039;video&#039;, &#039;audio&#039;].includes(mediaType)) {
    attributes.src = mediaSrc;
  }
  const PreviewTag = mediaTypeTag[mediaType];
  const preview = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PreviewTag, {
    src: media.previewUrl || mediaSrc,
    alt: alt,
    controls: mediaType === &#039;audio&#039; ? true : undefined,
    inert: &quot;true&quot;,
    onError: ({
      currentTarget
    }) =&gt; {
      // Fall back to the media source if the preview cannot be loaded.
      if (currentTarget.src === media.previewUrl) {
        currentTarget.src = mediaSrc;
      }
    }
  });
  return [(0,external_wp_blocks_namespaceObject.createBlock)(`core/${mediaType}`, attributes), preview];
}

;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/media-tab/media-preview.js
/**
 * External dependencies
 */


/**
 * WordPress dependencies
 */










/**
 * Internal dependencies
 */




const ALLOWED_MEDIA_TYPES = [&#039;image&#039;];
const MAXIMUM_TITLE_LENGTH = 25;
const MEDIA_OPTIONS_POPOVER_PROPS = {
  position: &#039;bottom left&#039;,
  className: &#039;block-editor-inserter__media-list__item-preview-options__popover&#039;
};
function MediaPreviewOptions({
  category,
  media
}) {
  if (!category.getReportUrl) {
    return null;
  }
  const reportUrl = category.getReportUrl(media);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.DropdownMenu, {
    className: &quot;block-editor-inserter__media-list__item-preview-options&quot;,
    label: (0,external_wp_i18n_namespaceObject.__)(&#039;Options&#039;),
    popoverProps: MEDIA_OPTIONS_POPOVER_PROPS,
    icon: more_vertical,
    children: () =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuGroup, {
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, {
        onClick: () =&gt; window.open(reportUrl, &#039;_blank&#039;).focus(),
        icon: library_external,
        children: (0,external_wp_i18n_namespaceObject.sprintf)(/* translators: %s: The media type to report e.g: &quot;image&quot;, &quot;video&quot;, &quot;audio&quot; */
        (0,external_wp_i18n_namespaceObject.__)(&#039;Report %s&#039;), category.mediaType)
      })
    })
  });
}
function InsertExternalImageModal({
  onClose,
  onSubmit
}) {
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.Modal, {
    title: (0,external_wp_i18n_namespaceObject.__)(&#039;Insert external image&#039;),
    onRequestClose: onClose,
    className: &quot;block-editor-inserter-media-tab-media-preview-inserter-external-image-modal&quot;,
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalVStack, {
      spacing: 3,
      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;p&quot;, {
        children: (0,external_wp_i18n_namespaceObject.__)(&#039;This image cannot be uploaded to your Media Library, but it can still be inserted as an external image.&#039;)
      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;p&quot;, {
        children: (0,external_wp_i18n_namespaceObject.__)(&#039;External images can be removed by the external provider without warning and could even have legal compliance issues related to privacy legislation.&#039;)
      })]
    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.Flex, {
      className: &quot;block-editor-block-lock-modal__actions&quot;,
      justify: &quot;flex-end&quot;,
      expanded: false,
      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FlexItem, {
        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
          __next40pxDefaultSize: true,
          variant: &quot;tertiary&quot;,
          onClick: onClose,
          children: (0,external_wp_i18n_namespaceObject.__)(&#039;Cancel&#039;)
        })
      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FlexItem, {
        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
          __next40pxDefaultSize: true,
          variant: &quot;primary&quot;,
          onClick: onSubmit,
          children: (0,external_wp_i18n_namespaceObject.__)(&#039;Insert&#039;)
        })
      })]
    })]
  });
}
function MediaPreview({
  media,
  onClick,
  category
}) {
  const [showExternalUploadModal, setShowExternalUploadModal] = (0,external_wp_element_namespaceObject.useState)(false);
  const [isHovered, setIsHovered] = (0,external_wp_element_namespaceObject.useState)(false);
  const [isInserting, setIsInserting] = (0,external_wp_element_namespaceObject.useState)(false);
  const [block, preview] = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; getBlockAndPreviewFromMedia(media, category.mediaType), [media, category.mediaType]);
  const {
    createErrorNotice,
    createSuccessNotice
  } = (0,external_wp_data_namespaceObject.useDispatch)(external_wp_notices_namespaceObject.store);
  const {
    getSettings,
    getBlock
  } = (0,external_wp_data_namespaceObject.useSelect)(store);
  const {
    updateBlockAttributes
  } = (0,external_wp_data_namespaceObject.useDispatch)(store);
  const onMediaInsert = (0,external_wp_element_namespaceObject.useCallback)(previewBlock =&gt; {
    // Prevent multiple uploads when we&#039;re in the process of inserting.
    if (isInserting) {
      return;
    }
    const settings = getSettings();
    const clonedBlock = (0,external_wp_blocks_namespaceObject.cloneBlock)(previewBlock);
    const {
      id,
      url,
      caption
    } = clonedBlock.attributes;

    // User has no permission to upload media.
    if (!id &amp;&amp; !settings.mediaUpload) {
      setShowExternalUploadModal(true);
      return;
    }

    // Media item already exists in library, so just insert it.
    if (!!id) {
      onClick(clonedBlock);
      return;
    }
    setIsInserting(true);
    // Media item does not exist in library, so try to upload it.
    // Fist fetch the image data. This may fail if the image host
    // doesn&#039;t allow CORS with the domain.
    // If this happens, we insert the image block using the external
    // URL and let the user know about the possible implications.
    window.fetch(url).then(response =&gt; response.blob()).then(blob =&gt; {
      const fileName = (0,external_wp_url_namespaceObject.getFilename)(url) || &#039;image.jpg&#039;;
      const file = new File([blob], fileName, {
        type: blob.type
      });
      settings.mediaUpload({
        filesList: [file],
        additionalData: {
          caption
        },
        onFileChange([img]) {
          if ((0,external_wp_blob_namespaceObject.isBlobURL)(img.url)) {
            return;
          }
          if (!getBlock(clonedBlock.clientId)) {
            // Ensure the block is only inserted once.
            onClick({
              ...clonedBlock,
              attributes: {
                ...clonedBlock.attributes,
                id: img.id,
                url: img.url
              }
            });
            createSuccessNotice((0,external_wp_i18n_namespaceObject.__)(&#039;Image uploaded and inserted.&#039;), {
              type: &#039;snackbar&#039;,
              id: &#039;inserter-notice&#039;
            });
          } else {
            // For subsequent calls, update the existing block.
            updateBlockAttributes(clonedBlock.clientId, {
              ...clonedBlock.attributes,
              id: img.id,
              url: img.url
            });
          }
          setIsInserting(false);
        },
        allowedTypes: ALLOWED_MEDIA_TYPES,
        onError(message) {
          createErrorNotice(message, {
            type: &#039;snackbar&#039;,
            id: &#039;inserter-notice&#039;
          });
          setIsInserting(false);
        }
      });
    }).catch(() =&gt; {
      setShowExternalUploadModal(true);
      setIsInserting(false);
    });
  }, [isInserting, getSettings, onClick, createSuccessNotice, updateBlockAttributes, createErrorNotice, getBlock]);
  const title = typeof media.title === &#039;string&#039; ? media.title : media.title?.rendered || (0,external_wp_i18n_namespaceObject.__)(&#039;no title&#039;);
  let truncatedTitle;
  if (title.length &gt; MAXIMUM_TITLE_LENGTH) {
    const omission = &#039;...&#039;;
    truncatedTitle = title.slice(0, MAXIMUM_TITLE_LENGTH - omission.length) + omission;
  }
  const onMouseEnter = (0,external_wp_element_namespaceObject.useCallback)(() =&gt; setIsHovered(true), []);
  const onMouseLeave = (0,external_wp_element_namespaceObject.useCallback)(() =&gt; setIsHovered(false), []);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inserter_draggable_blocks, {
      isEnabled: true,
      blocks: [block],
      children: ({
        draggable,
        onDragStart,
        onDragEnd
      }) =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
        className: dist_clsx(&#039;block-editor-inserter__media-list__list-item&#039;, {
          &#039;is-hovered&#039;: isHovered
        }),
        draggable: draggable,
        onDragStart: onDragStart,
        onDragEnd: onDragEnd,
        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;div&quot;, {
          onMouseEnter: onMouseEnter,
          onMouseLeave: onMouseLeave,
          children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Tooltip, {
            text: truncatedTitle || title,
            children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Composite.Item, {
              render: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
                &quot;aria-label&quot;: title,
                role: &quot;option&quot;,
                className: &quot;block-editor-inserter__media-list__item&quot;
              }),
              onClick: () =&gt; onMediaInsert(block),
              children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;div&quot;, {
                className: &quot;block-editor-inserter__media-list__item-preview&quot;,
                children: [preview, isInserting &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
                  className: &quot;block-editor-inserter__media-list__item-preview-spinner&quot;,
                  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Spinner, {})
                })]
              })
            })
          }), !isInserting &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(MediaPreviewOptions, {
            category: category,
            media: media
          })]
        })
      })
    }), showExternalUploadModal &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(InsertExternalImageModal, {
      onClose: () =&gt; setShowExternalUploadModal(false),
      onSubmit: () =&gt; {
        onClick((0,external_wp_blocks_namespaceObject.cloneBlock)(block));
        createSuccessNotice((0,external_wp_i18n_namespaceObject.__)(&#039;Image inserted.&#039;), {
          type: &#039;snackbar&#039;,
          id: &#039;inserter-notice&#039;
        });
        setShowExternalUploadModal(false);
      }
    })]
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/media-tab/media-list.js
/**
 * WordPress dependencies
 */



/**
 * Internal dependencies
 */


function MediaList({
  mediaList,
  category,
  onClick,
  label = (0,external_wp_i18n_namespaceObject.__)(&#039;Media List&#039;)
}) {
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Composite, {
    role: &quot;listbox&quot;,
    className: &quot;block-editor-inserter__media-list&quot;,
    &quot;aria-label&quot;: label,
    children: mediaList.map((media, index) =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(MediaPreview, {
      media: media,
      category: category,
      onClick: onClick
    }, media.id || media.sourceId || index))
  });
}
/* harmony default export */ const media_list = (MediaList);

;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/media-tab/hooks.js
/**
 * WordPress dependencies
 */



/**
 * Internal dependencies
 */



/** @typedef {import(&#039;../../../store/actions&#039;).InserterMediaRequest} InserterMediaRequest */
/** @typedef {import(&#039;../../../store/actions&#039;).InserterMediaItem} InserterMediaItem */

/**
 * Fetches media items based on the provided category.
 * Each media category is responsible for providing a `fetch` function.
 *
 * @param {Object}               category The media category to fetch results for.
 * @param {InserterMediaRequest} query    The query args to use for the request.
 * @return {InserterMediaItem[]} The media results.
 */
function useMediaResults(category, query = {}) {
  const [mediaList, setMediaList] = (0,external_wp_element_namespaceObject.useState)();
  const [isLoading, setIsLoading] = (0,external_wp_element_namespaceObject.useState)(false);
  // We need to keep track of the last request made because
  // multiple request can be fired without knowing the order
  // of resolution, and we need to ensure we are showing
  // the results of the last request.
  // In the future we could use AbortController to cancel previous
  // requests, but we don&#039;t for now as it involves adding support
  // for this to `core-data` package.
  const lastRequestRef = (0,external_wp_element_namespaceObject.useRef)();
  (0,external_wp_element_namespaceObject.useEffect)(() =&gt; {
    (async () =&gt; {
      const key = JSON.stringify({
        category: category.name,
        ...query
      });
      lastRequestRef.current = key;
      setIsLoading(true);
      setMediaList([]); // Empty the previous results.
      const _media = await category.fetch?.(query);
      if (key === lastRequestRef.current) {
        setMediaList(_media);
        setIsLoading(false);
      }
    })();
  }, [category.name, ...Object.values(query)]);
  return {
    mediaList,
    isLoading
  };
}
function useMediaCategories(rootClientId) {
  const [categories, setCategories] = (0,external_wp_element_namespaceObject.useState)([]);
  const inserterMediaCategories = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; unlock(select(store)).getInserterMediaCategories(), []);
  const {
    canInsertImage,
    canInsertVideo,
    canInsertAudio
  } = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      canInsertBlockType
    } = select(store);
    return {
      canInsertImage: canInsertBlockType(&#039;core/image&#039;, rootClientId),
      canInsertVideo: canInsertBlockType(&#039;core/video&#039;, rootClientId),
      canInsertAudio: canInsertBlockType(&#039;core/audio&#039;, rootClientId)
    };
  }, [rootClientId]);
  (0,external_wp_element_namespaceObject.useEffect)(() =&gt; {
    (async () =&gt; {
      const _categories = [];
      // If `inserterMediaCategories` is not defined in
      // block editor settings, do not show any media categories.
      if (!inserterMediaCategories) {
        return;
      }
      // Loop through categories to check if they have at least one media item.
      const categoriesHaveMedia = new Map(await Promise.all(inserterMediaCategories.map(async category =&gt; {
        // Some sources are external and we don&#039;t need to make a request.
        if (category.isExternalResource) {
          return [category.name, true];
        }
        let results = [];
        try {
          results = await category.fetch({
            per_page: 1
          });
        } catch (e) {
          // If the request fails, we shallow the error and just don&#039;t show
          // the category, in order to not break the media tab.
        }
        return [category.name, !!results.length];
      })));
      // We need to filter out categories that don&#039;t have any media items or
      // whose corresponding block type is not allowed to be inserted, based
      // on the category&#039;s `mediaType`.
      const canInsertMediaType = {
        image: canInsertImage,
        video: canInsertVideo,
        audio: canInsertAudio
      };
      inserterMediaCategories.forEach(category =&gt; {
        if (canInsertMediaType[category.mediaType] &amp;&amp; categoriesHaveMedia.get(category.name)) {
          _categories.push(category);
        }
      });
      if (!!_categories.length) {
        setCategories(_categories);
      }
    })();
  }, [canInsertImage, canInsertVideo, canInsertAudio, inserterMediaCategories]);
  return categories;
}

;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/media-tab/media-panel.js
/**
 * WordPress dependencies
 */




/**
 * Internal dependencies
 */




const INITIAL_MEDIA_ITEMS_PER_PAGE = 10;
function MediaCategoryPanel({
  rootClientId,
  onInsert,
  category
}) {
  const [search, setSearch, debouncedSearch] = (0,external_wp_compose_namespaceObject.useDebouncedInput)();
  const {
    mediaList,
    isLoading
  } = useMediaResults(category, {
    per_page: !!debouncedSearch ? 20 : INITIAL_MEDIA_ITEMS_PER_PAGE,
    search: debouncedSearch
  });
  const baseCssClass = &#039;block-editor-inserter__media-panel&#039;;
  const searchLabel = category.labels.search_items || (0,external_wp_i18n_namespaceObject.__)(&#039;Search&#039;);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;div&quot;, {
    className: baseCssClass,
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.SearchControl, {
      __nextHasNoMarginBottom: true,
      className: `${baseCssClass}-search`,
      onChange: setSearch,
      value: search,
      label: searchLabel,
      placeholder: searchLabel
    }), isLoading &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
      className: `${baseCssClass}-spinner`,
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Spinner, {})
    }), !isLoading &amp;&amp; !mediaList?.length &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(no_results, {}), !isLoading &amp;&amp; !!mediaList?.length &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(media_list, {
      rootClientId: rootClientId,
      onClick: onInsert,
      mediaList: mediaList,
      category: category
    })]
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/media-tab/media-tab.js
/**
 * WordPress dependencies
 */





/**
 * Internal dependencies
 */









const media_tab_ALLOWED_MEDIA_TYPES = [&#039;image&#039;, &#039;video&#039;, &#039;audio&#039;];
function MediaTab({
  rootClientId,
  selectedCategory,
  onSelectCategory,
  onInsert,
  children
}) {
  const mediaCategories = useMediaCategories(rootClientId);
  const isMobile = (0,external_wp_compose_namespaceObject.useViewportMatch)(&#039;medium&#039;, &#039;&lt;&#039;);
  const baseCssClass = &#039;block-editor-inserter__media-tabs&#039;;
  const onSelectMedia = (0,external_wp_element_namespaceObject.useCallback)(media =&gt; {
    if (!media?.url) {
      return;
    }
    const [block] = getBlockAndPreviewFromMedia(media, media.type);
    onInsert(block);
  }, [onInsert]);
  const categories = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; mediaCategories.map(mediaCategory =&gt; ({
    ...mediaCategory,
    label: mediaCategory.labels.name
  })), [mediaCategories]);
  if (!categories.length) {
    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(no_results, {});
  }
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
    children: [!isMobile &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;div&quot;, {
      className: `${baseCssClass}-container`,
      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(category_tabs, {
        categories: categories,
        selectedCategory: selectedCategory,
        onSelectCategory: onSelectCategory,
        children: children
      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(check, {
        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(media_upload, {
          multiple: false,
          onSelect: onSelectMedia,
          allowedTypes: media_tab_ALLOWED_MEDIA_TYPES,
          render: ({
            open
          }) =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
            __next40pxDefaultSize: true,
            onClick: event =&gt; {
              // Safari doesn&#039;t emit a focus event on button elements when
              // clicked and we need to manually focus the button here.
              // The reason is that core&#039;s Media Library modal explicitly triggers a
              // focus event and therefore a `blur` event is triggered on a different
              // element, which doesn&#039;t contain the `data-unstable-ignore-focus-outside-for-relatedtarget`
              // attribute making the Inserter dialog to close.
              event.target.focus();
              open();
            },
            className: &quot;block-editor-inserter__media-library-button&quot;,
            variant: &quot;secondary&quot;,
            &quot;data-unstable-ignore-focus-outside-for-relatedtarget&quot;: &quot;.media-modal&quot;,
            children: (0,external_wp_i18n_namespaceObject.__)(&#039;Open Media Library&#039;)
          })
        })
      })]
    }), isMobile &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(MobileTabNavigation, {
      categories: categories,
      children: category =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(MediaCategoryPanel, {
        onInsert: onInsert,
        rootClientId: rootClientId,
        category: category
      })
    })]
  });
}
/* harmony default export */ const media_tab = (MediaTab);

;// ./node_modules/@wordpress/block-editor/build-module/components/inserter-menu-extension/index.js
/**
 * WordPress dependencies
 */

const {
  Fill: __unstableInserterMenuExtension,
  Slot
} = (0,external_wp_components_namespaceObject.createSlotFill)(&#039;__unstableInserterMenuExtension&#039;);
__unstableInserterMenuExtension.Slot = Slot;
/* harmony default export */ const inserter_menu_extension = (__unstableInserterMenuExtension);

;// ./node_modules/@wordpress/block-editor/build-module/utils/order-inserter-block-items.js
/** @typedef {import(&#039;../store/selectors&#039;).WPEditorInserterItem} WPEditorInserterItem */

/**
 * Helper function to order inserter block items according to a provided array of prioritized blocks.
 *
 * @param {WPEditorInserterItem[]} items    The array of editor inserter block items to be sorted.
 * @param {string[]}               priority The array of block names to be prioritized.
 * @return {WPEditorInserterItem[]} The sorted array of editor inserter block items.
 */
const orderInserterBlockItems = (items, priority) =&gt; {
  if (!priority) {
    return items;
  }
  items.sort(({
    id: aName
  }, {
    id: bName
  }) =&gt; {
    // Sort block items according to `priority`.
    let aIndex = priority.indexOf(aName);
    let bIndex = priority.indexOf(bName);
    // All other block items should come after that.
    if (aIndex &lt; 0) {
      aIndex = priority.length;
    }
    if (bIndex &lt; 0) {
      bIndex = priority.length;
    }
    return aIndex - bIndex;
  });
  return items;
};

;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/search-results.js
/**
 * WordPress dependencies
 */







/**
 * Internal dependencies
 */














const INITIAL_INSERTER_RESULTS = 9;
/**
 * Shared reference to an empty array for cases where it is important to avoid
 * returning a new array reference on every invocation and rerendering the component.
 *
 * @type {Array}
 */
const search_results_EMPTY_ARRAY = [];
function InserterSearchResults({
  filterValue,
  onSelect,
  onHover,
  onHoverPattern,
  rootClientId,
  clientId,
  isAppender,
  __experimentalInsertionIndex,
  maxBlockPatterns,
  maxBlockTypes,
  showBlockDirectory = false,
  isDraggable = true,
  shouldFocusBlock = true,
  prioritizePatterns,
  selectBlockOnInsert,
  isQuick
}) {
  const debouncedSpeak = (0,external_wp_compose_namespaceObject.useDebounce)(external_wp_a11y_namespaceObject.speak, 500);
  const {
    prioritizedBlocks
  } = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const blockListSettings = select(store).getBlockListSettings(rootClientId);
    return {
      prioritizedBlocks: blockListSettings?.prioritizedInserterBlocks || search_results_EMPTY_ARRAY
    };
  }, [rootClientId]);
  const [destinationRootClientId, onInsertBlocks] = use_insertion_point({
    onSelect,
    rootClientId,
    clientId,
    isAppender,
    insertionIndex: __experimentalInsertionIndex,
    shouldFocusBlock,
    selectBlockOnInsert
  });
  const [blockTypes, blockTypeCategories, blockTypeCollections, onSelectBlockType] = use_block_types_state(destinationRootClientId, onInsertBlocks, isQuick);
  const [patterns,, onClickPattern] = use_patterns_state(onInsertBlocks, destinationRootClientId, undefined, isQuick);
  const filteredBlockPatterns = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; {
    if (maxBlockPatterns === 0) {
      return [];
    }
    const results = searchItems(patterns, filterValue);
    return maxBlockPatterns !== undefined ? results.slice(0, maxBlockPatterns) : results;
  }, [filterValue, patterns, maxBlockPatterns]);
  let maxBlockTypesToShow = maxBlockTypes;
  if (prioritizePatterns &amp;&amp; filteredBlockPatterns.length &gt; 2) {
    maxBlockTypesToShow = 0;
  }
  const filteredBlockTypes = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; {
    if (maxBlockTypesToShow === 0) {
      return [];
    }
    const nonPatternBlockTypes = blockTypes.filter(blockType =&gt; blockType.name !== &#039;core/block&#039;);
    let orderedItems = orderBy(nonPatternBlockTypes, &#039;frecency&#039;, &#039;desc&#039;);
    if (!filterValue &amp;&amp; prioritizedBlocks.length) {
      orderedItems = orderInserterBlockItems(orderedItems, prioritizedBlocks);
    }
    const results = searchBlockItems(orderedItems, blockTypeCategories, blockTypeCollections, filterValue);
    return maxBlockTypesToShow !== undefined ? results.slice(0, maxBlockTypesToShow) : results;
  }, [filterValue, blockTypes, blockTypeCategories, blockTypeCollections, maxBlockTypesToShow, prioritizedBlocks]);

  // Announce search results on change.
  (0,external_wp_element_namespaceObject.useEffect)(() =&gt; {
    if (!filterValue) {
      return;
    }
    const count = filteredBlockTypes.length + filteredBlockPatterns.length;
    const resultsFoundMessage = (0,external_wp_i18n_namespaceObject.sprintf)(/* translators: %d: number of results. */
    (0,external_wp_i18n_namespaceObject._n)(&#039;%d result found.&#039;, &#039;%d results found.&#039;, count), count);
    debouncedSpeak(resultsFoundMessage);
  }, [filterValue, debouncedSpeak, filteredBlockTypes, filteredBlockPatterns]);
  const currentShownBlockTypes = (0,external_wp_compose_namespaceObject.useAsyncList)(filteredBlockTypes, {
    step: INITIAL_INSERTER_RESULTS
  });
  const hasItems = filteredBlockTypes.length &gt; 0 || filteredBlockPatterns.length &gt; 0;
  const blocksUI = !!filteredBlockTypes.length &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(panel, {
    title: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.VisuallyHidden, {
      children: (0,external_wp_i18n_namespaceObject.__)(&#039;Blocks&#039;)
    }),
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_types_list, {
      items: currentShownBlockTypes,
      onSelect: onSelectBlockType,
      onHover: onHover,
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Blocks&#039;),
      isDraggable: isDraggable
    })
  });
  const patternsUI = !!filteredBlockPatterns.length &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(panel, {
    title: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.VisuallyHidden, {
      children: (0,external_wp_i18n_namespaceObject.__)(&#039;Block patterns&#039;)
    }),
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
      className: &quot;block-editor-inserter__quick-inserter-patterns&quot;,
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_patterns_list, {
        blockPatterns: filteredBlockPatterns,
        onClickPattern: onClickPattern,
        onHover: onHoverPattern,
        isDraggable: isDraggable
      })
    })
  });
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(inserter_listbox, {
    children: [!showBlockDirectory &amp;&amp; !hasItems &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(no_results, {}), prioritizePatterns ? patternsUI : blocksUI, !!filteredBlockTypes.length &amp;&amp; !!filteredBlockPatterns.length &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
      className: &quot;block-editor-inserter__quick-inserter-separator&quot;
    }), prioritizePatterns ? blocksUI : patternsUI, showBlockDirectory &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inserter_menu_extension.Slot, {
      fillProps: {
        onSelect: onSelectBlockType,
        onHover,
        filterValue,
        hasItems,
        rootClientId: destinationRootClientId
      },
      children: fills =&gt; {
        if (fills.length) {
          return fills;
        }
        if (!hasItems) {
          return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(no_results, {});
        }
        return null;
      }
    })]
  });
}
/* harmony default export */ const inserter_search_results = (InserterSearchResults);

;// ./node_modules/@wordpress/icons/build-module/library/close-small.js
/**
 * WordPress dependencies
 */


const closeSmall = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;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&quot;
  })
});
/* harmony default export */ const close_small = (closeSmall);

;// ./node_modules/@wordpress/block-editor/build-module/components/tabbed-sidebar/index.js
/**
 * WordPress dependencies
 */




/**
 * Internal dependencies
 */


const {
  Tabs: tabbed_sidebar_Tabs
} = unlock(external_wp_components_namespaceObject.privateApis);

/**
 * A component that creates a tabbed sidebar with a close button.
 *
 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/tabbed-sidebar/README.md
 *
 * @example
 * ```jsx
 * function MyTabbedSidebar() {
 *   return (
 *     &lt;TabbedSidebar
 *       tabs={ [
 *         {
 *           name: &#039;tab1&#039;,
 *           title: &#039;Settings&#039;,
 *           panel: &lt;PanelContents /&gt;,
 *         }
 *       ] }
 *       onClose={ () =&gt; {} }
 *       onSelect={ () =&gt; {} }
 *       defaultTabId=&quot;tab1&quot;
 *       selectedTab=&quot;tab1&quot;
 *       closeButtonLabel=&quot;Close sidebar&quot;
 *     /&gt;
 *   );
 * }
 * ```
 *
 * @param {Object}   props                  Component props.
 * @param {string}   [props.defaultTabId]   The ID of the tab to be selected by default when the component renders.
 * @param {Function} props.onClose          Function called when the close button is clicked.
 * @param {Function} props.onSelect         Function called when a tab is selected. Receives the selected tab&#039;s ID as an argument.
 * @param {string}   props.selectedTab      The ID of the currently selected tab.
 * @param {Array}    props.tabs             Array of tab objects. Each tab should have: name (string), title (string),
 *                                          panel (React.Node), and optionally panelRef (React.Ref).
 * @param {string}   props.closeButtonLabel Accessibility label for the close button.
 * @param {Object}   ref                    Forward ref to the tabs list element.
 * @return {Element} The tabbed sidebar component.
 */
function TabbedSidebar({
  defaultTabId,
  onClose,
  onSelect,
  selectedTab,
  tabs,
  closeButtonLabel
}, ref) {
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
    className: &quot;block-editor-tabbed-sidebar&quot;,
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(tabbed_sidebar_Tabs, {
      selectOnMove: false,
      defaultTabId: defaultTabId,
      onSelect: onSelect,
      selectedTabId: selectedTab,
      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;div&quot;, {
        className: &quot;block-editor-tabbed-sidebar__tablist-and-close-button&quot;,
        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
          className: &quot;block-editor-tabbed-sidebar__close-button&quot;,
          icon: close_small,
          label: closeButtonLabel,
          onClick: () =&gt; onClose(),
          size: &quot;compact&quot;
        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(tabbed_sidebar_Tabs.TabList, {
          className: &quot;block-editor-tabbed-sidebar__tablist&quot;,
          ref: ref,
          children: tabs.map(tab =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(tabbed_sidebar_Tabs.Tab, {
            tabId: tab.name,
            className: &quot;block-editor-tabbed-sidebar__tab&quot;,
            children: tab.title
          }, tab.name))
        })]
      }), tabs.map(tab =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(tabbed_sidebar_Tabs.TabPanel, {
        tabId: tab.name,
        focusable: false,
        className: &quot;block-editor-tabbed-sidebar__tabpanel&quot;,
        ref: tab.panelRef,
        children: tab.panel
      }, tab.name))]
    })
  });
}
/* harmony default export */ const tabbed_sidebar = ((0,external_wp_element_namespaceObject.forwardRef)(TabbedSidebar));

;// ./node_modules/@wordpress/block-editor/build-module/hooks/use-zoom-out.js
/**
 * WordPress dependencies
 */



/**
 * Internal dependencies
 */



/**
 * A hook used to set the editor mode to zoomed out mode, invoking the hook sets the mode.
 * Concepts:
 * - If we most recently changed the zoom level for them (in or out), we always resetZoomLevel() level when unmounting.
 * - If the user most recently changed the zoom level (manually toggling), we do nothing when unmounting.
 *
 * @param {boolean} enabled If we should enter into zoomOut mode or not
 */
function useZoomOut(enabled = true) {
  const {
    setZoomLevel,
    resetZoomLevel
  } = unlock((0,external_wp_data_namespaceObject.useDispatch)(store));

  /**
   * We need access to both the value and the function. The value is to trigger a useEffect hook
   * and the function is to check zoom out within another hook without triggering a re-render.
   */
  const {
    isZoomedOut,
    isZoomOut
  } = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      isZoomOut: _isZoomOut
    } = unlock(select(store));
    return {
      isZoomedOut: _isZoomOut(),
      isZoomOut: _isZoomOut
    };
  }, []);
  const controlZoomLevelRef = (0,external_wp_element_namespaceObject.useRef)(false);
  const isEnabledRef = (0,external_wp_element_namespaceObject.useRef)(enabled);

  /**
   * This hook tracks if the zoom state was changed manually by the user via clicking
   * the zoom out button. We only want this to run when isZoomedOut changes, so we use
   * a ref to track the enabled state.
   */
  (0,external_wp_element_namespaceObject.useEffect)(() =&gt; {
    // If the zoom state changed (isZoomOut) and it does not match the requested zoom
    // state (zoomOut), then it means the user manually changed the zoom state while
    // this hook was mounted, and we should no longer control the zoom state.
    if (isZoomedOut !== isEnabledRef.current) {
      controlZoomLevelRef.current = false;
    }
  }, [isZoomedOut]);
  (0,external_wp_element_namespaceObject.useEffect)(() =&gt; {
    isEnabledRef.current = enabled;
    if (enabled !== isZoomOut()) {
      controlZoomLevelRef.current = true;
      if (enabled) {
        setZoomLevel(&#039;auto-scaled&#039;);
      } else {
        resetZoomLevel();
      }
    }
    return () =&gt; {
      // If we are controlling zoom level and are zoomed out, reset the zoom level.
      if (controlZoomLevelRef.current &amp;&amp; isZoomOut()) {
        resetZoomLevel();
      }
    };
  }, [enabled, isZoomOut, resetZoomLevel, setZoomLevel]);
}

;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/menu.js
/**
 * External dependencies
 */


/**
 * WordPress dependencies
 */






/**
 * Internal dependencies
 */













const NOOP = () =&gt; {};
function InserterMenu({
  rootClientId,
  clientId,
  isAppender,
  __experimentalInsertionIndex,
  onSelect,
  showInserterHelpPanel,
  showMostUsedBlocks,
  __experimentalFilterValue = &#039;&#039;,
  shouldFocusBlock = true,
  onPatternCategorySelection,
  onClose,
  __experimentalInitialTab,
  __experimentalInitialCategory
}, ref) {
  const {
    isZoomOutMode,
    hasSectionRootClientId
  } = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      isZoomOut,
      getSectionRootClientId
    } = unlock(select(store));
    return {
      isZoomOutMode: isZoomOut(),
      hasSectionRootClientId: !!getSectionRootClientId()
    };
  }, []);
  const [filterValue, setFilterValue, delayedFilterValue] = (0,external_wp_compose_namespaceObject.useDebouncedInput)(__experimentalFilterValue);
  const [hoveredItem, setHoveredItem] = (0,external_wp_element_namespaceObject.useState)(null);
  const [selectedPatternCategory, setSelectedPatternCategory] = (0,external_wp_element_namespaceObject.useState)(__experimentalInitialCategory);
  const [patternFilter, setPatternFilter] = (0,external_wp_element_namespaceObject.useState)(&#039;all&#039;);
  const [selectedMediaCategory, setSelectedMediaCategory] = (0,external_wp_element_namespaceObject.useState)(null);
  const isLargeViewport = (0,external_wp_compose_namespaceObject.useViewportMatch)(&#039;large&#039;);
  function getInitialTab() {
    if (__experimentalInitialTab) {
      return __experimentalInitialTab;
    }
    if (isZoomOutMode) {
      return &#039;patterns&#039;;
    }
    return &#039;blocks&#039;;
  }
  const [selectedTab, setSelectedTab] = (0,external_wp_element_namespaceObject.useState)(getInitialTab());
  const shouldUseZoomOut = hasSectionRootClientId &amp;&amp; (selectedTab === &#039;patterns&#039; || selectedTab === &#039;media&#039;);
  useZoomOut(shouldUseZoomOut &amp;&amp; isLargeViewport);
  const [destinationRootClientId, onInsertBlocks, onToggleInsertionPoint] = use_insertion_point({
    rootClientId,
    clientId,
    isAppender,
    insertionIndex: __experimentalInsertionIndex,
    shouldFocusBlock
  });
  const blockTypesTabRef = (0,external_wp_element_namespaceObject.useRef)();
  const onInsert = (0,external_wp_element_namespaceObject.useCallback)((blocks, meta, shouldForceFocusBlock, _rootClientId) =&gt; {
    onInsertBlocks(blocks, meta, shouldForceFocusBlock, _rootClientId);
    onSelect(blocks);

    // Check for focus loss due to filtering blocks by selected block type
    window.requestAnimationFrame(() =&gt; {
      if (!shouldFocusBlock &amp;&amp; !blockTypesTabRef.current?.contains(ref.current.ownerDocument.activeElement)) {
        // There has been a focus loss, so focus the first button in the block types tab
        blockTypesTabRef.current?.querySelector(&#039;button&#039;).focus();
      }
    });
  }, [onInsertBlocks, onSelect, shouldFocusBlock]);
  const onInsertPattern = (0,external_wp_element_namespaceObject.useCallback)((blocks, patternName, ...args) =&gt; {
    onToggleInsertionPoint(false);
    onInsertBlocks(blocks, {
      patternName
    }, ...args);
    onSelect();
  }, [onInsertBlocks, onSelect]);
  const onHover = (0,external_wp_element_namespaceObject.useCallback)(item =&gt; {
    onToggleInsertionPoint(item);
    setHoveredItem(item);
  }, [onToggleInsertionPoint, setHoveredItem]);
  const onClickPatternCategory = (0,external_wp_element_namespaceObject.useCallback)((patternCategory, filter) =&gt; {
    setSelectedPatternCategory(patternCategory);
    setPatternFilter(filter);
    onPatternCategorySelection?.();
  }, [setSelectedPatternCategory, onPatternCategorySelection]);
  const showPatternPanel = selectedTab === &#039;patterns&#039; &amp;&amp; !delayedFilterValue &amp;&amp; !!selectedPatternCategory;
  const showMediaPanel = selectedTab === &#039;media&#039; &amp;&amp; !!selectedMediaCategory;
  const inserterSearch = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; {
    if (selectedTab === &#039;media&#039;) {
      return null;
    }
    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.SearchControl, {
        __nextHasNoMarginBottom: true,
        className: &quot;block-editor-inserter__search&quot;,
        onChange: value =&gt; {
          if (hoveredItem) {
            setHoveredItem(null);
          }
          setFilterValue(value);
        },
        value: filterValue,
        label: (0,external_wp_i18n_namespaceObject.__)(&#039;Search&#039;),
        placeholder: (0,external_wp_i18n_namespaceObject.__)(&#039;Search&#039;)
      }), !!delayedFilterValue &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inserter_search_results, {
        filterValue: delayedFilterValue,
        onSelect: onSelect,
        onHover: onHover,
        rootClientId: rootClientId,
        clientId: clientId,
        isAppender: isAppender,
        __experimentalInsertionIndex: __experimentalInsertionIndex,
        showBlockDirectory: true,
        shouldFocusBlock: shouldFocusBlock,
        prioritizePatterns: selectedTab === &#039;patterns&#039;
      })]
    });
  }, [selectedTab, hoveredItem, setHoveredItem, setFilterValue, filterValue, delayedFilterValue, onSelect, onHover, shouldFocusBlock, clientId, rootClientId, __experimentalInsertionIndex, isAppender]);
  const blocksTab = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; {
    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
        className: &quot;block-editor-inserter__block-list&quot;,
        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_types_tab, {
          ref: blockTypesTabRef,
          rootClientId: destinationRootClientId,
          onInsert: onInsert,
          onHover: onHover,
          showMostUsedBlocks: showMostUsedBlocks
        })
      }), showInserterHelpPanel &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;div&quot;, {
        className: &quot;block-editor-inserter__tips&quot;,
        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.VisuallyHidden, {
          as: &quot;h2&quot;,
          children: (0,external_wp_i18n_namespaceObject.__)(&#039;A tip for using the block editor&#039;)
        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(tips, {})]
      })]
    });
  }, [destinationRootClientId, onInsert, onHover, showMostUsedBlocks, showInserterHelpPanel]);
  const patternsTab = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; {
    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_patterns_tab, {
      rootClientId: destinationRootClientId,
      onInsert: onInsertPattern,
      onSelectCategory: onClickPatternCategory,
      selectedCategory: selectedPatternCategory,
      children: showPatternPanel &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PatternCategoryPreviews, {
        rootClientId: destinationRootClientId,
        onInsert: onInsertPattern,
        category: selectedPatternCategory,
        patternFilter: patternFilter,
        showTitlesAsTooltip: true
      })
    });
  }, [destinationRootClientId, onInsertPattern, onClickPatternCategory, patternFilter, selectedPatternCategory, showPatternPanel]);
  const mediaTab = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; {
    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(media_tab, {
      rootClientId: destinationRootClientId,
      selectedCategory: selectedMediaCategory,
      onSelectCategory: setSelectedMediaCategory,
      onInsert: onInsert,
      children: showMediaPanel &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(MediaCategoryPanel, {
        rootClientId: destinationRootClientId,
        onInsert: onInsert,
        category: selectedMediaCategory
      })
    });
  }, [destinationRootClientId, onInsert, selectedMediaCategory, setSelectedMediaCategory, showMediaPanel]);
  const handleSetSelectedTab = value =&gt; {
    // If no longer on patterns tab remove the category setting.
    if (value !== &#039;patterns&#039;) {
      setSelectedPatternCategory(null);
    }
    setSelectedTab(value);
  };

  // Focus first active tab, if any
  const tabsRef = (0,external_wp_element_namespaceObject.useRef)();
  (0,external_wp_element_namespaceObject.useLayoutEffect)(() =&gt; {
    if (tabsRef.current) {
      window.requestAnimationFrame(() =&gt; {
        tabsRef.current.querySelector(&#039;[role=&quot;tab&quot;][aria-selected=&quot;true&quot;]&#039;)?.focus();
      });
    }
  }, []);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;div&quot;, {
    className: dist_clsx(&#039;block-editor-inserter__menu&#039;, {
      &#039;show-panel&#039;: showPatternPanel || showMediaPanel,
      &#039;is-zoom-out&#039;: isZoomOutMode
    }),
    ref: ref,
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
      className: &quot;block-editor-inserter__main-area&quot;,
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(tabbed_sidebar, {
        ref: tabsRef,
        onSelect: handleSetSelectedTab,
        onClose: onClose,
        selectedTab: selectedTab,
        closeButtonLabel: (0,external_wp_i18n_namespaceObject.__)(&#039;Close Block Inserter&#039;),
        tabs: [{
          name: &#039;blocks&#039;,
          title: (0,external_wp_i18n_namespaceObject.__)(&#039;Blocks&#039;),
          panel: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
            children: [inserterSearch, selectedTab === &#039;blocks&#039; &amp;&amp; !delayedFilterValue &amp;&amp; blocksTab]
          })
        }, {
          name: &#039;patterns&#039;,
          title: (0,external_wp_i18n_namespaceObject.__)(&#039;Patterns&#039;),
          panel: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
            children: [inserterSearch, selectedTab === &#039;patterns&#039; &amp;&amp; !delayedFilterValue &amp;&amp; patternsTab]
          })
        }, {
          name: &#039;media&#039;,
          title: (0,external_wp_i18n_namespaceObject.__)(&#039;Media&#039;),
          panel: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
            children: [inserterSearch, mediaTab]
          })
        }]
      })
    }), showInserterHelpPanel &amp;&amp; hoveredItem &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Popover, {
      className: &quot;block-editor-inserter__preview-container__popover&quot;,
      placement: &quot;right-start&quot;,
      offset: 16,
      focusOnMount: false,
      animate: false,
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(preview_panel, {
        item: hoveredItem
      })
    })]
  });
}
const PrivateInserterMenu = (0,external_wp_element_namespaceObject.forwardRef)(InserterMenu);
function PublicInserterMenu(props, ref) {
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PrivateInserterMenu, {
    ...props,
    onPatternCategorySelection: NOOP,
    ref: ref
  });
}
/* harmony default export */ const menu = ((0,external_wp_element_namespaceObject.forwardRef)(PublicInserterMenu));

;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/quick-inserter.js
/**
 * External dependencies
 */


/**
 * WordPress dependencies
 */





/**
 * Internal dependencies
 */





const SEARCH_THRESHOLD = 6;
const SHOWN_BLOCK_TYPES = 6;
const SHOWN_BLOCK_PATTERNS = 2;
function QuickInserter({
  onSelect,
  rootClientId,
  clientId,
  isAppender,
  selectBlockOnInsert,
  hasSearch = true
}) {
  const [filterValue, setFilterValue] = (0,external_wp_element_namespaceObject.useState)(&#039;&#039;);
  const [destinationRootClientId, onInsertBlocks] = use_insertion_point({
    onSelect,
    rootClientId,
    clientId,
    isAppender,
    selectBlockOnInsert
  });
  const [blockTypes] = use_block_types_state(destinationRootClientId, onInsertBlocks, true);
  const {
    setInserterIsOpened,
    insertionIndex
  } = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      getSettings,
      getBlockIndex,
      getBlockCount
    } = select(store);
    const settings = getSettings();
    const index = getBlockIndex(clientId);
    const blockCount = getBlockCount();
    return {
      setInserterIsOpened: settings.__experimentalSetIsInserterOpened,
      insertionIndex: index === -1 ? blockCount : index
    };
  }, [clientId]);
  const showSearch = hasSearch &amp;&amp; blockTypes.length &gt; SEARCH_THRESHOLD;
  (0,external_wp_element_namespaceObject.useEffect)(() =&gt; {
    if (setInserterIsOpened) {
      setInserterIsOpened(false);
    }
  }, [setInserterIsOpened]);

  // When clicking Browse All select the appropriate block so as
  // the insertion point can work as expected.
  const onBrowseAll = () =&gt; {
    setInserterIsOpened({
      filterValue,
      onSelect,
      rootClientId,
      insertionIndex
    });
  };
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;div&quot;, {
    className: dist_clsx(&#039;block-editor-inserter__quick-inserter&#039;, {
      &#039;has-search&#039;: showSearch,
      &#039;has-expand&#039;: setInserterIsOpened
    }),
    children: [showSearch &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.SearchControl, {
      __nextHasNoMarginBottom: true,
      className: &quot;block-editor-inserter__search&quot;,
      value: filterValue,
      onChange: value =&gt; {
        setFilterValue(value);
      },
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Search&#039;),
      placeholder: (0,external_wp_i18n_namespaceObject.__)(&#039;Search&#039;)
    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
      className: &quot;block-editor-inserter__quick-inserter-results&quot;,
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inserter_search_results, {
        filterValue: filterValue,
        onSelect: onSelect,
        rootClientId: rootClientId,
        clientId: clientId,
        isAppender: isAppender,
        maxBlockPatterns: !!filterValue ? SHOWN_BLOCK_PATTERNS : 0,
        maxBlockTypes: SHOWN_BLOCK_TYPES,
        isDraggable: false,
        selectBlockOnInsert: selectBlockOnInsert,
        isQuick: true
      })
    }), setInserterIsOpened &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
      __next40pxDefaultSize: true,
      className: &quot;block-editor-inserter__quick-inserter-expand&quot;,
      onClick: onBrowseAll,
      &quot;aria-label&quot;: (0,external_wp_i18n_namespaceObject.__)(&#039;Browse all. This will open the main inserter panel in the editor toolbar.&#039;),
      children: (0,external_wp_i18n_namespaceObject.__)(&#039;Browse all&#039;)
    })]
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/index.js
/**
 * External dependencies
 */


/**
 * WordPress dependencies
 */









/**
 * Internal dependencies
 */




const defaultRenderToggle = ({
  onToggle,
  disabled,
  isOpen,
  blockTitle,
  hasSingleBlockType,
  toggleProps = {}
}) =&gt; {
  const {
    as: Wrapper = external_wp_components_namespaceObject.Button,
    label: labelProp,
    onClick,
    ...rest
  } = toggleProps;
  let label = labelProp;
  if (!label &amp;&amp; hasSingleBlockType) {
    label = (0,external_wp_i18n_namespaceObject.sprintf)(
    // translators: %s: the name of the block when there is only one
    (0,external_wp_i18n_namespaceObject._x)(&#039;Add %s&#039;, &#039;directly add the only allowed block&#039;), blockTitle);
  } else if (!label) {
    label = (0,external_wp_i18n_namespaceObject._x)(&#039;Add block&#039;, &#039;Generic label for block inserter button&#039;);
  }

  // Handle both onClick functions from the toggle and the parent component.
  function handleClick(event) {
    if (onToggle) {
      onToggle(event);
    }
    if (onClick) {
      onClick(event);
    }
  }
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Wrapper, {
    __next40pxDefaultSize: toggleProps.as ? undefined : true,
    icon: library_plus,
    label: label,
    tooltipPosition: &quot;bottom&quot;,
    onClick: handleClick,
    className: &quot;block-editor-inserter__toggle&quot;,
    &quot;aria-haspopup&quot;: !hasSingleBlockType ? &#039;true&#039; : false,
    &quot;aria-expanded&quot;: !hasSingleBlockType ? isOpen : false,
    disabled: disabled,
    ...rest
  });
};
class Inserter extends external_wp_element_namespaceObject.Component {
  constructor() {
    super(...arguments);
    this.onToggle = this.onToggle.bind(this);
    this.renderToggle = this.renderToggle.bind(this);
    this.renderContent = this.renderContent.bind(this);
  }
  onToggle(isOpen) {
    const {
      onToggle
    } = this.props;

    // Surface toggle callback to parent component.
    if (onToggle) {
      onToggle(isOpen);
    }
  }

  /**
   * Render callback to display Dropdown toggle element.
   *
   * @param {Object}   options
   * @param {Function} options.onToggle Callback to invoke when toggle is
   *                                    pressed.
   * @param {boolean}  options.isOpen   Whether dropdown is currently open.
   *
   * @return {Element} Dropdown toggle element.
   */
  renderToggle({
    onToggle,
    isOpen
  }) {
    const {
      disabled,
      blockTitle,
      hasSingleBlockType,
      directInsertBlock,
      toggleProps,
      hasItems,
      renderToggle = defaultRenderToggle
    } = this.props;
    return renderToggle({
      onToggle,
      isOpen,
      disabled: disabled || !hasItems,
      blockTitle,
      hasSingleBlockType,
      directInsertBlock,
      toggleProps
    });
  }

  /**
   * Render callback to display Dropdown content element.
   *
   * @param {Object}   options
   * @param {Function} options.onClose Callback to invoke when dropdown is
   *                                   closed.
   *
   * @return {Element} Dropdown content element.
   */
  renderContent({
    onClose
  }) {
    const {
      rootClientId,
      clientId,
      isAppender,
      showInserterHelpPanel,
      // This prop is experimental to give some time for the quick inserter to mature
      // Feel free to make them stable after a few releases.
      __experimentalIsQuick: isQuick,
      onSelectOrClose,
      selectBlockOnInsert
    } = this.props;
    if (isQuick) {
      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(QuickInserter, {
        onSelect: blocks =&gt; {
          const firstBlock = Array.isArray(blocks) &amp;&amp; blocks?.length ? blocks[0] : blocks;
          if (onSelectOrClose &amp;&amp; typeof onSelectOrClose === &#039;function&#039;) {
            onSelectOrClose(firstBlock);
          }
          onClose();
        },
        rootClientId: rootClientId,
        clientId: clientId,
        isAppender: isAppender,
        selectBlockOnInsert: selectBlockOnInsert
      });
    }
    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(menu, {
      onSelect: () =&gt; {
        onClose();
      },
      rootClientId: rootClientId,
      clientId: clientId,
      isAppender: isAppender,
      showInserterHelpPanel: showInserterHelpPanel
    });
  }
  render() {
    const {
      position,
      hasSingleBlockType,
      directInsertBlock,
      insertOnlyAllowedBlock,
      __experimentalIsQuick: isQuick,
      onSelectOrClose
    } = this.props;
    if (hasSingleBlockType || directInsertBlock) {
      return this.renderToggle({
        onToggle: insertOnlyAllowedBlock
      });
    }
    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Dropdown, {
      className: &quot;block-editor-inserter&quot;,
      contentClassName: dist_clsx(&#039;block-editor-inserter__popover&#039;, {
        &#039;is-quick&#039;: isQuick
      }),
      popoverProps: {
        position,
        shift: true
      },
      onToggle: this.onToggle,
      expandOnMobile: true,
      headerTitle: (0,external_wp_i18n_namespaceObject.__)(&#039;Add a block&#039;),
      renderToggle: this.renderToggle,
      renderContent: this.renderContent,
      onClose: onSelectOrClose
    });
  }
}
/* harmony default export */ const inserter = ((0,external_wp_compose_namespaceObject.compose)([(0,external_wp_data_namespaceObject.withSelect)((select, {
  clientId,
  rootClientId,
  shouldDirectInsert = true
}) =&gt; {
  const {
    getBlockRootClientId,
    hasInserterItems,
    getAllowedBlocks,
    getDirectInsertBlock
  } = select(store);
  const {
    getBlockVariations
  } = select(external_wp_blocks_namespaceObject.store);
  rootClientId = rootClientId || getBlockRootClientId(clientId) || undefined;
  const allowedBlocks = getAllowedBlocks(rootClientId);
  const directInsertBlock = shouldDirectInsert &amp;&amp; getDirectInsertBlock(rootClientId);
  const hasSingleBlockType = allowedBlocks?.length === 1 &amp;&amp; getBlockVariations(allowedBlocks[0].name, &#039;inserter&#039;)?.length === 0;
  let allowedBlockType = false;
  if (hasSingleBlockType) {
    allowedBlockType = allowedBlocks[0];
  }
  return {
    hasItems: hasInserterItems(rootClientId),
    hasSingleBlockType,
    blockTitle: allowedBlockType ? allowedBlockType.title : &#039;&#039;,
    allowedBlockType,
    directInsertBlock,
    rootClientId
  };
}), (0,external_wp_data_namespaceObject.withDispatch)((dispatch, ownProps, {
  select
}) =&gt; {
  return {
    insertOnlyAllowedBlock() {
      const {
        rootClientId,
        clientId,
        isAppender,
        hasSingleBlockType,
        allowedBlockType,
        directInsertBlock,
        onSelectOrClose,
        selectBlockOnInsert
      } = ownProps;
      if (!hasSingleBlockType &amp;&amp; !directInsertBlock) {
        return;
      }
      function getAdjacentBlockAttributes(attributesToCopy) {
        const {
          getBlock,
          getPreviousBlockClientId
        } = select(store);
        if (!attributesToCopy || !clientId &amp;&amp; !rootClientId) {
          return {};
        }
        const result = {};
        let adjacentAttributes = {};

        // If there is no clientId, then attempt to get attributes
        // from the last block within innerBlocks of the root block.
        if (!clientId) {
          const parentBlock = getBlock(rootClientId);
          if (parentBlock?.innerBlocks?.length) {
            const lastInnerBlock = parentBlock.innerBlocks[parentBlock.innerBlocks.length - 1];
            if (directInsertBlock &amp;&amp; directInsertBlock?.name === lastInnerBlock.name) {
              adjacentAttributes = lastInnerBlock.attributes;
            }
          }
        } else {
          // Otherwise, attempt to get attributes from the
          // previous block relative to the current clientId.
          const currentBlock = getBlock(clientId);
          const previousBlock = getBlock(getPreviousBlockClientId(clientId));
          if (currentBlock?.name === previousBlock?.name) {
            adjacentAttributes = previousBlock?.attributes || {};
          }
        }

        // Copy over only those attributes flagged to be copied.
        attributesToCopy.forEach(attribute =&gt; {
          if (adjacentAttributes.hasOwnProperty(attribute)) {
            result[attribute] = adjacentAttributes[attribute];
          }
        });
        return result;
      }
      function getInsertionIndex() {
        const {
          getBlockIndex,
          getBlockSelectionEnd,
          getBlockOrder,
          getBlockRootClientId
        } = select(store);

        // If the clientId is defined, we insert at the position of the block.
        if (clientId) {
          return getBlockIndex(clientId);
        }

        // If there a selected block, we insert after the selected block.
        const end = getBlockSelectionEnd();
        if (!isAppender &amp;&amp; end &amp;&amp; getBlockRootClientId(end) === rootClientId) {
          return getBlockIndex(end) + 1;
        }

        // Otherwise, we insert at the end of the current rootClientId.
        return getBlockOrder(rootClientId).length;
      }
      const {
        insertBlock
      } = dispatch(store);
      let blockToInsert;

      // Attempt to augment the directInsertBlock with attributes from an adjacent block.
      // This ensures styling from nearby blocks is preserved in the newly inserted block.
      // See: https://github.com/WordPress/gutenberg/issues/37904
      if (directInsertBlock) {
        const newAttributes = getAdjacentBlockAttributes(directInsertBlock.attributesToCopy);
        blockToInsert = (0,external_wp_blocks_namespaceObject.createBlock)(directInsertBlock.name, {
          ...(directInsertBlock.attributes || {}),
          ...newAttributes
        });
      } else {
        blockToInsert = (0,external_wp_blocks_namespaceObject.createBlock)(allowedBlockType.name);
      }
      insertBlock(blockToInsert, getInsertionIndex(), rootClientId, selectBlockOnInsert);
      if (onSelectOrClose) {
        onSelectOrClose({
          clientId: blockToInsert?.clientId
        });
      }
      const message = (0,external_wp_i18n_namespaceObject.sprintf)(
      // translators: %s: the name of the block that has been added
      (0,external_wp_i18n_namespaceObject.__)(&#039;%s block added&#039;), allowedBlockType.title);
      (0,external_wp_a11y_namespaceObject.speak)(message);
    }
  };
}),
// The global inserter should always be visible, we are using ( ! isAppender &amp;&amp; ! rootClientId &amp;&amp; ! clientId ) as
// a way to detect the global Inserter.
(0,external_wp_compose_namespaceObject.ifCondition)(({
  hasItems,
  isAppender,
  rootClientId,
  clientId
}) =&gt; hasItems || !isAppender &amp;&amp; !rootClientId &amp;&amp; !clientId)])(Inserter));

;// ./node_modules/@wordpress/block-editor/build-module/components/button-block-appender/index.js
/**
 * External dependencies
 */


/**
 * WordPress dependencies
 */






/**
 * Internal dependencies
 */


function button_block_appender_ButtonBlockAppender({
  rootClientId,
  className,
  onFocus,
  tabIndex,
  onSelect
}, ref) {
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inserter, {
    position: &quot;bottom center&quot;,
    rootClientId: rootClientId,
    __experimentalIsQuick: true,
    onSelectOrClose: (...args) =&gt; {
      if (onSelect &amp;&amp; typeof onSelect === &#039;function&#039;) {
        onSelect(...args);
      }
    },
    renderToggle: ({
      onToggle,
      disabled,
      isOpen,
      blockTitle,
      hasSingleBlockType
    }) =&gt; {
      const isToggleButton = !hasSingleBlockType;
      const label = hasSingleBlockType ? (0,external_wp_i18n_namespaceObject.sprintf)(
      // translators: %s: the name of the block when there is only one
      (0,external_wp_i18n_namespaceObject._x)(&#039;Add %s&#039;, &#039;directly add the only allowed block&#039;), blockTitle) : (0,external_wp_i18n_namespaceObject._x)(&#039;Add block&#039;, &#039;Generic label for block inserter button&#039;);
      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
        __next40pxDefaultSize: true,
        ref: ref,
        onFocus: onFocus,
        tabIndex: tabIndex,
        className: dist_clsx(className, &#039;block-editor-button-block-appender&#039;),
        onClick: onToggle,
        &quot;aria-haspopup&quot;: isToggleButton ? &#039;true&#039; : undefined,
        &quot;aria-expanded&quot;: isToggleButton ? isOpen : undefined
        // Disable reason: There shouldn&#039;t be a case where this button is disabled but not visually hidden.
        // eslint-disable-next-line no-restricted-syntax
        ,
        disabled: disabled,
        label: label,
        showTooltip: true,
        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(build_module_icon, {
          icon: library_plus
        })
      });
    },
    isAppender: true
  });
}

/**
 * Use `ButtonBlockAppender` instead.
 *
 * @deprecated
 */
const ButtonBlockerAppender = (0,external_wp_element_namespaceObject.forwardRef)((props, ref) =&gt; {
  external_wp_deprecated_default()(`wp.blockEditor.ButtonBlockerAppender`, {
    alternative: &#039;wp.blockEditor.ButtonBlockAppender&#039;,
    since: &#039;5.9&#039;
  });
  return button_block_appender_ButtonBlockAppender(props, ref);
});

/**
 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/button-block-appender/README.md
 */
/* harmony default export */ const button_block_appender = ((0,external_wp_element_namespaceObject.forwardRef)(button_block_appender_ButtonBlockAppender));

;// ./node_modules/@wordpress/block-editor/build-module/components/grid/grid-visualizer.js
/**
 * External dependencies
 */


/**
 * WordPress dependencies
 */




/**
 * Internal dependencies
 */








function GridVisualizer({
  clientId,
  contentRef,
  parentLayout
}) {
  const isDistractionFree = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; select(store).getSettings().isDistractionFree, []);
  const gridElement = useBlockElement(clientId);
  if (isDistractionFree || !gridElement) {
    return null;
  }
  const isManualGrid = parentLayout?.isManualPlacement &amp;&amp; window.__experimentalEnableGridInteractivity;
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(GridVisualizerGrid, {
    gridClientId: clientId,
    gridElement: gridElement,
    isManualGrid: isManualGrid,
    ref: contentRef
  });
}
const GridVisualizerGrid = (0,external_wp_element_namespaceObject.forwardRef)(({
  gridClientId,
  gridElement,
  isManualGrid
}, ref) =&gt; {
  const [gridInfo, setGridInfo] = (0,external_wp_element_namespaceObject.useState)(() =&gt; getGridInfo(gridElement));
  const [isDroppingAllowed, setIsDroppingAllowed] = (0,external_wp_element_namespaceObject.useState)(false);
  (0,external_wp_element_namespaceObject.useEffect)(() =&gt; {
    const resizeCallback = () =&gt; setGridInfo(getGridInfo(gridElement));
    // Both border-box and content-box are observed as they may change
    // independently. This requires two observers because a single one
    // can’t be made to monitor both on the same element.
    const borderBoxSpy = new window.ResizeObserver(resizeCallback);
    borderBoxSpy.observe(gridElement, {
      box: &#039;border-box&#039;
    });
    const contentBoxSpy = new window.ResizeObserver(resizeCallback);
    contentBoxSpy.observe(gridElement);
    return () =&gt; {
      borderBoxSpy.disconnect();
      contentBoxSpy.disconnect();
    };
  }, [gridElement]);
  (0,external_wp_element_namespaceObject.useEffect)(() =&gt; {
    function onGlobalDrag() {
      setIsDroppingAllowed(true);
    }
    function onGlobalDragEnd() {
      setIsDroppingAllowed(false);
    }
    document.addEventListener(&#039;drag&#039;, onGlobalDrag);
    document.addEventListener(&#039;dragend&#039;, onGlobalDragEnd);
    return () =&gt; {
      document.removeEventListener(&#039;drag&#039;, onGlobalDrag);
      document.removeEventListener(&#039;dragend&#039;, onGlobalDragEnd);
    };
  }, []);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(cover, {
    className: dist_clsx(&#039;block-editor-grid-visualizer&#039;, {
      &#039;is-dropping-allowed&#039;: isDroppingAllowed
    }),
    clientId: gridClientId,
    __unstablePopoverSlot: &quot;__unstable-block-tools-after&quot;,
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
      ref: ref,
      className: &quot;block-editor-grid-visualizer__grid&quot;,
      style: gridInfo.style,
      children: isManualGrid ? /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ManualGridVisualizer, {
        gridClientId: gridClientId,
        gridInfo: gridInfo
      }) : Array.from({
        length: gridInfo.numItems
      }, (_, i) =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(GridVisualizerCell, {
        color: gridInfo.currentColor
      }, i))
    })
  });
});
function ManualGridVisualizer({
  gridClientId,
  gridInfo
}) {
  const [highlightedRect, setHighlightedRect] = (0,external_wp_element_namespaceObject.useState)(null);
  const gridItemStyles = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      getBlockOrder,
      getBlockStyles
    } = unlock(select(store));
    const blockOrder = getBlockOrder(gridClientId);
    return getBlockStyles(blockOrder);
  }, [gridClientId]);
  const occupiedRects = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; {
    const rects = [];
    for (const style of Object.values(gridItemStyles)) {
      var _style$layout;
      const {
        columnStart,
        rowStart,
        columnSpan = 1,
        rowSpan = 1
      } = (_style$layout = style?.layout) !== null &amp;&amp; _style$layout !== void 0 ? _style$layout : {};
      if (!columnStart || !rowStart) {
        continue;
      }
      rects.push(new GridRect({
        columnStart,
        rowStart,
        columnSpan,
        rowSpan
      }));
    }
    return rects;
  }, [gridItemStyles]);
  return range(1, gridInfo.numRows).map(row =&gt; range(1, gridInfo.numColumns).map(column =&gt; {
    var _highlightedRect$cont;
    const isCellOccupied = occupiedRects.some(rect =&gt; rect.contains(column, row));
    const isHighlighted = (_highlightedRect$cont = highlightedRect?.contains(column, row)) !== null &amp;&amp; _highlightedRect$cont !== void 0 ? _highlightedRect$cont : false;
    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(GridVisualizerCell, {
      color: gridInfo.currentColor,
      className: isHighlighted &amp;&amp; &#039;is-highlighted&#039;,
      children: isCellOccupied ? /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(GridVisualizerDropZone, {
        column: column,
        row: row,
        gridClientId: gridClientId,
        gridInfo: gridInfo,
        setHighlightedRect: setHighlightedRect
      }) : /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(GridVisualizerAppender, {
        column: column,
        row: row,
        gridClientId: gridClientId,
        gridInfo: gridInfo,
        setHighlightedRect: setHighlightedRect
      })
    }, `${row}-${column}`);
  }));
}
function GridVisualizerCell({
  color,
  children,
  className
}) {
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
    className: dist_clsx(&#039;block-editor-grid-visualizer__cell&#039;, className),
    style: {
      boxShadow: `inset 0 0 0 1px color-mix(in srgb, ${color} 20%, #0000)`,
      color
    },
    children: children
  });
}
function useGridVisualizerDropZone(column, row, gridClientId, gridInfo, setHighlightedRect) {
  const {
    getBlockAttributes,
    getBlockRootClientId,
    canInsertBlockType,
    getBlockName
  } = (0,external_wp_data_namespaceObject.useSelect)(store);
  const {
    updateBlockAttributes,
    moveBlocksToPosition,
    __unstableMarkNextChangeAsNotPersistent
  } = (0,external_wp_data_namespaceObject.useDispatch)(store);
  const getNumberOfBlocksBeforeCell = useGetNumberOfBlocksBeforeCell(gridClientId, gridInfo.numColumns);
  return useDropZoneWithValidation({
    validateDrag(srcClientId) {
      const blockName = getBlockName(srcClientId);
      if (!canInsertBlockType(blockName, gridClientId)) {
        return false;
      }
      const attributes = getBlockAttributes(srcClientId);
      const rect = new GridRect({
        columnStart: column,
        rowStart: row,
        columnSpan: attributes.style?.layout?.columnSpan,
        rowSpan: attributes.style?.layout?.rowSpan
      });
      const isInBounds = new GridRect({
        columnSpan: gridInfo.numColumns,
        rowSpan: gridInfo.numRows
      }).containsRect(rect);
      return isInBounds;
    },
    onDragEnter(srcClientId) {
      const attributes = getBlockAttributes(srcClientId);
      setHighlightedRect(new GridRect({
        columnStart: column,
        rowStart: row,
        columnSpan: attributes.style?.layout?.columnSpan,
        rowSpan: attributes.style?.layout?.rowSpan
      }));
    },
    onDragLeave() {
      // onDragEnter can be called before onDragLeave if the user moves
      // their mouse quickly, so only clear the highlight if it was set
      // by this cell.
      setHighlightedRect(prevHighlightedRect =&gt; prevHighlightedRect?.columnStart === column &amp;&amp; prevHighlightedRect?.rowStart === row ? null : prevHighlightedRect);
    },
    onDrop(srcClientId) {
      setHighlightedRect(null);
      const attributes = getBlockAttributes(srcClientId);
      updateBlockAttributes(srcClientId, {
        style: {
          ...attributes.style,
          layout: {
            ...attributes.style?.layout,
            columnStart: column,
            rowStart: row
          }
        }
      });
      __unstableMarkNextChangeAsNotPersistent();
      moveBlocksToPosition([srcClientId], getBlockRootClientId(srcClientId), gridClientId, getNumberOfBlocksBeforeCell(column, row));
    }
  });
}
function GridVisualizerDropZone({
  column,
  row,
  gridClientId,
  gridInfo,
  setHighlightedRect
}) {
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
    className: &quot;block-editor-grid-visualizer__drop-zone&quot;,
    ref: useGridVisualizerDropZone(column, row, gridClientId, gridInfo, setHighlightedRect)
  });
}
function GridVisualizerAppender({
  column,
  row,
  gridClientId,
  gridInfo,
  setHighlightedRect
}) {
  const {
    updateBlockAttributes,
    moveBlocksToPosition,
    __unstableMarkNextChangeAsNotPersistent
  } = (0,external_wp_data_namespaceObject.useDispatch)(store);
  const getNumberOfBlocksBeforeCell = useGetNumberOfBlocksBeforeCell(gridClientId, gridInfo.numColumns);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(button_block_appender, {
    rootClientId: gridClientId,
    className: &quot;block-editor-grid-visualizer__appender&quot;,
    ref: useGridVisualizerDropZone(column, row, gridClientId, gridInfo, setHighlightedRect),
    style: {
      color: gridInfo.currentColor
    },
    onSelect: block =&gt; {
      if (!block) {
        return;
      }
      updateBlockAttributes(block.clientId, {
        style: {
          layout: {
            columnStart: column,
            rowStart: row
          }
        }
      });
      __unstableMarkNextChangeAsNotPersistent();
      moveBlocksToPosition([block.clientId], gridClientId, gridClientId, getNumberOfBlocksBeforeCell(column, row));
    }
  });
}
function useDropZoneWithValidation({
  validateDrag,
  onDragEnter,
  onDragLeave,
  onDrop
}) {
  const {
    getDraggedBlockClientIds
  } = (0,external_wp_data_namespaceObject.useSelect)(store);
  return (0,external_wp_compose_namespaceObject.__experimentalUseDropZone)({
    onDragEnter() {
      const [srcClientId] = getDraggedBlockClientIds();
      if (srcClientId &amp;&amp; validateDrag(srcClientId)) {
        onDragEnter(srcClientId);
      }
    },
    onDragLeave() {
      onDragLeave();
    },
    onDrop() {
      const [srcClientId] = getDraggedBlockClientIds();
      if (srcClientId &amp;&amp; validateDrag(srcClientId)) {
        onDrop(srcClientId);
      }
    }
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/grid/grid-item-resizer.js
/**
 * WordPress dependencies
 */



/**
 * Internal dependencies
 */




function GridItemResizer({
  clientId,
  bounds,
  onChange,
  parentLayout
}) {
  const blockElement = useBlockElement(clientId);
  const rootBlockElement = blockElement?.parentElement;
  const {
    isManualPlacement
  } = parentLayout;
  if (!blockElement || !rootBlockElement) {
    return null;
  }
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(GridItemResizerInner, {
    clientId: clientId,
    bounds: bounds,
    blockElement: blockElement,
    rootBlockElement: rootBlockElement,
    onChange: onChange,
    isManualGrid: isManualPlacement &amp;&amp; window.__experimentalEnableGridInteractivity
  });
}
function GridItemResizerInner({
  clientId,
  bounds,
  blockElement,
  rootBlockElement,
  onChange,
  isManualGrid
}) {
  const [resizeDirection, setResizeDirection] = (0,external_wp_element_namespaceObject.useState)(null);
  const [enableSide, setEnableSide] = (0,external_wp_element_namespaceObject.useState)({
    top: false,
    bottom: false,
    left: false,
    right: false
  });
  (0,external_wp_element_namespaceObject.useEffect)(() =&gt; {
    const observer = new window.ResizeObserver(() =&gt; {
      const blockClientRect = blockElement.getBoundingClientRect();
      const rootBlockClientRect = rootBlockElement.getBoundingClientRect();
      setEnableSide({
        top: blockClientRect.top &gt; rootBlockClientRect.top,
        bottom: blockClientRect.bottom &lt; rootBlockClientRect.bottom,
        left: blockClientRect.left &gt; rootBlockClientRect.left,
        right: blockClientRect.right &lt; rootBlockClientRect.right
      });
    });
    observer.observe(blockElement);
    return () =&gt; observer.disconnect();
  }, [blockElement, rootBlockElement]);
  const justification = {
    right: &#039;left&#039;,
    left: &#039;right&#039;
  };
  const alignment = {
    top: &#039;flex-end&#039;,
    bottom: &#039;flex-start&#039;
  };
  const styles = {
    display: &#039;flex&#039;,
    justifyContent: &#039;center&#039;,
    alignItems: &#039;center&#039;,
    ...(justification[resizeDirection] &amp;&amp; {
      justifyContent: justification[resizeDirection]
    }),
    ...(alignment[resizeDirection] &amp;&amp; {
      alignItems: alignment[resizeDirection]
    })
  };
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(cover, {
    className: &quot;block-editor-grid-item-resizer&quot;,
    clientId: clientId,
    __unstablePopoverSlot: &quot;__unstable-block-tools-after&quot;,
    additionalStyles: styles,
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ResizableBox, {
      className: &quot;block-editor-grid-item-resizer__box&quot;,
      size: {
        width: &#039;100%&#039;,
        height: &#039;100%&#039;
      },
      enable: {
        bottom: enableSide.bottom,
        bottomLeft: false,
        bottomRight: false,
        left: enableSide.left,
        right: enableSide.right,
        top: enableSide.top,
        topLeft: false,
        topRight: false
      },
      bounds: bounds,
      boundsByDirection: true,
      onPointerDown: ({
        target,
        pointerId
      }) =&gt; {
        /*
         * Captures the pointer to avoid hiccups while dragging over objects
         * like iframes and ensures that the event to end the drag is
         * captured by the target (resize handle) whether or not it’s under
         * the pointer.
         */
        target.setPointerCapture(pointerId);
      },
      onResizeStart: (event, direction) =&gt; {
        /*
         * The container justification and alignment need to be set
         * according to the direction the resizer is being dragged in,
         * so that it resizes in the right direction.
         */
        setResizeDirection(direction);
      },
      onResizeStop: (event, direction, boxElement) =&gt; {
        const columnGap = parseFloat(utils_getComputedCSS(rootBlockElement, &#039;column-gap&#039;));
        const rowGap = parseFloat(utils_getComputedCSS(rootBlockElement, &#039;row-gap&#039;));
        const gridColumnTracks = getGridTracks(utils_getComputedCSS(rootBlockElement, &#039;grid-template-columns&#039;), columnGap);
        const gridRowTracks = getGridTracks(utils_getComputedCSS(rootBlockElement, &#039;grid-template-rows&#039;), rowGap);
        const rect = new window.DOMRect(blockElement.offsetLeft + boxElement.offsetLeft, blockElement.offsetTop + boxElement.offsetTop, boxElement.offsetWidth, boxElement.offsetHeight);
        const columnStart = getClosestTrack(gridColumnTracks, rect.left) + 1;
        const rowStart = getClosestTrack(gridRowTracks, rect.top) + 1;
        const columnEnd = getClosestTrack(gridColumnTracks, rect.right, &#039;end&#039;) + 1;
        const rowEnd = getClosestTrack(gridRowTracks, rect.bottom, &#039;end&#039;) + 1;
        onChange({
          columnSpan: columnEnd - columnStart + 1,
          rowSpan: rowEnd - rowStart + 1,
          columnStart: isManualGrid ? columnStart : undefined,
          rowStart: isManualGrid ? rowStart : undefined
        });
      }
    })
  });
}

;// ./node_modules/@wordpress/icons/build-module/library/chevron-up.js
/**
 * WordPress dependencies
 */


const chevronUp = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  viewBox: &quot;0 0 24 24&quot;,
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;M6.5 12.4L12 8l5.5 4.4-.9 1.2L12 10l-4.5 3.6-1-1.2z&quot;
  })
});
/* harmony default export */ const chevron_up = (chevronUp);

;// ./node_modules/@wordpress/icons/build-module/library/chevron-down.js
/**
 * WordPress dependencies
 */


const chevronDown = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  viewBox: &quot;0 0 24 24&quot;,
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;M17.5 11.6L12 16l-5.5-4.4.9-1.2L12 14l4.5-3.6 1 1.2z&quot;
  })
});
/* harmony default export */ const chevron_down = (chevronDown);

;// ./node_modules/@wordpress/block-editor/build-module/components/grid/grid-item-movers.js
/**
 * External dependencies
 */


/**
 * WordPress dependencies
 */






/**
 * Internal dependencies
 */




function GridItemMovers({
  layout,
  parentLayout,
  onChange,
  gridClientId,
  blockClientId
}) {
  var _layout$columnStart, _layout$rowStart, _layout$columnSpan, _layout$rowSpan;
  const {
    moveBlocksToPosition,
    __unstableMarkNextChangeAsNotPersistent
  } = (0,external_wp_data_namespaceObject.useDispatch)(store);
  const columnStart = (_layout$columnStart = layout?.columnStart) !== null &amp;&amp; _layout$columnStart !== void 0 ? _layout$columnStart : 1;
  const rowStart = (_layout$rowStart = layout?.rowStart) !== null &amp;&amp; _layout$rowStart !== void 0 ? _layout$rowStart : 1;
  const columnSpan = (_layout$columnSpan = layout?.columnSpan) !== null &amp;&amp; _layout$columnSpan !== void 0 ? _layout$columnSpan : 1;
  const rowSpan = (_layout$rowSpan = layout?.rowSpan) !== null &amp;&amp; _layout$rowSpan !== void 0 ? _layout$rowSpan : 1;
  const columnEnd = columnStart + columnSpan - 1;
  const rowEnd = rowStart + rowSpan - 1;
  const columnCount = parentLayout?.columnCount;
  const rowCount = parentLayout?.rowCount;
  const getNumberOfBlocksBeforeCell = useGetNumberOfBlocksBeforeCell(gridClientId, columnCount);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_controls, {
    group: &quot;parent&quot;,
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.ToolbarGroup, {
      className: &quot;block-editor-grid-item-mover__move-button-container&quot;,
      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
        className: &quot;block-editor-grid-item-mover__move-horizontal-button-container is-left&quot;,
        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(GridItemMover, {
          icon: (0,external_wp_i18n_namespaceObject.isRTL)() ? chevron_right : chevron_left,
          label: (0,external_wp_i18n_namespaceObject.__)(&#039;Move left&#039;),
          description: (0,external_wp_i18n_namespaceObject.__)(&#039;Move left&#039;),
          isDisabled: columnStart &lt;= 1,
          onClick: () =&gt; {
            onChange({
              columnStart: columnStart - 1
            });
            __unstableMarkNextChangeAsNotPersistent();
            moveBlocksToPosition([blockClientId], gridClientId, gridClientId, getNumberOfBlocksBeforeCell(columnStart - 1, rowStart));
          }
        })
      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;div&quot;, {
        className: &quot;block-editor-grid-item-mover__move-vertical-button-container&quot;,
        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(GridItemMover, {
          className: &quot;is-up-button&quot;,
          icon: chevron_up,
          label: (0,external_wp_i18n_namespaceObject.__)(&#039;Move up&#039;),
          description: (0,external_wp_i18n_namespaceObject.__)(&#039;Move up&#039;),
          isDisabled: rowStart &lt;= 1,
          onClick: () =&gt; {
            onChange({
              rowStart: rowStart - 1
            });
            __unstableMarkNextChangeAsNotPersistent();
            moveBlocksToPosition([blockClientId], gridClientId, gridClientId, getNumberOfBlocksBeforeCell(columnStart, rowStart - 1));
          }
        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(GridItemMover, {
          className: &quot;is-down-button&quot;,
          icon: chevron_down,
          label: (0,external_wp_i18n_namespaceObject.__)(&#039;Move down&#039;),
          description: (0,external_wp_i18n_namespaceObject.__)(&#039;Move down&#039;),
          isDisabled: rowCount &amp;&amp; rowEnd &gt;= rowCount,
          onClick: () =&gt; {
            onChange({
              rowStart: rowStart + 1
            });
            __unstableMarkNextChangeAsNotPersistent();
            moveBlocksToPosition([blockClientId], gridClientId, gridClientId, getNumberOfBlocksBeforeCell(columnStart, rowStart + 1));
          }
        })]
      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
        className: &quot;block-editor-grid-item-mover__move-horizontal-button-container is-right&quot;,
        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(GridItemMover, {
          icon: (0,external_wp_i18n_namespaceObject.isRTL)() ? chevron_left : chevron_right,
          label: (0,external_wp_i18n_namespaceObject.__)(&#039;Move right&#039;),
          description: (0,external_wp_i18n_namespaceObject.__)(&#039;Move right&#039;),
          isDisabled: columnCount &amp;&amp; columnEnd &gt;= columnCount,
          onClick: () =&gt; {
            onChange({
              columnStart: columnStart + 1
            });
            __unstableMarkNextChangeAsNotPersistent();
            moveBlocksToPosition([blockClientId], gridClientId, gridClientId, getNumberOfBlocksBeforeCell(columnStart + 1, rowStart));
          }
        })
      })]
    })
  });
}
function GridItemMover({
  className,
  icon,
  label,
  isDisabled,
  onClick,
  description
}) {
  const instanceId = (0,external_wp_compose_namespaceObject.useInstanceId)(GridItemMover);
  const descriptionId = `block-editor-grid-item-mover-button__description-${instanceId}`;
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarButton, {
      className: dist_clsx(&#039;block-editor-grid-item-mover-button&#039;, className),
      icon: icon,
      label: label,
      &quot;aria-describedby&quot;: descriptionId,
      onClick: isDisabled ? null : onClick,
      disabled: isDisabled,
      accessibleWhenDisabled: true
    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.VisuallyHidden, {
      id: descriptionId,
      children: description
    })]
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/hooks/layout-child.js
/**
 * WordPress dependencies
 */




/**
 * Internal dependencies
 */





// Used for generating the instance ID

const LAYOUT_CHILD_BLOCK_PROPS_REFERENCE = {};
function useBlockPropsChildLayoutStyles({
  style
}) {
  var _style$layout;
  const shouldRenderChildLayoutStyles = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    return !select(store).getSettings().disableLayoutStyles;
  });
  const layout = (_style$layout = style?.layout) !== null &amp;&amp; _style$layout !== void 0 ? _style$layout : {};
  const {
    selfStretch,
    flexSize,
    columnStart,
    rowStart,
    columnSpan,
    rowSpan
  } = layout;
  const parentLayout = useLayout() || {};
  const {
    columnCount,
    minimumColumnWidth
  } = parentLayout;
  const id = (0,external_wp_compose_namespaceObject.useInstanceId)(LAYOUT_CHILD_BLOCK_PROPS_REFERENCE);
  const selector = `.wp-container-content-${id}`;

  // Check that the grid layout attributes are of the correct type, so that we don&#039;t accidentally
  // write code that stores a string attribute instead of a number.
  if (false) {}
  let css = &#039;&#039;;
  if (shouldRenderChildLayoutStyles) {
    if (selfStretch === &#039;fixed&#039; &amp;&amp; flexSize) {
      css = `${selector} {
				flex-basis: ${flexSize};
				box-sizing: border-box;
			}`;
    } else if (selfStretch === &#039;fill&#039;) {
      css = `${selector} {
				flex-grow: 1;
			}`;
    } else if (columnStart &amp;&amp; columnSpan) {
      css = `${selector} {
				grid-column: ${columnStart} / span ${columnSpan};
			}`;
    } else if (columnStart) {
      css = `${selector} {
				grid-column: ${columnStart};
			}`;
    } else if (columnSpan) {
      css = `${selector} {
				grid-column: span ${columnSpan};
			}`;
    }
    if (rowStart &amp;&amp; rowSpan) {
      css += `${selector} {
				grid-row: ${rowStart} / span ${rowSpan};
			}`;
    } else if (rowStart) {
      css += `${selector} {
				grid-row: ${rowStart};
			}`;
    } else if (rowSpan) {
      css += `${selector} {
				grid-row: span ${rowSpan};
			}`;
    }
    /**
     * If minimumColumnWidth is set on the parent, or if no
     * columnCount is set, the grid is responsive so a
     * container query is needed for the span to resize.
     */
    if ((columnSpan || columnStart) &amp;&amp; (minimumColumnWidth || !columnCount)) {
      let parentColumnValue = parseFloat(minimumColumnWidth);
      /**
       * 12rem is the default minimumColumnWidth value.
       * If parentColumnValue is not a number, default to 12.
       */
      if (isNaN(parentColumnValue)) {
        parentColumnValue = 12;
      }
      let parentColumnUnit = minimumColumnWidth?.replace(parentColumnValue, &#039;&#039;);
      /**
       * Check that parent column unit is either &#039;px&#039;, &#039;rem&#039; or &#039;em&#039;.
       * If not, default to &#039;rem&#039;.
       */
      if (![&#039;px&#039;, &#039;rem&#039;, &#039;em&#039;].includes(parentColumnUnit)) {
        parentColumnUnit = &#039;rem&#039;;
      }
      let numColsToBreakAt = 2;
      if (columnSpan &amp;&amp; columnStart) {
        numColsToBreakAt = columnSpan + columnStart - 1;
      } else if (columnSpan) {
        numColsToBreakAt = columnSpan;
      } else {
        numColsToBreakAt = columnStart;
      }
      const defaultGapValue = parentColumnUnit === &#039;px&#039; ? 24 : 1.5;
      const containerQueryValue = numColsToBreakAt * parentColumnValue + (numColsToBreakAt - 1) * defaultGapValue;
      // For blocks that only span one column, we want to remove any rowStart values as
      // the container reduces in size, so that blocks are still arranged in markup order.
      const minimumContainerQueryValue = parentColumnValue * 2 + defaultGapValue - 1;
      // If a span is set we want to preserve it as long as possible, otherwise we just reset the value.
      const gridColumnValue = columnSpan &amp;&amp; columnSpan &gt; 1 ? &#039;1/-1&#039; : &#039;auto&#039;;
      css += `@container (max-width: ${Math.max(containerQueryValue, minimumContainerQueryValue)}${parentColumnUnit}) {
				${selector} {
					grid-column: ${gridColumnValue};
					grid-row: auto;
				}
			}`;
    }
  }
  useStyleOverride({
    css
  });

  // Only attach a container class if there is generated CSS to be attached.
  if (!css) {
    return;
  }

  // Attach a `wp-container-content` id-based classname.
  return {
    className: `wp-container-content-${id}`
  };
}
function ChildLayoutControlsPure({
  clientId,
  style,
  setAttributes
}) {
  const parentLayout = useLayout() || {};
  const {
    type: parentLayoutType = &#039;default&#039;,
    allowSizingOnChildren = false,
    isManualPlacement
  } = parentLayout;
  if (parentLayoutType !== &#039;grid&#039;) {
    return null;
  }
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(GridTools, {
    clientId: clientId,
    style: style,
    setAttributes: setAttributes,
    allowSizingOnChildren: allowSizingOnChildren,
    isManualPlacement: isManualPlacement,
    parentLayout: parentLayout
  });
}
function GridTools({
  clientId,
  style,
  setAttributes,
  allowSizingOnChildren,
  isManualPlacement,
  parentLayout
}) {
  const {
    rootClientId,
    isVisible
  } = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      getBlockRootClientId,
      getBlockEditingMode,
      getTemplateLock
    } = select(store);
    const _rootClientId = getBlockRootClientId(clientId);
    if (getTemplateLock(_rootClientId) || getBlockEditingMode(_rootClientId) !== &#039;default&#039;) {
      return {
        rootClientId: _rootClientId,
        isVisible: false
      };
    }
    return {
      rootClientId: _rootClientId,
      isVisible: true
    };
  }, [clientId]);

  // Use useState() instead of useRef() so that GridItemResizer updates when ref is set.
  const [resizerBounds, setResizerBounds] = (0,external_wp_element_namespaceObject.useState)();
  if (!isVisible) {
    return null;
  }
  function updateLayout(layout) {
    setAttributes({
      style: {
        ...style,
        layout: {
          ...style?.layout,
          ...layout
        }
      }
    });
  }
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(GridVisualizer, {
      clientId: rootClientId,
      contentRef: setResizerBounds,
      parentLayout: parentLayout
    }), allowSizingOnChildren &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(GridItemResizer, {
      clientId: clientId
      // Don&#039;t allow resizing beyond the grid visualizer.
      ,
      bounds: resizerBounds,
      onChange: updateLayout,
      parentLayout: parentLayout
    }), isManualPlacement &amp;&amp; window.__experimentalEnableGridInteractivity &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(GridItemMovers, {
      layout: style?.layout,
      parentLayout: parentLayout,
      onChange: updateLayout,
      gridClientId: rootClientId,
      blockClientId: clientId
    })]
  });
}
/* harmony default export */ const layout_child = ({
  useBlockProps: useBlockPropsChildLayoutStyles,
  edit: ChildLayoutControlsPure,
  attributeKeys: [&#039;style&#039;],
  hasSupport() {
    return true;
  }
});

;// ./node_modules/@wordpress/block-editor/build-module/hooks/content-lock-ui.js
/**
 * WordPress dependencies
 */





/**
 * Internal dependencies
 */




// The implementation of content locking is mainly in this file, although the mechanism
// to stop temporarily editing as blocks when an outside block is selected is on component StopEditingAsBlocksOnOutsideSelect
// at block-editor/src/components/block-list/index.js.
// Besides the components on this file and the file referenced above the implementation
// also includes artifacts on the store (actions, reducers, and selector).

function ContentLockControlsPure({
  clientId
}) {
  const {
    templateLock,
    isLockedByParent,
    isEditingAsBlocks
  } = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      getContentLockingParent,
      getTemplateLock,
      getTemporarilyEditingAsBlocks
    } = unlock(select(store));
    return {
      templateLock: getTemplateLock(clientId),
      isLockedByParent: !!getContentLockingParent(clientId),
      isEditingAsBlocks: getTemporarilyEditingAsBlocks() === clientId
    };
  }, [clientId]);
  const {
    stopEditingAsBlocks
  } = unlock((0,external_wp_data_namespaceObject.useDispatch)(store));
  const isContentLocked = !isLockedByParent &amp;&amp; templateLock === &#039;contentOnly&#039;;
  const stopEditingAsBlockCallback = (0,external_wp_element_namespaceObject.useCallback)(() =&gt; {
    stopEditingAsBlocks(clientId);
  }, [clientId, stopEditingAsBlocks]);
  if (!isContentLocked &amp;&amp; !isEditingAsBlocks) {
    return null;
  }
  const showStopEditingAsBlocks = isEditingAsBlocks &amp;&amp; !isContentLocked;
  return showStopEditingAsBlocks &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_controls, {
    group: &quot;other&quot;,
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarButton, {
      onClick: stopEditingAsBlockCallback,
      children: (0,external_wp_i18n_namespaceObject.__)(&#039;Done&#039;)
    })
  });
}
/* harmony default export */ const content_lock_ui = ({
  edit: ContentLockControlsPure,
  hasSupport() {
    return true;
  }
});

;// ./node_modules/@wordpress/block-editor/build-module/hooks/metadata.js
/**
 * WordPress dependencies
 */

const META_ATTRIBUTE_NAME = &#039;metadata&#039;;

/**
 * Filters registered block settings, extending attributes to include `metadata`.
 *
 * see: https://github.com/WordPress/gutenberg/pull/40393/files#r864632012
 *
 * @param {Object} blockTypeSettings Original block settings.
 * @return {Object} Filtered block settings.
 */
function addMetaAttribute(blockTypeSettings) {
  // Allow blocks to specify their own attribute definition with default values if needed.
  if (blockTypeSettings?.attributes?.[META_ATTRIBUTE_NAME]?.type) {
    return blockTypeSettings;
  }
  blockTypeSettings.attributes = {
    ...blockTypeSettings.attributes,
    [META_ATTRIBUTE_NAME]: {
      type: &#039;object&#039;
    }
  };
  return blockTypeSettings;
}
(0,external_wp_hooks_namespaceObject.addFilter)(&#039;blocks.registerBlockType&#039;, &#039;core/metadata/addMetaAttribute&#039;, addMetaAttribute);

;// ./node_modules/@wordpress/block-editor/build-module/hooks/block-hooks.js
/**
 * WordPress dependencies
 */






/**
 * Internal dependencies
 */



const block_hooks_EMPTY_OBJECT = {};
function BlockHooksControlPure({
  name,
  clientId,
  metadata: {
    ignoredHookedBlocks = []
  } = {}
}) {
  const blockTypes = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; select(external_wp_blocks_namespaceObject.store).getBlockTypes(), []);

  // A hooked block added via a filter will not be exposed through a block
  // type&#039;s `blockHooks` property; however, if the containing layout has been
  // modified, it will be present in the anchor block&#039;s `ignoredHookedBlocks`
  // metadata.
  const hookedBlocksForCurrentBlock = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; blockTypes?.filter(({
    name: blockName,
    blockHooks
  }) =&gt; blockHooks &amp;&amp; name in blockHooks || ignoredHookedBlocks.includes(blockName)), [blockTypes, name, ignoredHookedBlocks]);
  const hookedBlockClientIds = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      getBlocks,
      getBlockRootClientId,
      getGlobalBlockCount
    } = select(store);
    const rootClientId = getBlockRootClientId(clientId);
    const _hookedBlockClientIds = hookedBlocksForCurrentBlock.reduce((clientIds, block) =&gt; {
      // If the block doesn&#039;t exist anywhere in the block tree,
      // we know that we have to set the toggle to disabled.
      if (getGlobalBlockCount(block.name) === 0) {
        return clientIds;
      }
      const relativePosition = block?.blockHooks?.[name];
      let candidates;
      switch (relativePosition) {
        case &#039;before&#039;:
        case &#039;after&#039;:
          // Any of the current block&#039;s siblings (with the right block type) qualifies
          // as a hooked block (inserted `before` or `after` the current one), as the block
          // might&#039;ve been automatically inserted and then moved around a bit by the user.
          candidates = getBlocks(rootClientId);
          break;
        case &#039;first_child&#039;:
        case &#039;last_child&#039;:
          // Any of the current block&#039;s child blocks (with the right block type) qualifies
          // as a hooked first or last child block, as the block might&#039;ve been automatically
          // inserted and then moved around a bit by the user.
          candidates = getBlocks(clientId);
          break;
        case undefined:
          // If we haven&#039;t found a blockHooks field with a relative position for the hooked
          // block, it means that it was added by a filter. In this case, we look for the block
          // both among the current block&#039;s siblings and its children.
          candidates = [...getBlocks(rootClientId), ...getBlocks(clientId)];
          break;
      }
      const hookedBlock = candidates?.find(candidate =&gt; candidate.name === block.name);

      // If the block exists in the designated location, we consider it hooked
      // and show the toggle as enabled.
      if (hookedBlock) {
        return {
          ...clientIds,
          [block.name]: hookedBlock.clientId
        };
      }

      // If no hooked block was found in any of its designated locations,
      // we set the toggle to disabled.
      return clientIds;
    }, {});
    if (Object.values(_hookedBlockClientIds).length &gt; 0) {
      return _hookedBlockClientIds;
    }
    return block_hooks_EMPTY_OBJECT;
  }, [hookedBlocksForCurrentBlock, name, clientId]);
  const {
    getBlockIndex,
    getBlockCount,
    getBlockRootClientId
  } = (0,external_wp_data_namespaceObject.useSelect)(store);
  const {
    insertBlock,
    removeBlock
  } = (0,external_wp_data_namespaceObject.useDispatch)(store);
  if (!hookedBlocksForCurrentBlock.length) {
    return null;
  }

  // Group by block namespace (i.e. prefix before the slash).
  const groupedHookedBlocks = hookedBlocksForCurrentBlock.reduce((groups, block) =&gt; {
    const [namespace] = block.name.split(&#039;/&#039;);
    if (!groups[namespace]) {
      groups[namespace] = [];
    }
    groups[namespace].push(block);
    return groups;
  }, {});
  const insertBlockIntoDesignatedLocation = (block, relativePosition) =&gt; {
    const blockIndex = getBlockIndex(clientId);
    const innerBlocksLength = getBlockCount(clientId);
    const rootClientId = getBlockRootClientId(clientId);
    switch (relativePosition) {
      case &#039;before&#039;:
      case &#039;after&#039;:
        insertBlock(block, relativePosition === &#039;after&#039; ? blockIndex + 1 : blockIndex, rootClientId,
        // Insert as a child of the current block&#039;s parent
        false);
        break;
      case &#039;first_child&#039;:
      case &#039;last_child&#039;:
        insertBlock(block,
        // TODO: It&#039;d be great if insertBlock() would accept negative indices for insertion.
        relativePosition === &#039;first_child&#039; ? 0 : innerBlocksLength, clientId,
        // Insert as a child of the current block.
        false);
        break;
      case undefined:
        // If we do not know the relative position, it is because the block was
        // added via a filter. In this case, we default to inserting it after the
        // current block.
        insertBlock(block, blockIndex + 1, rootClientId,
        // Insert as a child of the current block&#039;s parent
        false);
        break;
    }
  };
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls, {
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.PanelBody, {
      className: &quot;block-editor-hooks__block-hooks&quot;,
      title: (0,external_wp_i18n_namespaceObject.__)(&#039;Plugins&#039;),
      initialOpen: true,
      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;p&quot;, {
        className: &quot;block-editor-hooks__block-hooks-helptext&quot;,
        children: (0,external_wp_i18n_namespaceObject.__)(&#039;Manage the inclusion of blocks added automatically by plugins.&#039;)
      }), Object.keys(groupedHookedBlocks).map(vendor =&gt; {
        return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_element_namespaceObject.Fragment, {
          children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;h3&quot;, {
            children: vendor
          }), groupedHookedBlocks[vendor].map(block =&gt; {
            const checked = block.name in hookedBlockClientIds;
            return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToggleControl, {
              __nextHasNoMarginBottom: true,
              checked: checked,
              label: block.title,
              onChange: () =&gt; {
                if (!checked) {
                  // Create and insert block.
                  const relativePosition = block.blockHooks[name];
                  insertBlockIntoDesignatedLocation((0,external_wp_blocks_namespaceObject.createBlock)(block.name), relativePosition);
                  return;
                }

                // Remove block.
                removeBlock(hookedBlockClientIds[block.name], false);
              }
            }, block.title);
          })]
        }, vendor);
      })]
    })
  });
}
/* harmony default export */ const block_hooks = ({
  edit: BlockHooksControlPure,
  attributeKeys: [&#039;metadata&#039;],
  hasSupport() {
    return true;
  }
});

;// ./node_modules/@wordpress/block-editor/build-module/hooks/block-bindings.js
/**
 * WordPress dependencies
 */







/**
 * Internal dependencies
 */







const {
  Menu
} = unlock(external_wp_components_namespaceObject.privateApis);
const block_bindings_EMPTY_OBJECT = {};
const block_bindings_useToolsPanelDropdownMenuProps = () =&gt; {
  const isMobile = (0,external_wp_compose_namespaceObject.useViewportMatch)(&#039;medium&#039;, &#039;&lt;&#039;);
  return !isMobile ? {
    popoverProps: {
      placement: &#039;left-start&#039;,
      // For non-mobile, inner sidebar width (248px) - button width (24px) - border (1px) + padding (16px) + spacing (20px)
      offset: 259
    }
  } : {};
};
function BlockBindingsPanelMenuContent({
  fieldsList,
  attribute,
  binding
}) {
  const {
    clientId
  } = useBlockEditContext();
  const registeredSources = (0,external_wp_blocks_namespaceObject.getBlockBindingsSources)();
  const {
    updateBlockBindings
  } = useBlockBindingsUtils();
  const currentKey = binding?.args?.key;
  const attributeType = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      name: blockName
    } = select(store).getBlock(clientId);
    const _attributeType = (0,external_wp_blocks_namespaceObject.getBlockType)(blockName).attributes?.[attribute]?.type;
    return _attributeType === &#039;rich-text&#039; ? &#039;string&#039; : _attributeType;
  }, [clientId, attribute]);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_ReactJSXRuntime_namespaceObject.Fragment, {
    children: Object.entries(fieldsList).map(([name, fields], i) =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_element_namespaceObject.Fragment, {
      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(Menu.Group, {
        children: [Object.keys(fieldsList).length &gt; 1 &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Menu.GroupLabel, {
          children: registeredSources[name].label
        }), Object.entries(fields).filter(([, args]) =&gt; args?.type === attributeType).map(([key, args]) =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(Menu.RadioItem, {
          onChange: () =&gt; updateBlockBindings({
            [attribute]: {
              source: name,
              args: {
                key
              }
            }
          }),
          name: attribute + &#039;-binding&#039;,
          value: key,
          checked: key === currentKey,
          children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Menu.ItemLabel, {
            children: args?.label
          }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Menu.ItemHelpText, {
            children: args?.value
          })]
        }, key))]
      }), i !== Object.keys(fieldsList).length - 1 &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Menu.Separator, {})]
    }, name))
  });
}
function BlockBindingsAttribute({
  attribute,
  binding,
  fieldsList
}) {
  const {
    source: sourceName,
    args
  } = binding || {};
  const sourceProps = (0,external_wp_blocks_namespaceObject.getBlockBindingsSource)(sourceName);
  const isSourceInvalid = !sourceProps;
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalVStack, {
    className: &quot;block-editor-bindings__item&quot;,
    spacing: 0,
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalText, {
      truncate: true,
      children: attribute
    }), !!binding &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalText, {
      truncate: true,
      variant: !isSourceInvalid &amp;&amp; &#039;muted&#039;,
      isDestructive: isSourceInvalid,
      children: isSourceInvalid ? (0,external_wp_i18n_namespaceObject.__)(&#039;Invalid source&#039;) : fieldsList?.[sourceName]?.[args?.key]?.label || sourceProps?.label || sourceName
    })]
  });
}
function ReadOnlyBlockBindingsPanelItems({
  bindings,
  fieldsList
}) {
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_ReactJSXRuntime_namespaceObject.Fragment, {
    children: Object.entries(bindings).map(([attribute, binding]) =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalItem, {
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockBindingsAttribute, {
        attribute: attribute,
        binding: binding,
        fieldsList: fieldsList
      })
    }, attribute))
  });
}
function EditableBlockBindingsPanelItems({
  attributes,
  bindings,
  fieldsList
}) {
  const {
    updateBlockBindings
  } = useBlockBindingsUtils();
  const isMobile = (0,external_wp_compose_namespaceObject.useViewportMatch)(&#039;medium&#039;, &#039;&lt;&#039;);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_ReactJSXRuntime_namespaceObject.Fragment, {
    children: attributes.map(attribute =&gt; {
      const binding = bindings[attribute];
      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanelItem, {
        hasValue: () =&gt; !!binding,
        label: attribute,
        onDeselect: () =&gt; {
          updateBlockBindings({
            [attribute]: undefined
          });
        },
        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(Menu, {
          placement: isMobile ? &#039;bottom-start&#039; : &#039;left-start&#039;,
          children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Menu.TriggerButton, {
            render: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalItem, {}),
            children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockBindingsAttribute, {
              attribute: attribute,
              binding: binding,
              fieldsList: fieldsList
            })
          }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Menu.Popover, {
            gutter: isMobile ? 8 : 36,
            children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockBindingsPanelMenuContent, {
              fieldsList: fieldsList,
              attribute: attribute,
              binding: binding
            })
          })]
        })
      }, attribute);
    })
  });
}
const BlockBindingsPanel = ({
  name: blockName,
  metadata
}) =&gt; {
  const blockContext = (0,external_wp_element_namespaceObject.useContext)(block_context);
  const {
    removeAllBlockBindings
  } = useBlockBindingsUtils();
  const bindableAttributes = getBindableAttributes(blockName);
  const dropdownMenuProps = block_bindings_useToolsPanelDropdownMenuProps();

  // `useSelect` is used purposely here to ensure `getFieldsList`
  // is updated whenever there are updates in block context.
  // `source.getFieldsList` may also call a selector via `select`.
  const _fieldsList = {};
  const {
    fieldsList,
    canUpdateBlockBindings
  } = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    if (!bindableAttributes || bindableAttributes.length === 0) {
      return block_bindings_EMPTY_OBJECT;
    }
    const registeredSources = (0,external_wp_blocks_namespaceObject.getBlockBindingsSources)();
    Object.entries(registeredSources).forEach(([sourceName, {
      getFieldsList,
      usesContext
    }]) =&gt; {
      if (getFieldsList) {
        // Populate context.
        const context = {};
        if (usesContext?.length) {
          for (const key of usesContext) {
            context[key] = blockContext[key];
          }
        }
        const sourceList = getFieldsList({
          select,
          context
        });
        // Only add source if the list is not empty.
        if (Object.keys(sourceList || {}).length) {
          _fieldsList[sourceName] = {
            ...sourceList
          };
        }
      }
    });
    return {
      fieldsList: Object.values(_fieldsList).length &gt; 0 ? _fieldsList : block_bindings_EMPTY_OBJECT,
      canUpdateBlockBindings: select(store).getSettings().canUpdateBlockBindings
    };
  }, [blockContext, bindableAttributes]);
  // Return early if there are no bindable attributes.
  if (!bindableAttributes || bindableAttributes.length === 0) {
    return null;
  }
  // Filter bindings to only show bindable attributes and remove pattern overrides.
  const {
    bindings
  } = metadata || {};
  const filteredBindings = {
    ...bindings
  };
  Object.keys(filteredBindings).forEach(key =&gt; {
    if (!canBindAttribute(blockName, key) || filteredBindings[key].source === &#039;core/pattern-overrides&#039;) {
      delete filteredBindings[key];
    }
  });

  // Lock the UI when the user can&#039;t update bindings or there are no fields to connect to.
  const readOnly = !canUpdateBlockBindings || !Object.keys(fieldsList).length;
  if (readOnly &amp;&amp; Object.keys(filteredBindings).length === 0) {
    return null;
  }
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls, {
    group: &quot;bindings&quot;,
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalToolsPanel, {
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Attributes&#039;),
      resetAll: () =&gt; {
        removeAllBlockBindings();
      },
      dropdownMenuProps: dropdownMenuProps,
      className: &quot;block-editor-bindings__panel&quot;,
      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalItemGroup, {
        isBordered: true,
        isSeparated: true,
        children: readOnly ? /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ReadOnlyBlockBindingsPanelItems, {
          bindings: filteredBindings,
          fieldsList: fieldsList
        }) : /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(EditableBlockBindingsPanelItems, {
          attributes: bindableAttributes,
          bindings: filteredBindings,
          fieldsList: fieldsList
        })
      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalText, {
        as: &quot;div&quot;,
        variant: &quot;muted&quot;,
        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;p&quot;, {
          children: (0,external_wp_i18n_namespaceObject.__)(&#039;Attributes connected to custom fields or other dynamic data.&#039;)
        })
      })]
    })
  });
};
/* harmony default export */ const block_bindings = ({
  edit: BlockBindingsPanel,
  attributeKeys: [&#039;metadata&#039;],
  hasSupport() {
    return true;
  }
});

;// ./node_modules/@wordpress/block-editor/build-module/hooks/block-renaming.js
/**
 * WordPress dependencies
 */



/**
 * Filters registered block settings, adding an `__experimentalLabel` callback if one does not already exist.
 *
 * @param {Object} settings Original block settings.
 *
 * @return {Object} Filtered block settings.
 */
function addLabelCallback(settings) {
  // If blocks provide their own label callback, do not override it.
  if (settings.__experimentalLabel) {
    return settings;
  }
  const supportsBlockNaming = (0,external_wp_blocks_namespaceObject.hasBlockSupport)(settings, &#039;renaming&#039;, true // default value
  );

  // Check whether block metadata is supported before using it.
  if (supportsBlockNaming) {
    settings.__experimentalLabel = (attributes, {
      context
    }) =&gt; {
      const {
        metadata
      } = attributes;

      // In the list view, use the block&#039;s name attribute as the label.
      if (context === &#039;list-view&#039; &amp;&amp; metadata?.name) {
        return metadata.name;
      }
    };
  }
  return settings;
}
(0,external_wp_hooks_namespaceObject.addFilter)(&#039;blocks.registerBlockType&#039;, &#039;core/metadata/addLabelCallback&#039;, addLabelCallback);

;// ./node_modules/@wordpress/block-editor/build-module/components/grid/use-grid-layout-sync.js
/**
 * WordPress dependencies
 */




/**
 * Internal dependencies
 */



function useGridLayoutSync({
  clientId: gridClientId
}) {
  const {
    gridLayout,
    blockOrder,
    selectedBlockLayout
  } = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    var _getBlockAttributes$l;
    const {
      getBlockAttributes,
      getBlockOrder
    } = select(store);
    const selectedBlock = select(store).getSelectedBlock();
    return {
      gridLayout: (_getBlockAttributes$l = getBlockAttributes(gridClientId).layout) !== null &amp;&amp; _getBlockAttributes$l !== void 0 ? _getBlockAttributes$l : {},
      blockOrder: getBlockOrder(gridClientId),
      selectedBlockLayout: selectedBlock?.attributes.style?.layout
    };
  }, [gridClientId]);
  const {
    getBlockAttributes,
    getBlockRootClientId
  } = (0,external_wp_data_namespaceObject.useSelect)(store);
  const {
    updateBlockAttributes,
    __unstableMarkNextChangeAsNotPersistent
  } = (0,external_wp_data_namespaceObject.useDispatch)(store);
  const selectedBlockRect = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; selectedBlockLayout ? new GridRect(selectedBlockLayout) : null, [selectedBlockLayout]);
  const previouslySelectedBlockRect = (0,external_wp_compose_namespaceObject.usePrevious)(selectedBlockRect);
  const previousIsManualPlacement = (0,external_wp_compose_namespaceObject.usePrevious)(gridLayout.isManualPlacement);
  const previousBlockOrder = (0,external_wp_compose_namespaceObject.usePrevious)(blockOrder);
  (0,external_wp_element_namespaceObject.useEffect)(() =&gt; {
    const updates = {};
    if (gridLayout.isManualPlacement) {
      const occupiedRects = [];

      // Respect the position of blocks that already have a columnStart and rowStart value.
      for (const clientId of blockOrder) {
        var _getBlockAttributes$s;
        const {
          columnStart,
          rowStart,
          columnSpan = 1,
          rowSpan = 1
        } = (_getBlockAttributes$s = getBlockAttributes(clientId).style?.layout) !== null &amp;&amp; _getBlockAttributes$s !== void 0 ? _getBlockAttributes$s : {};
        if (!columnStart || !rowStart) {
          continue;
        }
        occupiedRects.push(new GridRect({
          columnStart,
          rowStart,
          columnSpan,
          rowSpan
        }));
      }

      // When in manual mode, ensure that every block has a columnStart and rowStart value.
      for (const clientId of blockOrder) {
        var _attributes$style$lay;
        const attributes = getBlockAttributes(clientId);
        const {
          columnStart,
          rowStart,
          columnSpan = 1,
          rowSpan = 1
        } = (_attributes$style$lay = attributes.style?.layout) !== null &amp;&amp; _attributes$style$lay !== void 0 ? _attributes$style$lay : {};
        if (columnStart &amp;&amp; rowStart) {
          continue;
        }
        const [newColumnStart, newRowStart] = placeBlock(occupiedRects, gridLayout.columnCount, columnSpan, rowSpan, previouslySelectedBlockRect?.columnEnd, previouslySelectedBlockRect?.rowEnd);
        occupiedRects.push(new GridRect({
          columnStart: newColumnStart,
          rowStart: newRowStart,
          columnSpan,
          rowSpan
        }));
        updates[clientId] = {
          style: {
            ...attributes.style,
            layout: {
              ...attributes.style?.layout,
              columnStart: newColumnStart,
              rowStart: newRowStart
            }
          }
        };
      }

      // Ensure there&#039;s enough rows to fit all blocks.
      const bottomMostRow = Math.max(...occupiedRects.map(r =&gt; r.rowEnd));
      if (!gridLayout.rowCount || gridLayout.rowCount &lt; bottomMostRow) {
        updates[gridClientId] = {
          layout: {
            ...gridLayout,
            rowCount: bottomMostRow
          }
        };
      }

      // Unset grid layout attributes for blocks removed from the grid.
      for (const clientId of previousBlockOrder !== null &amp;&amp; previousBlockOrder !== void 0 ? previousBlockOrder : []) {
        if (!blockOrder.includes(clientId)) {
          var _attributes$style$lay2;
          const rootClientId = getBlockRootClientId(clientId);

          // Block was removed from the editor, so nothing to do.
          if (rootClientId === null) {
            continue;
          }

          // Check if the block is being moved to another grid.
          // If so, do nothing and let the new grid parent handle
          // the attributes.
          const rootAttributes = getBlockAttributes(rootClientId);
          if (rootAttributes?.layout?.type === &#039;grid&#039;) {
            continue;
          }
          const attributes = getBlockAttributes(clientId);
          const {
            columnStart,
            rowStart,
            columnSpan,
            rowSpan,
            ...layout
          } = (_attributes$style$lay2 = attributes.style?.layout) !== null &amp;&amp; _attributes$style$lay2 !== void 0 ? _attributes$style$lay2 : {};
          if (columnStart || rowStart || columnSpan || rowSpan) {
            const hasEmptyLayoutAttribute = Object.keys(layout).length === 0;
            updates[clientId] = setImmutably(attributes, [&#039;style&#039;, &#039;layout&#039;], hasEmptyLayoutAttribute ? undefined : layout);
          }
        }
      }
    } else {
      // Remove all of the columnStart and rowStart values
      // when switching from manual to auto mode,
      if (previousIsManualPlacement === true) {
        for (const clientId of blockOrder) {
          var _attributes$style$lay3;
          const attributes = getBlockAttributes(clientId);
          const {
            columnStart,
            rowStart,
            ...layout
          } = (_attributes$style$lay3 = attributes.style?.layout) !== null &amp;&amp; _attributes$style$lay3 !== void 0 ? _attributes$style$lay3 : {};
          // Only update attributes if columnStart or rowStart are set.
          if (columnStart || rowStart) {
            const hasEmptyLayoutAttribute = Object.keys(layout).length === 0;
            updates[clientId] = setImmutably(attributes, [&#039;style&#039;, &#039;layout&#039;], hasEmptyLayoutAttribute ? undefined : layout);
          }
        }
      }

      // Remove row styles in auto mode
      if (gridLayout.rowCount) {
        updates[gridClientId] = {
          layout: {
            ...gridLayout,
            rowCount: undefined
          }
        };
      }
    }
    if (Object.keys(updates).length) {
      __unstableMarkNextChangeAsNotPersistent();
      updateBlockAttributes(Object.keys(updates), updates, /* uniqueByBlock: */true);
    }
  }, [
  // Actual deps to sync:
  gridClientId, gridLayout, previousBlockOrder, blockOrder, previouslySelectedBlockRect, previousIsManualPlacement,
  // These won&#039;t change, but the linter thinks they might:
  __unstableMarkNextChangeAsNotPersistent, getBlockAttributes, getBlockRootClientId, updateBlockAttributes]);
}

/**
 * @param {GridRect[]} occupiedRects
 * @param {number}     gridColumnCount
 * @param {number}     blockColumnSpan
 * @param {number}     blockRowSpan
 * @param {number?}    startColumn
 * @param {number?}    startRow
 */
function placeBlock(occupiedRects, gridColumnCount, blockColumnSpan, blockRowSpan, startColumn = 1, startRow = 1) {
  for (let row = startRow;; row++) {
    for (let column = row === startRow ? startColumn : 1; column &lt;= gridColumnCount; column++) {
      const candidateRect = new GridRect({
        columnStart: column,
        rowStart: row,
        columnSpan: blockColumnSpan,
        rowSpan: blockRowSpan
      });
      if (!occupiedRects.some(r =&gt; r.intersectsRect(candidateRect))) {
        return [column, row];
      }
    }
  }
}

;// ./node_modules/@wordpress/block-editor/build-module/hooks/grid-visualizer.js
/**
 * WordPress dependencies
 */




/**
 * Internal dependencies
 */



function GridLayoutSync(props) {
  useGridLayoutSync(props);
}
function grid_visualizer_GridTools({
  clientId,
  layout
}) {
  const isVisible = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      isBlockSelected,
      isDraggingBlocks,
      getTemplateLock,
      getBlockEditingMode
    } = select(store);

    // These calls are purposely ordered from least expensive to most expensive.
    // Hides the visualizer in cases where the user is not or cannot interact with it.
    if (!isDraggingBlocks() &amp;&amp; !isBlockSelected(clientId) || getTemplateLock(clientId) || getBlockEditingMode(clientId) !== &#039;default&#039;) {
      return false;
    }
    return true;
  }, [clientId]);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(GridLayoutSync, {
      clientId: clientId
    }), isVisible &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(GridVisualizer, {
      clientId: clientId,
      parentLayout: layout
    })]
  });
}
const addGridVisualizerToBlockEdit = (0,external_wp_compose_namespaceObject.createHigherOrderComponent)(BlockEdit =&gt; props =&gt; {
  if (props.attributes.layout?.type !== &#039;grid&#039;) {
    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockEdit, {
      ...props
    }, &quot;edit&quot;);
  }
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(grid_visualizer_GridTools, {
      clientId: props.clientId,
      layout: props.attributes.layout
    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockEdit, {
      ...props
    }, &quot;edit&quot;)]
  });
}, &#039;addGridVisualizerToBlockEdit&#039;);
(0,external_wp_hooks_namespaceObject.addFilter)(&#039;editor.BlockEdit&#039;, &#039;core/editor/grid-visualizer&#039;, addGridVisualizerToBlockEdit);

;// ./node_modules/@wordpress/block-editor/build-module/hooks/use-border-props.js
/**
 * Internal dependencies
 */




// This utility is intended to assist where the serialization of the border
// block support is being skipped for a block but the border related CSS classes
// &amp; styles still need to be generated so they can be applied to inner elements.

/**
 * Provides the CSS class names and inline styles for a block&#039;s border support
 * attributes.
 *
 * @param {Object} attributes Block attributes.
 * @return {Object} Border block support derived CSS classes &amp; styles.
 */
function getBorderClassesAndStyles(attributes) {
  const border = attributes.style?.border || {};
  const className = getBorderClasses(attributes);
  return {
    className: className || undefined,
    style: getInlineStyles({
      border
    })
  };
}

/**
 * Derives the border related props for a block from its border block support
 * attributes.
 *
 * Inline styles are forced for named colors to ensure these selections are
 * reflected when themes do not load their color stylesheets in the editor.
 *
 * @param {Object} attributes Block attributes.
 *
 * @return {Object} ClassName &amp; style props from border block support.
 */
function useBorderProps(attributes) {
  const {
    colors
  } = useMultipleOriginColorsAndGradients();
  const borderProps = getBorderClassesAndStyles(attributes);
  const {
    borderColor
  } = attributes;

  // Force inline styles to apply named border colors when themes do not load
  // their color stylesheets in the editor.
  if (borderColor) {
    const borderColorObject = getMultiOriginColor({
      colors,
      namedColor: borderColor
    });
    borderProps.style.borderColor = borderColorObject.color;
  }
  return borderProps;
}

;// ./node_modules/@wordpress/block-editor/build-module/hooks/use-shadow-props.js
/**
 * Internal dependencies
 */


// This utility is intended to assist where the serialization of the shadow
// block support is being skipped for a block but the shadow related CSS classes
// &amp; styles still need to be generated so they can be applied to inner elements.

/**
 * Provides the CSS class names and inline styles for a block&#039;s shadow support
 * attributes.
 *
 * @param {Object} attributes Block attributes.
 * @return {Object} Shadow block support derived CSS classes &amp; styles.
 */
function getShadowClassesAndStyles(attributes) {
  const shadow = attributes.style?.shadow || &#039;&#039;;
  return {
    style: getInlineStyles({
      shadow
    })
  };
}

;// ./node_modules/@wordpress/block-editor/build-module/hooks/use-color-props.js
/**
 * External dependencies
 */


/**
 * WordPress dependencies
 */


/**
 * Internal dependencies
 */





// The code in this file has largely been lifted from the color block support
// hook.
//
// This utility is intended to assist where the serialization of the colors
// block support is being skipped for a block but the color related CSS classes
// &amp; styles still need to be generated so they can be applied to inner elements.

/**
 * Provides the CSS class names and inline styles for a block&#039;s color support
 * attributes.
 *
 * @param {Object} attributes Block attributes.
 *
 * @return {Object} Color block support derived CSS classes &amp; styles.
 */
function getColorClassesAndStyles(attributes) {
  const {
    backgroundColor,
    textColor,
    gradient,
    style
  } = attributes;

  // Collect color CSS classes.
  const backgroundClass = getColorClassName(&#039;background-color&#039;, backgroundColor);
  const textClass = getColorClassName(&#039;color&#039;, textColor);
  const gradientClass = __experimentalGetGradientClass(gradient);
  const hasGradient = gradientClass || style?.color?.gradient;

  // Determine color CSS class name list.
  const className = dist_clsx(textClass, gradientClass, {
    // Don&#039;t apply the background class if there&#039;s a gradient.
    [backgroundClass]: !hasGradient &amp;&amp; !!backgroundClass,
    &#039;has-text-color&#039;: textColor || style?.color?.text,
    &#039;has-background&#039;: backgroundColor || style?.color?.background || gradient || style?.color?.gradient,
    &#039;has-link-color&#039;: style?.elements?.link?.color
  });

  // Collect inline styles for colors.
  const colorStyles = style?.color || {};
  const styleProp = getInlineStyles({
    color: colorStyles
  });
  return {
    className: className || undefined,
    style: styleProp
  };
}

/**
 * Determines the color related props for a block derived from its color block
 * support attributes.
 *
 * Inline styles are forced for named colors to ensure these selections are
 * reflected when themes do not load their color stylesheets in the editor.
 *
 * @param {Object} attributes Block attributes.
 *
 * @return {Object} ClassName &amp; style props from colors block support.
 */
function useColorProps(attributes) {
  const {
    backgroundColor,
    textColor,
    gradient
  } = attributes;
  const [userPalette, themePalette, defaultPalette, userGradients, themeGradients, defaultGradients] = use_settings_useSettings(&#039;color.palette.custom&#039;, &#039;color.palette.theme&#039;, &#039;color.palette.default&#039;, &#039;color.gradients.custom&#039;, &#039;color.gradients.theme&#039;, &#039;color.gradients.default&#039;);
  const colors = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; [...(userPalette || []), ...(themePalette || []), ...(defaultPalette || [])], [userPalette, themePalette, defaultPalette]);
  const gradients = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; [...(userGradients || []), ...(themeGradients || []), ...(defaultGradients || [])], [userGradients, themeGradients, defaultGradients]);
  const colorProps = getColorClassesAndStyles(attributes);

  // Force inline styles to apply colors when themes do not load their color
  // stylesheets in the editor.
  if (backgroundColor) {
    const backgroundColorObject = getColorObjectByAttributeValues(colors, backgroundColor);
    colorProps.style.backgroundColor = backgroundColorObject.color;
  }
  if (gradient) {
    colorProps.style.background = getGradientValueBySlug(gradients, gradient);
  }
  if (textColor) {
    const textColorObject = getColorObjectByAttributeValues(colors, textColor);
    colorProps.style.color = textColorObject.color;
  }
  return colorProps;
}

;// ./node_modules/@wordpress/block-editor/build-module/hooks/use-spacing-props.js
/**
 * Internal dependencies
 */


// This utility is intended to assist where the serialization of the spacing
// block support is being skipped for a block but the spacing related CSS
// styles still need to be generated so they can be applied to inner elements.

/**
 * Provides the CSS class names and inline styles for a block&#039;s spacing support
 * attributes.
 *
 * @param {Object} attributes Block attributes.
 *
 * @return {Object} Spacing block support derived CSS classes &amp; styles.
 */
function getSpacingClassesAndStyles(attributes) {
  const {
    style
  } = attributes;

  // Collect inline styles for spacing.
  const spacingStyles = style?.spacing || {};
  const styleProp = getInlineStyles({
    spacing: spacingStyles
  });
  return {
    style: styleProp
  };
}

;// ./node_modules/@wordpress/block-editor/build-module/hooks/use-typography-props.js
/**
 * External dependencies
 */


/**
 * WordPress dependencies
 */


/**
 * Internal dependencies
 */




const {
  kebabCase: use_typography_props_kebabCase
} = unlock(external_wp_components_namespaceObject.privateApis);

/*
 * This utility is intended to assist where the serialization of the typography
 * block support is being skipped for a block but the typography related CSS
 * styles still need to be generated so they can be applied to inner elements.
 */
/**
 * Provides the CSS class names and inline styles for a block&#039;s typography support
 * attributes.
 *
 * @param {Object}         attributes Block attributes.
 * @param {Object|boolean} settings   Merged theme.json settings
 *
 * @return {Object} Typography block support derived CSS classes &amp; styles.
 */
function getTypographyClassesAndStyles(attributes, settings) {
  let typographyStyles = attributes?.style?.typography || {};
  typographyStyles = {
    ...typographyStyles,
    fontSize: getTypographyFontSizeValue({
      size: attributes?.style?.typography?.fontSize
    }, settings)
  };
  const style = getInlineStyles({
    typography: typographyStyles
  });
  const fontFamilyClassName = !!attributes?.fontFamily ? `has-${use_typography_props_kebabCase(attributes.fontFamily)}-font-family` : &#039;&#039;;
  const textAlignClassName = !!attributes?.style?.typography?.textAlign ? `has-text-align-${attributes?.style?.typography?.textAlign}` : &#039;&#039;;
  const className = dist_clsx(fontFamilyClassName, textAlignClassName, getFontSizeClass(attributes?.fontSize));
  return {
    className,
    style
  };
}

;// ./node_modules/@wordpress/block-editor/build-module/hooks/use-cached-truthy.js
/**
 * WordPress dependencies
 */


/**
 * Keeps an up-to-date copy of the passed value and returns it. If value becomes falsy, it will return the last truthy copy.
 *
 * @param {any} value
 * @return {any} value
 */
function useCachedTruthy(value) {
  const [cachedValue, setCachedValue] = (0,external_wp_element_namespaceObject.useState)(value);
  (0,external_wp_element_namespaceObject.useEffect)(() =&gt; {
    if (value) {
      setCachedValue(value);
    }
  }, [value]);
  return cachedValue;
}

;// ./node_modules/@wordpress/block-editor/build-module/hooks/index.js
/**
 * Internal dependencies
 */




























createBlockEditFilter([align, text_align, hooks_anchor, custom_class_name, style, duotone, position, layout, content_lock_ui, block_hooks, block_bindings, layout_child].filter(Boolean));
createBlockListBlockFilter([align, text_align, background, style, color, dimensions, duotone, font_family, font_size, border, position, block_style_variation, layout_child]);
createBlockSaveFilter([align, text_align, hooks_anchor, aria_label, custom_class_name, border, color, style, font_family, font_size]);














;// ./node_modules/@wordpress/block-editor/build-module/components/colors/with-colors.js
/**
 * WordPress dependencies
 */




/**
 * Internal dependencies
 */




const {
  kebabCase: with_colors_kebabCase
} = unlock(external_wp_components_namespaceObject.privateApis);

/**
 * Capitalizes the first letter in a string.
 *
 * @param {string} str The string whose first letter the function will capitalize.
 *
 * @return {string} Capitalized string.
 */
const upperFirst = ([firstLetter, ...rest]) =&gt; firstLetter.toUpperCase() + rest.join(&#039;&#039;);

/**
 * Higher order component factory for injecting the `colorsArray` argument as
 * the colors prop in the `withCustomColors` HOC.
 *
 * @param {Array} colorsArray An array of color objects.
 *
 * @return {Function} The higher order component.
 */
const withCustomColorPalette = colorsArray =&gt; (0,external_wp_compose_namespaceObject.createHigherOrderComponent)(WrappedComponent =&gt; props =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(WrappedComponent, {
  ...props,
  colors: colorsArray
}), &#039;withCustomColorPalette&#039;);

/**
 * Higher order component factory for injecting the editor colors as the
 * `colors` prop in the `withColors` HOC.
 *
 * @return {Function} The higher order component.
 */
const withEditorColorPalette = () =&gt; (0,external_wp_compose_namespaceObject.createHigherOrderComponent)(WrappedComponent =&gt; props =&gt; {
  const [userPalette, themePalette, defaultPalette] = use_settings_useSettings(&#039;color.palette.custom&#039;, &#039;color.palette.theme&#039;, &#039;color.palette.default&#039;);
  const allColors = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; [...(userPalette || []), ...(themePalette || []), ...(defaultPalette || [])], [userPalette, themePalette, defaultPalette]);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(WrappedComponent, {
    ...props,
    colors: allColors
  });
}, &#039;withEditorColorPalette&#039;);

/**
 * Helper function used with `createHigherOrderComponent` to create
 * higher order components for managing color logic.
 *
 * @param {Array}    colorTypes       An array of color types (e.g. &#039;backgroundColor, borderColor).
 * @param {Function} withColorPalette A HOC for injecting the &#039;colors&#039; prop into the WrappedComponent.
 *
 * @return {Component} The component that can be used as a HOC.
 */
function createColorHOC(colorTypes, withColorPalette) {
  const colorMap = colorTypes.reduce((colorObject, colorType) =&gt; {
    return {
      ...colorObject,
      ...(typeof colorType === &#039;string&#039; ? {
        [colorType]: with_colors_kebabCase(colorType)
      } : colorType)
    };
  }, {});
  return (0,external_wp_compose_namespaceObject.compose)([withColorPalette, WrappedComponent =&gt; {
    return class extends external_wp_element_namespaceObject.Component {
      constructor(props) {
        super(props);
        this.setters = this.createSetters();
        this.colorUtils = {
          getMostReadableColor: this.getMostReadableColor.bind(this)
        };
        this.state = {};
      }
      getMostReadableColor(colorValue) {
        const {
          colors
        } = this.props;
        return getMostReadableColor(colors, colorValue);
      }
      createSetters() {
        return Object.keys(colorMap).reduce((settersAccumulator, colorAttributeName) =&gt; {
          const upperFirstColorAttributeName = upperFirst(colorAttributeName);
          const customColorAttributeName = `custom${upperFirstColorAttributeName}`;
          settersAccumulator[`set${upperFirstColorAttributeName}`] = this.createSetColor(colorAttributeName, customColorAttributeName);
          return settersAccumulator;
        }, {});
      }
      createSetColor(colorAttributeName, customColorAttributeName) {
        return colorValue =&gt; {
          const colorObject = getColorObjectByColorValue(this.props.colors, colorValue);
          this.props.setAttributes({
            [colorAttributeName]: colorObject &amp;&amp; colorObject.slug ? colorObject.slug : undefined,
            [customColorAttributeName]: colorObject &amp;&amp; colorObject.slug ? undefined : colorValue
          });
        };
      }
      static getDerivedStateFromProps({
        attributes,
        colors
      }, previousState) {
        return Object.entries(colorMap).reduce((newState, [colorAttributeName, colorContext]) =&gt; {
          const colorObject = getColorObjectByAttributeValues(colors, attributes[colorAttributeName], attributes[`custom${upperFirst(colorAttributeName)}`]);
          const previousColorObject = previousState[colorAttributeName];
          const previousColor = previousColorObject?.color;
          /**
           * The &quot;and previousColorObject&quot; condition checks that a previous color object was already computed.
           * At the start previousColorObject and colorValue are both equal to undefined
           * bus as previousColorObject does not exist we should compute the object.
           */
          if (previousColor === colorObject.color &amp;&amp; previousColorObject) {
            newState[colorAttributeName] = previousColorObject;
          } else {
            newState[colorAttributeName] = {
              ...colorObject,
              class: getColorClassName(colorContext, colorObject.slug)
            };
          }
          return newState;
        }, {});
      }
      render() {
        return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(WrappedComponent, {
          ...this.props,
          colors: undefined,
          ...this.state,
          ...this.setters,
          colorUtils: this.colorUtils
        });
      }
    };
  }]);
}

/**
 * A higher-order component factory for creating a &#039;withCustomColors&#039; HOC, which handles color logic
 * for class generation color value, retrieval and color attribute setting.
 *
 * Use this higher-order component to work with a custom set of colors.
 *
 * @example
 *
 * ```jsx
 * const CUSTOM_COLORS = [ { name: &#039;Red&#039;, slug: &#039;red&#039;, color: &#039;#ff0000&#039; }, { name: &#039;Blue&#039;, slug: &#039;blue&#039;, color: &#039;#0000ff&#039; } ];
 * const withCustomColors = createCustomColorsHOC( CUSTOM_COLORS );
 * // ...
 * export default compose(
 *     withCustomColors( &#039;backgroundColor&#039;, &#039;borderColor&#039; ),
 *     MyColorfulComponent,
 * );
 * ```
 *
 * @param {Array} colorsArray The array of color objects (name, slug, color, etc... ).
 *
 * @return {Function} Higher-order component.
 */
function createCustomColorsHOC(colorsArray) {
  return (...colorTypes) =&gt; {
    const withColorPalette = withCustomColorPalette(colorsArray);
    return (0,external_wp_compose_namespaceObject.createHigherOrderComponent)(createColorHOC(colorTypes, withColorPalette), &#039;withCustomColors&#039;);
  };
}

/**
 * A higher-order component, which handles color logic for class generation color value, retrieval and color attribute setting.
 *
 * For use with the default editor/theme color palette.
 *
 * @example
 *
 * ```jsx
 * export default compose(
 *     withColors( &#039;backgroundColor&#039;, { textColor: &#039;color&#039; } ),
 *     MyColorfulComponent,
 * );
 * ```
 *
 * @param {...(Object|string)} colorTypes The arguments can be strings or objects. If the argument is an object,
 *                                        it should contain the color attribute name as key and the color context as value.
 *                                        If the argument is a string the value should be the color attribute name,
 *                                        the color context is computed by applying a kebab case transform to the value.
 *                                        Color context represents the context/place where the color is going to be used.
 *                                        The class name of the color is generated using &#039;has&#039; followed by the color name
 *                                        and ending with the color context all in kebab case e.g: has-green-background-color.
 *
 * @return {Function} Higher-order component.
 */
function withColors(...colorTypes) {
  const withColorPalette = withEditorColorPalette();
  return (0,external_wp_compose_namespaceObject.createHigherOrderComponent)(createColorHOC(colorTypes, withColorPalette), &#039;withColors&#039;);
}

;// ./node_modules/@wordpress/block-editor/build-module/components/colors/index.js



;// ./node_modules/@wordpress/block-editor/build-module/components/gradients/index.js


;// ./node_modules/@wordpress/block-editor/build-module/components/font-sizes/font-size-picker.js
/**
 * WordPress dependencies
 */


/**
 * Internal dependencies
 */


function font_size_picker_FontSizePicker(props) {
  const [fontSizes, customFontSize] = use_settings_useSettings(&#039;typography.fontSizes&#039;, &#039;typography.customFontSize&#039;);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FontSizePicker, {
    ...props,
    fontSizes: fontSizes,
    disableCustomFontSizes: !customFontSize
  });
}

/**
 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/font-sizes/README.md
 */
/* harmony default export */ const font_size_picker = (font_size_picker_FontSizePicker);

;// ./node_modules/@wordpress/block-editor/build-module/components/font-sizes/with-font-sizes.js
/**
 * WordPress dependencies
 */



/**
 * Internal dependencies
 */



const DEFAULT_FONT_SIZES = [];

/**
 * Capitalizes the first letter in a string.
 *
 * @param {string} str The string whose first letter the function will capitalize.
 *
 * @return {string} Capitalized string.
 */
const with_font_sizes_upperFirst = ([firstLetter, ...rest]) =&gt; firstLetter.toUpperCase() + rest.join(&#039;&#039;);

/**
 * Higher-order component, which handles font size logic for class generation,
 * font size value retrieval, and font size change handling.
 *
 * @param {...(Object|string)} fontSizeNames The arguments should all be strings.
 *                                           Each string contains the font size
 *                                           attribute name e.g: &#039;fontSize&#039;.
 *
 * @return {Function} Higher-order component.
 */
/* harmony default export */ const with_font_sizes = ((...fontSizeNames) =&gt; {
  /*
   * Computes an object whose key is the font size attribute name as passed in the array,
   * and the value is the custom font size attribute name.
   * Custom font size is automatically compted by appending custom followed by the font size attribute name in with the first letter capitalized.
   */
  const fontSizeAttributeNames = fontSizeNames.reduce((fontSizeAttributeNamesAccumulator, fontSizeAttributeName) =&gt; {
    fontSizeAttributeNamesAccumulator[fontSizeAttributeName] = `custom${with_font_sizes_upperFirst(fontSizeAttributeName)}`;
    return fontSizeAttributeNamesAccumulator;
  }, {});
  return (0,external_wp_compose_namespaceObject.createHigherOrderComponent)((0,external_wp_compose_namespaceObject.compose)([(0,external_wp_compose_namespaceObject.createHigherOrderComponent)(WrappedComponent =&gt; props =&gt; {
    const [fontSizes] = use_settings_useSettings(&#039;typography.fontSizes&#039;);
    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(WrappedComponent, {
      ...props,
      fontSizes: fontSizes || DEFAULT_FONT_SIZES
    });
  }, &#039;withFontSizes&#039;), WrappedComponent =&gt; {
    return class extends external_wp_element_namespaceObject.Component {
      constructor(props) {
        super(props);
        this.setters = this.createSetters();
        this.state = {};
      }
      createSetters() {
        return Object.entries(fontSizeAttributeNames).reduce((settersAccumulator, [fontSizeAttributeName, customFontSizeAttributeName]) =&gt; {
          const upperFirstFontSizeAttributeName = with_font_sizes_upperFirst(fontSizeAttributeName);
          settersAccumulator[`set${upperFirstFontSizeAttributeName}`] = this.createSetFontSize(fontSizeAttributeName, customFontSizeAttributeName);
          return settersAccumulator;
        }, {});
      }
      createSetFontSize(fontSizeAttributeName, customFontSizeAttributeName) {
        return fontSizeValue =&gt; {
          const fontSizeObject = this.props.fontSizes?.find(({
            size
          }) =&gt; size === Number(fontSizeValue));
          this.props.setAttributes({
            [fontSizeAttributeName]: fontSizeObject &amp;&amp; fontSizeObject.slug ? fontSizeObject.slug : undefined,
            [customFontSizeAttributeName]: fontSizeObject &amp;&amp; fontSizeObject.slug ? undefined : fontSizeValue
          });
        };
      }
      static getDerivedStateFromProps({
        attributes,
        fontSizes
      }, previousState) {
        const didAttributesChange = (customFontSizeAttributeName, fontSizeAttributeName) =&gt; {
          if (previousState[fontSizeAttributeName]) {
            // If new font size is name compare with the previous slug.
            if (attributes[fontSizeAttributeName]) {
              return attributes[fontSizeAttributeName] !== previousState[fontSizeAttributeName].slug;
            }
            // If font size is not named, update when the font size value changes.
            return previousState[fontSizeAttributeName].size !== attributes[customFontSizeAttributeName];
          }
          // In this case we need to build the font size object.
          return true;
        };
        if (!Object.values(fontSizeAttributeNames).some(didAttributesChange)) {
          return null;
        }
        const newState = Object.entries(fontSizeAttributeNames).filter(([key, value]) =&gt; didAttributesChange(value, key)).reduce((newStateAccumulator, [fontSizeAttributeName, customFontSizeAttributeName]) =&gt; {
          const fontSizeAttributeValue = attributes[fontSizeAttributeName];
          const fontSizeObject = utils_getFontSize(fontSizes, fontSizeAttributeValue, attributes[customFontSizeAttributeName]);
          newStateAccumulator[fontSizeAttributeName] = {
            ...fontSizeObject,
            class: getFontSizeClass(fontSizeAttributeValue)
          };
          return newStateAccumulator;
        }, {});
        return {
          ...previousState,
          ...newState
        };
      }
      render() {
        return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(WrappedComponent, {
          ...this.props,
          fontSizes: undefined,
          ...this.state,
          ...this.setters
        });
      }
    };
  }]), &#039;withFontSizes&#039;);
});

;// ./node_modules/@wordpress/block-editor/build-module/components/font-sizes/index.js





;// ./node_modules/@wordpress/block-editor/build-module/autocompleters/block.js
/**
 * WordPress dependencies
 */




/**
 * Internal dependencies
 */







const block_noop = () =&gt; {};
const block_SHOWN_BLOCK_TYPES = 9;

/**
 * Creates a blocks repeater for replacing the current block with a selected block type.
 *
 * @return {Object} A blocks completer.
 */
function createBlockCompleter() {
  return {
    name: &#039;blocks&#039;,
    className: &#039;block-editor-autocompleters__block&#039;,
    triggerPrefix: &#039;/&#039;,
    useItems(filterValue) {
      const {
        rootClientId,
        selectedBlockId,
        prioritizedBlocks
      } = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
        const {
          getSelectedBlockClientId,
          getBlock,
          getBlockListSettings,
          getBlockRootClientId
        } = select(store);
        const {
          getActiveBlockVariation
        } = select(external_wp_blocks_namespaceObject.store);
        const selectedBlockClientId = getSelectedBlockClientId();
        const {
          name: blockName,
          attributes
        } = getBlock(selectedBlockClientId);
        const activeBlockVariation = getActiveBlockVariation(blockName, attributes);
        const _rootClientId = getBlockRootClientId(selectedBlockClientId);
        return {
          selectedBlockId: activeBlockVariation ? `${blockName}/${activeBlockVariation.name}` : blockName,
          rootClientId: _rootClientId,
          prioritizedBlocks: getBlockListSettings(_rootClientId)?.prioritizedInserterBlocks
        };
      }, []);
      const [items, categories, collections] = use_block_types_state(rootClientId, block_noop, true);
      const filteredItems = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; {
        const initialFilteredItems = !!filterValue.trim() ? searchBlockItems(items, categories, collections, filterValue) : orderInserterBlockItems(orderBy(items, &#039;frecency&#039;, &#039;desc&#039;), prioritizedBlocks);
        return initialFilteredItems.filter(item =&gt; item.id !== selectedBlockId).slice(0, block_SHOWN_BLOCK_TYPES);
      }, [filterValue, selectedBlockId, items, categories, collections, prioritizedBlocks]);
      const options = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; filteredItems.map(blockItem =&gt; {
        const {
          title,
          icon,
          isDisabled
        } = blockItem;
        return {
          key: `block-${blockItem.id}`,
          value: blockItem,
          label: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
            children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_icon, {
              icon: icon,
              showColors: true
            }, &quot;icon&quot;), title]
          }),
          isDisabled
        };
      }), [filteredItems]);
      return [options];
    },
    allowContext(before, after) {
      return !(/\S/.test(before) || /\S/.test(after));
    },
    getOptionCompletion(inserterItem) {
      const {
        name,
        initialAttributes,
        innerBlocks,
        syncStatus,
        content
      } = inserterItem;
      return {
        action: &#039;replace&#039;,
        value: syncStatus === &#039;unsynced&#039; ? (0,external_wp_blocks_namespaceObject.parse)(content, {
          __unstableSkipMigrationLogs: true
        }) : (0,external_wp_blocks_namespaceObject.createBlock)(name, initialAttributes, (0,external_wp_blocks_namespaceObject.createBlocksFromInnerBlocksTemplate)(innerBlocks))
      };
    }
  };
}

/**
 * Creates a blocks repeater for replacing the current block with a selected block type.
 *
 * @return {Object} A blocks completer.
 */
/* harmony default export */ const autocompleters_block = (createBlockCompleter());

;// external [&quot;wp&quot;,&quot;apiFetch&quot;]
const external_wp_apiFetch_namespaceObject = window[&quot;wp&quot;][&quot;apiFetch&quot;];
var external_wp_apiFetch_default = /*#__PURE__*/__webpack_require__.n(external_wp_apiFetch_namespaceObject);
;// ./node_modules/@wordpress/icons/build-module/library/post.js
/**
 * WordPress dependencies
 */


const post = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;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&quot;
  })
});
/* harmony default export */ const library_post = (post);

;// ./node_modules/@wordpress/block-editor/build-module/autocompleters/link.js
/**
 * WordPress dependencies
 */
// Disable Reason: Needs to be refactored.
// eslint-disable-next-line no-restricted-imports





const SHOWN_SUGGESTIONS = 10;

/**
 * Creates a suggestion list for links to posts or pages.
 *
 * @return {Object} A links completer.
 */
function createLinkCompleter() {
  return {
    name: &#039;links&#039;,
    className: &#039;block-editor-autocompleters__link&#039;,
    triggerPrefix: &#039;[[&#039;,
    options: async letters =&gt; {
      let options = await external_wp_apiFetch_default()({
        path: (0,external_wp_url_namespaceObject.addQueryArgs)(&#039;/wp/v2/search&#039;, {
          per_page: SHOWN_SUGGESTIONS,
          search: letters,
          type: &#039;post&#039;,
          order_by: &#039;menu_order&#039;
        })
      });
      options = options.filter(option =&gt; option.title !== &#039;&#039;);
      return options;
    },
    getOptionKeywords(item) {
      const expansionWords = item.title.split(/\s+/);
      return [...expansionWords];
    },
    getOptionLabel(item) {
      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(build_module_icon, {
          icon: item.subtype === &#039;page&#039; ? library_page : library_post
        }, &quot;icon&quot;), (0,external_wp_htmlEntities_namespaceObject.decodeEntities)(item.title)]
      });
    },
    getOptionCompletion(item) {
      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;a&quot;, {
        href: item.url,
        children: item.title
      });
    }
  };
}

/**
 * Creates a suggestion list for links to posts or pages..
 *
 * @return {Object} A link completer.
 */
/* harmony default export */ const autocompleters_link = (createLinkCompleter());

;// ./node_modules/@wordpress/block-editor/build-module/components/autocomplete/index.js
/**
 * WordPress dependencies
 */





/**
 * Internal dependencies
 */




/**
 * Shared reference to an empty array for cases where it is important to avoid
 * returning a new array reference on every invocation.
 *
 * @type {Array}
 */

const autocomplete_EMPTY_ARRAY = [];
function useCompleters({
  completers = autocomplete_EMPTY_ARRAY
}) {
  const {
    name
  } = useBlockEditContext();
  return (0,external_wp_element_namespaceObject.useMemo)(() =&gt; {
    let filteredCompleters = [...completers, autocompleters_link];
    if (name === (0,external_wp_blocks_namespaceObject.getDefaultBlockName)() || (0,external_wp_blocks_namespaceObject.getBlockSupport)(name, &#039;__experimentalSlashInserter&#039;, false)) {
      filteredCompleters = [...filteredCompleters, autocompleters_block];
    }
    if ((0,external_wp_hooks_namespaceObject.hasFilter)(&#039;editor.Autocomplete.completers&#039;)) {
      // Provide copies so filters may directly modify them.
      if (filteredCompleters === completers) {
        filteredCompleters = filteredCompleters.map(completer =&gt; ({
          ...completer
        }));
      }
      filteredCompleters = (0,external_wp_hooks_namespaceObject.applyFilters)(&#039;editor.Autocomplete.completers&#039;, filteredCompleters, name);
    }
    return filteredCompleters;
  }, [completers, name]);
}
function useBlockEditorAutocompleteProps(props) {
  return (0,external_wp_components_namespaceObject.__unstableUseAutocompleteProps)({
    ...props,
    completers: useCompleters(props)
  });
}

/**
 * Wrap the default Autocomplete component with one that supports a filter hook
 * for customizing its list of autocompleters.
 *
 * @type {import(&#039;react&#039;).FC}
 */
function BlockEditorAutocomplete(props) {
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Autocomplete, {
    ...props,
    completers: useCompleters(props)
  });
}

/**
 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/autocomplete/README.md
 */
/* harmony default export */ const autocomplete = (BlockEditorAutocomplete);

;// ./node_modules/@wordpress/icons/build-module/library/fullscreen.js
/**
 * WordPress dependencies
 */


const fullscreen = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;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&quot;
  })
});
/* harmony default export */ const library_fullscreen = (fullscreen);

;// ./node_modules/@wordpress/block-editor/build-module/components/block-full-height-alignment-control/index.js
/**
 * WordPress dependencies
 */




function BlockFullHeightAlignmentControl({
  isActive,
  label = (0,external_wp_i18n_namespaceObject.__)(&#039;Full height&#039;),
  onToggle,
  isDisabled
}) {
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarButton, {
    isActive: isActive,
    icon: library_fullscreen,
    label: label,
    onClick: () =&gt; onToggle(!isActive),
    disabled: isDisabled
  });
}
/* harmony default export */ const block_full_height_alignment_control = (BlockFullHeightAlignmentControl);

;// ./node_modules/@wordpress/block-editor/build-module/components/block-alignment-matrix-control/index.js
/**
 * WordPress dependencies
 */




const block_alignment_matrix_control_noop = () =&gt; {};

/**
 * The alignment matrix control allows users to quickly adjust inner block alignment.
 *
 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/block-alignment-matrix-control/README.md
 *
 * @example
 * ```jsx
 * function Example() {
 *   return (
 *     &lt;BlockControls&gt;
 *       &lt;BlockAlignmentMatrixControl
 *         label={ __( &#039;Change content position&#039; ) }
 *         value=&quot;center&quot;
 *         onChange={ ( nextPosition ) =&gt;
 *           setAttributes( { contentPosition: nextPosition } )
 *         }
 *       /&gt;
 *     &lt;/BlockControls&gt;
 *   );
 * }
 * ```
 *
 * @param {Object}   props            Component props.
 * @param {string}   props.label      Label for the control. Defaults to &#039;Change matrix alignment&#039;.
 * @param {Function} props.onChange   Function to execute upon change of matrix state.
 * @param {string}   props.value      Content alignment location. One of: &#039;center&#039;, &#039;center center&#039;,
 *                                    &#039;center left&#039;, &#039;center right&#039;, &#039;top center&#039;, &#039;top left&#039;,
 *                                    &#039;top right&#039;, &#039;bottom center&#039;, &#039;bottom left&#039;, &#039;bottom right&#039;.
 * @param {boolean}  props.isDisabled Whether the control should be disabled.
 * @return {Element} The BlockAlignmentMatrixControl component.
 */
function BlockAlignmentMatrixControl(props) {
  const {
    label = (0,external_wp_i18n_namespaceObject.__)(&#039;Change matrix alignment&#039;),
    onChange = block_alignment_matrix_control_noop,
    value = &#039;center&#039;,
    isDisabled
  } = props;
  const icon = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.AlignmentMatrixControl.Icon, {
    value: value
  });
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Dropdown, {
    popoverProps: {
      placement: &#039;bottom-start&#039;
    },
    renderToggle: ({
      onToggle,
      isOpen
    }) =&gt; {
      const openOnArrowDown = event =&gt; {
        if (!isOpen &amp;&amp; event.keyCode === external_wp_keycodes_namespaceObject.DOWN) {
          event.preventDefault();
          onToggle();
        }
      };
      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarButton, {
        onClick: onToggle,
        &quot;aria-haspopup&quot;: &quot;true&quot;,
        &quot;aria-expanded&quot;: isOpen,
        onKeyDown: openOnArrowDown,
        label: label,
        icon: icon,
        showTooltip: true,
        disabled: isDisabled
      });
    },
    renderContent: () =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.AlignmentMatrixControl, {
      hasFocusBorder: false,
      onChange: onChange,
      value: value
    })
  });
}
/* harmony default export */ const block_alignment_matrix_control = (BlockAlignmentMatrixControl);

;// ./node_modules/@wordpress/block-editor/build-module/components/block-title/use-block-display-title.js
/**
 * WordPress dependencies
 */



/**
 * Internal dependencies
 */


/**
 * Returns the block&#039;s configured title as a string, or empty if the title
 * cannot be determined.
 *
 * @example
 *
 * ```js
 * useBlockDisplayTitle( { clientId: &#039;afd1cb17-2c08-4e7a-91be-007ba7ddc3a1&#039;, maximumLength: 17 } );
 * ```
 *
 * @param {Object}           props
 * @param {string}           props.clientId      Client ID of block.
 * @param {number|undefined} props.maximumLength The maximum length that the block title string may be before truncated.
 * @param {string|undefined} props.context       The context to pass to `getBlockLabel`.
 * @return {?string} Block title.
 */
function useBlockDisplayTitle({
  clientId,
  maximumLength,
  context
}) {
  const blockTitle = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    if (!clientId) {
      return null;
    }
    const {
      getBlockName,
      getBlockAttributes
    } = select(store);
    const {
      getBlockType,
      getActiveBlockVariation
    } = select(external_wp_blocks_namespaceObject.store);
    const blockName = getBlockName(clientId);
    const blockType = getBlockType(blockName);
    if (!blockType) {
      return null;
    }
    const attributes = getBlockAttributes(clientId);
    const label = (0,external_wp_blocks_namespaceObject.__experimentalGetBlockLabel)(blockType, attributes, context);
    // If the label is defined we prioritize it over a possible block variation title match.
    if (label !== blockType.title) {
      return label;
    }
    const match = getActiveBlockVariation(blockName, attributes);
    // Label will fallback to the title if no label is defined for the current label context.
    return match?.title || blockType.title;
  }, [clientId, context]);
  if (!blockTitle) {
    return null;
  }
  if (maximumLength &amp;&amp; maximumLength &gt; 0 &amp;&amp; blockTitle.length &gt; maximumLength) {
    const omission = &#039;...&#039;;
    return blockTitle.slice(0, maximumLength - omission.length) + omission;
  }
  return blockTitle;
}

;// ./node_modules/@wordpress/block-editor/build-module/components/block-title/index.js
/**
 * Internal dependencies
 */



/**
 * Renders the block&#039;s configured title as a string, or empty if the title
 * cannot be determined.
 *
 * @example
 *
 * ```jsx
 * &lt;BlockTitle clientId=&quot;afd1cb17-2c08-4e7a-91be-007ba7ddc3a1&quot; maximumLength={ 17 }/&gt;
 * ```
 *
 * @param {Object}           props
 * @param {string}           props.clientId      Client ID of block.
 * @param {number|undefined} props.maximumLength The maximum length that the block title string may be before truncated.
 * @param {string|undefined} props.context       The context to pass to `getBlockLabel`.
 *
 * @return {JSX.Element} Block title.
 */
function BlockTitle({
  clientId,
  maximumLength,
  context
}) {
  return useBlockDisplayTitle({
    clientId,
    maximumLength,
    context
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/utils/get-editor-region.js
/**
 * Gets the editor region for a given editor canvas element or
 * returns the passed element if no region is found
 *
 * @param { Object } editor The editor canvas element.
 * @return { Object } The editor region or given editor element
 */
function getEditorRegion(editor) {
  var _Array$from$find, _editorCanvas$closest;
  if (!editor) {
    return null;
  }

  // If there are multiple editors, we need to find the iframe that contains our contentRef to make sure
  // we&#039;re focusing the region that contains this editor.
  const editorCanvas = (_Array$from$find = Array.from(document.querySelectorAll(&#039;iframe[name=&quot;editor-canvas&quot;]&#039;).values()).find(iframe =&gt; {
    // Find the iframe that contains our contentRef
    const iframeDocument = iframe.contentDocument || iframe.contentWindow.document;
    return iframeDocument === editor.ownerDocument;
  })) !== null &amp;&amp; _Array$from$find !== void 0 ? _Array$from$find : editor;

  // The region is provided by the editor, not the block-editor.
  // We should send focus to the region if one is available to reuse the
  // same interface for navigating landmarks. If no region is available,
  // use the canvas instead.
  return (_editorCanvas$closest = editorCanvas?.closest(&#039;[role=&quot;region&quot;]&#039;)) !== null &amp;&amp; _editorCanvas$closest !== void 0 ? _editorCanvas$closest : editorCanvas;
}

;// ./node_modules/@wordpress/block-editor/build-module/components/block-breadcrumb/index.js
/**
 * WordPress dependencies
 */






/**
 * Internal dependencies
 */






/**
 * Block breadcrumb component, displaying the hierarchy of the current block selection as a breadcrumb.
 *
 * @param {Object} props               Component props.
 * @param {string} props.rootLabelText Translated label for the root element of the breadcrumb trail.
 * @return {Element}                   Block Breadcrumb.
 */

function BlockBreadcrumb({
  rootLabelText
}) {
  const {
    selectBlock,
    clearSelectedBlock
  } = (0,external_wp_data_namespaceObject.useDispatch)(store);
  const {
    clientId,
    parents,
    hasSelection
  } = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      getSelectionStart,
      getSelectedBlockClientId,
      getEnabledBlockParents
    } = unlock(select(store));
    const selectedBlockClientId = getSelectedBlockClientId();
    return {
      parents: getEnabledBlockParents(selectedBlockClientId),
      clientId: selectedBlockClientId,
      hasSelection: !!getSelectionStart().clientId
    };
  }, []);
  const rootLabel = rootLabelText || (0,external_wp_i18n_namespaceObject.__)(&#039;Document&#039;);

  // We don&#039;t care about this specific ref, but this is a way
  // to get a ref within the editor canvas so we can focus it later.
  const blockRef = (0,external_wp_element_namespaceObject.useRef)();
  useBlockElementRef(clientId, blockRef);

  /*
   * Disable reason: The `list` ARIA role is redundant but
   * Safari+VoiceOver won&#039;t announce the list otherwise.
   */
  /* eslint-disable jsx-a11y/no-redundant-roles */
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;ul&quot;, {
    className: &quot;block-editor-block-breadcrumb&quot;,
    role: &quot;list&quot;,
    &quot;aria-label&quot;: (0,external_wp_i18n_namespaceObject.__)(&#039;Block breadcrumb&#039;),
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;li&quot;, {
      className: !hasSelection ? &#039;block-editor-block-breadcrumb__current&#039; : undefined,
      &quot;aria-current&quot;: !hasSelection ? &#039;true&#039; : undefined,
      children: [hasSelection &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
        size: &quot;small&quot;,
        className: &quot;block-editor-block-breadcrumb__button&quot;,
        onClick: () =&gt; {
          // Find the block editor wrapper for the selected block
          const blockEditor = blockRef.current?.closest(&#039;.editor-styles-wrapper&#039;);
          clearSelectedBlock();
          getEditorRegion(blockEditor)?.focus();
        },
        children: rootLabel
      }), !hasSelection &amp;&amp; rootLabel, !!clientId &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(build_module_icon, {
        icon: chevron_right_small,
        className: &quot;block-editor-block-breadcrumb__separator&quot;
      })]
    }), parents.map(parentClientId =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;li&quot;, {
      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
        size: &quot;small&quot;,
        className: &quot;block-editor-block-breadcrumb__button&quot;,
        onClick: () =&gt; selectBlock(parentClientId),
        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockTitle, {
          clientId: parentClientId,
          maximumLength: 35
        })
      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(build_module_icon, {
        icon: chevron_right_small,
        className: &quot;block-editor-block-breadcrumb__separator&quot;
      })]
    }, parentClientId)), !!clientId &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;li&quot;, {
      className: &quot;block-editor-block-breadcrumb__current&quot;,
      &quot;aria-current&quot;: &quot;true&quot;,
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockTitle, {
        clientId: clientId,
        maximumLength: 35
      })
    })]
  })
  /* eslint-enable jsx-a11y/no-redundant-roles */;
}
/* harmony default export */ const block_breadcrumb = (BlockBreadcrumb);

;// ./node_modules/@wordpress/block-editor/build-module/components/block-content-overlay/index.js
/**
 * WordPress dependencies
 */


/**
 * Internal dependencies
 */

function useBlockOverlayActive(clientId) {
  return (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      __unstableHasActiveBlockOverlayActive
    } = select(store);
    return __unstableHasActiveBlockOverlayActive(clientId);
  }, [clientId]);
}

;// ./node_modules/@wordpress/block-editor/build-module/components/block-tools/use-block-toolbar-popover-props.js
/**
 * WordPress dependencies
 */





/**
 * Internal dependencies
 */




const COMMON_PROPS = {
  placement: &#039;top-start&#039;
};

// By default the toolbar sets the `shift` prop. If the user scrolls the page
// down the toolbar will stay on screen by adopting a sticky position at the
// top of the viewport.
const DEFAULT_PROPS = {
  ...COMMON_PROPS,
  flip: false,
  shift: true
};

// When there isn&#039;t enough height between the top of the block and the editor
// canvas, the `shift` prop is set to `false`, as it will cause the block to be
// obscured. The `flip` behavior is enabled, which positions the toolbar below
// the block. This only happens if the block is smaller than the viewport, as
// otherwise the toolbar will be off-screen.
const RESTRICTED_HEIGHT_PROPS = {
  ...COMMON_PROPS,
  flip: true,
  shift: false
};

/**
 * Get the popover props for the block toolbar, determined by the space at the top of the canvas and the toolbar height.
 *
 * @param {Element} contentElement       The DOM element that represents the editor content or canvas.
 * @param {Element} selectedBlockElement The outer DOM element of the first selected block.
 * @param {Element} scrollContainer      The scrollable container for the contentElement.
 * @param {number}  toolbarHeight        The height of the toolbar in pixels.
 * @param {boolean} isSticky             Whether or not the selected block is sticky or fixed.
 *
 * @return {Object} The popover props used to determine the position of the toolbar.
 */
function getProps(contentElement, selectedBlockElement, scrollContainer, toolbarHeight, isSticky) {
  if (!contentElement || !selectedBlockElement) {
    return DEFAULT_PROPS;
  }

  // Get how far the content area has been scrolled.
  const scrollTop = scrollContainer?.scrollTop || 0;
  const blockRect = getElementBounds(selectedBlockElement);
  const contentRect = contentElement.getBoundingClientRect();

  // Get the vertical position of top of the visible content area.
  const topOfContentElementInViewport = scrollTop + contentRect.top;

  // The document element&#039;s clientHeight represents the viewport height.
  const viewportHeight = contentElement.ownerDocument.documentElement.clientHeight;

  // The restricted height area is calculated as the sum of the
  // vertical position of the visible content area, plus the height
  // of the block toolbar.
  const restrictedTopArea = topOfContentElementInViewport + toolbarHeight;
  const hasSpaceForToolbarAbove = blockRect.top &gt; restrictedTopArea;
  const isBlockTallerThanViewport = blockRect.height &gt; viewportHeight - toolbarHeight;

  // Sticky blocks are treated as if they will never have enough space for the toolbar above.
  if (!isSticky &amp;&amp; (hasSpaceForToolbarAbove || isBlockTallerThanViewport)) {
    return DEFAULT_PROPS;
  }
  return RESTRICTED_HEIGHT_PROPS;
}

/**
 * Determines the desired popover positioning behavior, returning a set of appropriate props.
 *
 * @param {Object}  elements
 * @param {Element} elements.contentElement The DOM element that represents the editor content or canvas.
 * @param {string}  elements.clientId       The clientId of the first selected block.
 *
 * @return {Object} The popover props used to determine the position of the toolbar.
 */
function useBlockToolbarPopoverProps({
  contentElement,
  clientId
}) {
  const selectedBlockElement = useBlockElement(clientId);
  const [toolbarHeight, setToolbarHeight] = (0,external_wp_element_namespaceObject.useState)(0);
  const {
    blockIndex,
    isSticky
  } = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      getBlockIndex,
      getBlockAttributes
    } = select(store);
    return {
      blockIndex: getBlockIndex(clientId),
      isSticky: hasStickyOrFixedPositionValue(getBlockAttributes(clientId))
    };
  }, [clientId]);
  const scrollContainer = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; {
    if (!contentElement) {
      return;
    }
    return (0,external_wp_dom_namespaceObject.getScrollContainer)(contentElement);
  }, [contentElement]);
  const [props, setProps] = (0,external_wp_element_namespaceObject.useState)(() =&gt; getProps(contentElement, selectedBlockElement, scrollContainer, toolbarHeight, isSticky));
  const popoverRef = (0,external_wp_compose_namespaceObject.useRefEffect)(popoverNode =&gt; {
    setToolbarHeight(popoverNode.offsetHeight);
  }, []);
  const updateProps = (0,external_wp_element_namespaceObject.useCallback)(() =&gt; setProps(getProps(contentElement, selectedBlockElement, scrollContainer, toolbarHeight, isSticky)), [contentElement, selectedBlockElement, scrollContainer, toolbarHeight]);

  // Update props when the block is moved. This also ensures the props are
  // correct on initial mount, and when the selected block or content element
  // changes (since the callback ref will update).
  (0,external_wp_element_namespaceObject.useLayoutEffect)(updateProps, [blockIndex, updateProps]);

  // Update props when the viewport is resized or the block is resized.
  (0,external_wp_element_namespaceObject.useLayoutEffect)(() =&gt; {
    if (!contentElement || !selectedBlockElement) {
      return;
    }

    // Update the toolbar props on viewport resize.
    const contentView = contentElement?.ownerDocument?.defaultView;
    contentView?.addEventHandler?.(&#039;resize&#039;, updateProps);

    // Update the toolbar props on block resize.
    let resizeObserver;
    const blockView = selectedBlockElement?.ownerDocument?.defaultView;
    if (blockView.ResizeObserver) {
      resizeObserver = new blockView.ResizeObserver(updateProps);
      resizeObserver.observe(selectedBlockElement);
    }
    return () =&gt; {
      contentView?.removeEventHandler?.(&#039;resize&#039;, updateProps);
      if (resizeObserver) {
        resizeObserver.disconnect();
      }
    };
  }, [updateProps, contentElement, selectedBlockElement]);
  return {
    ...props,
    ref: popoverRef
  };
}

;// ./node_modules/@wordpress/block-editor/build-module/components/block-tools/use-selected-block-tool-props.js
/**
 * WordPress dependencies
 */


/**
 * Internal dependencies
 */


/**
 * Returns props for the selected block tools and empty block inserter.
 *
 * @param {string} clientId Selected block client ID.
 */
function useSelectedBlockToolProps(clientId) {
  const selectedBlockProps = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      getBlockRootClientId,
      getBlockParents,
      __experimentalGetBlockListSettingsForBlocks,
      isBlockInsertionPointVisible,
      getBlockInsertionPoint,
      getBlockOrder,
      hasMultiSelection,
      getLastMultiSelectedBlockClientId
    } = select(store);
    const blockParentsClientIds = getBlockParents(clientId);

    // Get Block List Settings for all ancestors of the current Block clientId.
    const parentBlockListSettings = __experimentalGetBlockListSettingsForBlocks(blockParentsClientIds);

    // Get the clientId of the topmost parent with the capture toolbars setting.
    const capturingClientId = blockParentsClientIds.find(parentClientId =&gt; parentBlockListSettings[parentClientId]?.__experimentalCaptureToolbars);
    let isInsertionPointVisible = false;
    if (isBlockInsertionPointVisible()) {
      const insertionPoint = getBlockInsertionPoint();
      const order = getBlockOrder(insertionPoint.rootClientId);
      isInsertionPointVisible = order[insertionPoint.index] === clientId;
    }
    return {
      capturingClientId,
      isInsertionPointVisible,
      lastClientId: hasMultiSelection() ? getLastMultiSelectedBlockClientId() : null,
      rootClientId: getBlockRootClientId(clientId)
    };
  }, [clientId]);
  return selectedBlockProps;
}

;// ./node_modules/@wordpress/block-editor/build-module/components/block-tools/empty-block-inserter.js
/**
 * External dependencies
 */


/**
 * Internal dependencies
 */





function EmptyBlockInserter({
  clientId,
  __unstableContentRef
}) {
  const {
    capturingClientId,
    isInsertionPointVisible,
    lastClientId,
    rootClientId
  } = useSelectedBlockToolProps(clientId);
  const popoverProps = useBlockToolbarPopoverProps({
    contentElement: __unstableContentRef?.current,
    clientId
  });
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(cover, {
    clientId: capturingClientId || clientId,
    bottomClientId: lastClientId,
    className: dist_clsx(&#039;block-editor-block-list__block-side-inserter-popover&#039;, {
      &#039;is-insertion-point-visible&#039;: isInsertionPointVisible
    }),
    __unstableContentRef: __unstableContentRef,
    ...popoverProps,
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
      className: &quot;block-editor-block-list__empty-block-inserter&quot;,
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inserter, {
        position: &quot;bottom right&quot;,
        rootClientId: rootClientId,
        clientId: clientId,
        __experimentalIsQuick: true
      })
    })
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/block-draggable/use-scroll-when-dragging.js
/**
 * WordPress dependencies
 */


const SCROLL_INACTIVE_DISTANCE_PX = 50;
const SCROLL_INTERVAL_MS = 25;
const PIXELS_PER_SECOND_PER_PERCENTAGE = 1000;
const VELOCITY_MULTIPLIER = PIXELS_PER_SECOND_PER_PERCENTAGE * (SCROLL_INTERVAL_MS / 1000);

/**
 * React hook that scrolls the scroll container when a block is being dragged.
 *
 * @return {Function[]} `startScrolling`, `scrollOnDragOver`, `stopScrolling`
 *                      functions to be called in `onDragStart`, `onDragOver`
 *                      and `onDragEnd` events respectively.
 */
function useScrollWhenDragging() {
  const dragStartYRef = (0,external_wp_element_namespaceObject.useRef)(null);
  const velocityYRef = (0,external_wp_element_namespaceObject.useRef)(null);
  const scrollParentYRef = (0,external_wp_element_namespaceObject.useRef)(null);
  const scrollEditorIntervalRef = (0,external_wp_element_namespaceObject.useRef)(null);

  // Clear interval when unmounting.
  (0,external_wp_element_namespaceObject.useEffect)(() =&gt; () =&gt; {
    if (scrollEditorIntervalRef.current) {
      clearInterval(scrollEditorIntervalRef.current);
      scrollEditorIntervalRef.current = null;
    }
  }, []);
  const startScrolling = (0,external_wp_element_namespaceObject.useCallback)(event =&gt; {
    dragStartYRef.current = event.clientY;

    // Find nearest parent(s) to scroll.
    scrollParentYRef.current = (0,external_wp_dom_namespaceObject.getScrollContainer)(event.target);
    scrollEditorIntervalRef.current = setInterval(() =&gt; {
      if (scrollParentYRef.current &amp;&amp; velocityYRef.current) {
        const newTop = scrollParentYRef.current.scrollTop + velocityYRef.current;

        // Setting `behavior: &#039;smooth&#039;` as a scroll property seems to hurt performance.
        // Better to use a small scroll interval.
        scrollParentYRef.current.scroll({
          top: newTop
        });
      }
    }, SCROLL_INTERVAL_MS);
  }, []);
  const scrollOnDragOver = (0,external_wp_element_namespaceObject.useCallback)(event =&gt; {
    if (!scrollParentYRef.current) {
      return;
    }
    const scrollParentHeight = scrollParentYRef.current.offsetHeight;
    const offsetDragStartPosition = dragStartYRef.current - scrollParentYRef.current.offsetTop;
    const offsetDragPosition = event.clientY - scrollParentYRef.current.offsetTop;
    if (event.clientY &gt; offsetDragStartPosition) {
      // User is dragging downwards.
      const moveableDistance = Math.max(scrollParentHeight - offsetDragStartPosition - SCROLL_INACTIVE_DISTANCE_PX, 0);
      const dragDistance = Math.max(offsetDragPosition - offsetDragStartPosition - SCROLL_INACTIVE_DISTANCE_PX, 0);
      const distancePercentage = moveableDistance === 0 || dragDistance === 0 ? 0 : dragDistance / moveableDistance;
      velocityYRef.current = VELOCITY_MULTIPLIER * distancePercentage;
    } else if (event.clientY &lt; offsetDragStartPosition) {
      // User is dragging upwards.
      const moveableDistance = Math.max(offsetDragStartPosition - SCROLL_INACTIVE_DISTANCE_PX, 0);
      const dragDistance = Math.max(offsetDragStartPosition - offsetDragPosition - SCROLL_INACTIVE_DISTANCE_PX, 0);
      const distancePercentage = moveableDistance === 0 || dragDistance === 0 ? 0 : dragDistance / moveableDistance;
      velocityYRef.current = -VELOCITY_MULTIPLIER * distancePercentage;
    } else {
      velocityYRef.current = 0;
    }
  }, []);
  const stopScrolling = () =&gt; {
    dragStartYRef.current = null;
    scrollParentYRef.current = null;
    if (scrollEditorIntervalRef.current) {
      clearInterval(scrollEditorIntervalRef.current);
      scrollEditorIntervalRef.current = null;
    }
  };
  return [startScrolling, scrollOnDragOver, stopScrolling];
}

;// ./node_modules/@wordpress/block-editor/build-module/components/block-draggable/index.js
/**
 * WordPress dependencies
 */






/**
 * Internal dependencies
 */






const BlockDraggable = ({
  appendToOwnerDocument,
  children,
  clientIds,
  cloneClassname,
  elementId,
  onDragStart,
  onDragEnd,
  fadeWhenDisabled = false,
  dragComponent
}) =&gt; {
  const {
    srcRootClientId,
    isDraggable,
    icon,
    visibleInserter,
    getBlockType
  } = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      canMoveBlocks,
      getBlockRootClientId,
      getBlockName,
      getBlockAttributes,
      isBlockInsertionPointVisible
    } = select(store);
    const {
      getBlockType: _getBlockType,
      getActiveBlockVariation
    } = select(external_wp_blocks_namespaceObject.store);
    const rootClientId = getBlockRootClientId(clientIds[0]);
    const blockName = getBlockName(clientIds[0]);
    const variation = getActiveBlockVariation(blockName, getBlockAttributes(clientIds[0]));
    return {
      srcRootClientId: rootClientId,
      isDraggable: canMoveBlocks(clientIds),
      icon: variation?.icon || _getBlockType(blockName)?.icon,
      visibleInserter: isBlockInsertionPointVisible(),
      getBlockType: _getBlockType
    };
  }, [clientIds]);
  const isDraggingRef = (0,external_wp_element_namespaceObject.useRef)(false);
  const [startScrolling, scrollOnDragOver, stopScrolling] = useScrollWhenDragging();
  const {
    getAllowedBlocks,
    getBlockNamesByClientId,
    getBlockRootClientId
  } = (0,external_wp_data_namespaceObject.useSelect)(store);
  const {
    startDraggingBlocks,
    stopDraggingBlocks
  } = (0,external_wp_data_namespaceObject.useDispatch)(store);

  // Stop dragging blocks if the block draggable is unmounted.
  (0,external_wp_element_namespaceObject.useEffect)(() =&gt; {
    return () =&gt; {
      if (isDraggingRef.current) {
        stopDraggingBlocks();
      }
    };
  }, []);

  // Find the root of the editor iframe.
  const blockEl = useBlockElement(clientIds[0]);
  const editorRoot = blockEl?.closest(&#039;body&#039;);

  /*
   * Add a dragover event listener to the editor root to track the blocks being dragged over.
   * The listener has to be inside the editor iframe otherwise the target isn&#039;t accessible.
   */
  (0,external_wp_element_namespaceObject.useEffect)(() =&gt; {
    if (!editorRoot || !fadeWhenDisabled) {
      return;
    }
    const onDragOver = event =&gt; {
      if (!event.target.closest(&#039;[data-block]&#039;)) {
        return;
      }
      const draggedBlockNames = getBlockNamesByClientId(clientIds);
      const targetClientId = event.target.closest(&#039;[data-block]&#039;).getAttribute(&#039;data-block&#039;);
      const allowedBlocks = getAllowedBlocks(targetClientId);
      const targetBlockName = getBlockNamesByClientId([targetClientId])[0];

      /*
       * Check if the target is valid to drop in.
       * If the target&#039;s allowedBlocks is an empty array,
       * it isn&#039;t a container block, in which case we check
       * its parent&#039;s validity instead.
       */
      let dropTargetValid;
      if (allowedBlocks?.length === 0) {
        const targetRootClientId = getBlockRootClientId(targetClientId);
        const targetRootBlockName = getBlockNamesByClientId([targetRootClientId])[0];
        const rootAllowedBlocks = getAllowedBlocks(targetRootClientId);
        dropTargetValid = isDropTargetValid(getBlockType, rootAllowedBlocks, draggedBlockNames, targetRootBlockName);
      } else {
        dropTargetValid = isDropTargetValid(getBlockType, allowedBlocks, draggedBlockNames, targetBlockName);
      }

      /*
       * Update the body class to reflect if drop target is valid.
       * This has to be done on the document body because the draggable
       * chip is rendered outside of the editor iframe.
       */
      if (!dropTargetValid &amp;&amp; !visibleInserter) {
        window?.document?.body?.classList?.add(&#039;block-draggable-invalid-drag-token&#039;);
      } else {
        window?.document?.body?.classList?.remove(&#039;block-draggable-invalid-drag-token&#039;);
      }
    };
    const throttledOnDragOver = (0,external_wp_compose_namespaceObject.throttle)(onDragOver, 200);
    editorRoot.addEventListener(&#039;dragover&#039;, throttledOnDragOver);
    return () =&gt; {
      editorRoot.removeEventListener(&#039;dragover&#039;, throttledOnDragOver);
    };
  }, [clientIds, editorRoot, fadeWhenDisabled, getAllowedBlocks, getBlockNamesByClientId, getBlockRootClientId, getBlockType, visibleInserter]);
  if (!isDraggable) {
    return children({
      draggable: false
    });
  }
  const transferData = {
    type: &#039;block&#039;,
    srcClientIds: clientIds,
    srcRootClientId
  };
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Draggable, {
    appendToOwnerDocument: appendToOwnerDocument,
    cloneClassname: cloneClassname,
    __experimentalTransferDataType: &quot;wp-blocks&quot;,
    transferData: transferData,
    onDragStart: event =&gt; {
      // Defer hiding the dragged source element to the next
      // frame to enable dragging.
      window.requestAnimationFrame(() =&gt; {
        startDraggingBlocks(clientIds);
        isDraggingRef.current = true;
        startScrolling(event);
        if (onDragStart) {
          onDragStart();
        }
      });
    },
    onDragOver: scrollOnDragOver,
    onDragEnd: () =&gt; {
      stopDraggingBlocks();
      isDraggingRef.current = false;
      stopScrolling();
      if (onDragEnd) {
        onDragEnd();
      }
    },
    __experimentalDragComponent:
    // Check against `undefined` so that `null` can be used to disable
    // the default drag component.
    dragComponent !== undefined ? dragComponent : /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockDraggableChip, {
      count: clientIds.length,
      icon: icon,
      fadeWhenDisabled: true
    }),
    elementId: elementId,
    children: ({
      onDraggableStart,
      onDraggableEnd
    }) =&gt; {
      return children({
        draggable: true,
        onDragStart: onDraggableStart,
        onDragEnd: onDraggableEnd
      });
    }
  });
};
/* harmony default export */ const block_draggable = (BlockDraggable);

;// ./node_modules/@wordpress/block-editor/build-module/components/block-mover/mover-description.js
/**
 * WordPress dependencies
 */

const getMovementDirection = (moveDirection, orientation) =&gt; {
  if (moveDirection === &#039;up&#039;) {
    if (orientation === &#039;horizontal&#039;) {
      return (0,external_wp_i18n_namespaceObject.isRTL)() ? &#039;right&#039; : &#039;left&#039;;
    }
    return &#039;up&#039;;
  } else if (moveDirection === &#039;down&#039;) {
    if (orientation === &#039;horizontal&#039;) {
      return (0,external_wp_i18n_namespaceObject.isRTL)() ? &#039;left&#039; : &#039;right&#039;;
    }
    return &#039;down&#039;;
  }
  return null;
};

/**
 * Return a label for the block movement controls depending on block position.
 *
 * @param {number}  selectedCount Number of blocks selected.
 * @param {string}  type          Block type - in the case of a single block, should
 *                                define its &#039;type&#039;. I.e. &#039;Text&#039;, &#039;Heading&#039;, &#039;Image&#039; etc.
 * @param {number}  firstIndex    The index (position - 1) of the first block selected.
 * @param {boolean} isFirst       This is the first block.
 * @param {boolean} isLast        This is the last block.
 * @param {number}  dir           Direction of movement (&gt; 0 is considered to be going
 *                                down, &lt; 0 is up).
 * @param {string}  orientation   The orientation of the block movers, vertical or
 *                                horizontal.
 *
 * @return {string | undefined} Label for the block movement controls.
 */
function getBlockMoverDescription(selectedCount, type, firstIndex, isFirst, isLast, dir, orientation) {
  const position = firstIndex + 1;
  if (selectedCount &gt; 1) {
    return getMultiBlockMoverDescription(selectedCount, firstIndex, isFirst, isLast, dir, orientation);
  }
  if (isFirst &amp;&amp; isLast) {
    return (0,external_wp_i18n_namespaceObject.sprintf)(
    // translators: %s: Type of block (i.e. Text, Image etc)
    (0,external_wp_i18n_namespaceObject.__)(&#039;Block %s is the only block, and cannot be moved&#039;), type);
  }
  if (dir &gt; 0 &amp;&amp; !isLast) {
    // Moving down.
    const movementDirection = getMovementDirection(&#039;down&#039;, orientation);
    if (movementDirection === &#039;down&#039;) {
      return (0,external_wp_i18n_namespaceObject.sprintf)(
      // translators: 1: Type of block (i.e. Text, Image etc), 2: Position of selected block, 3: New position
      (0,external_wp_i18n_namespaceObject.__)(&#039;Move %1$s block from position %2$d down to position %3$d&#039;), type, position, position + 1);
    }
    if (movementDirection === &#039;left&#039;) {
      return (0,external_wp_i18n_namespaceObject.sprintf)(
      // translators: 1: Type of block (i.e. Text, Image etc), 2: Position of selected block, 3: New position
      (0,external_wp_i18n_namespaceObject.__)(&#039;Move %1$s block from position %2$d left to position %3$d&#039;), type, position, position + 1);
    }
    if (movementDirection === &#039;right&#039;) {
      return (0,external_wp_i18n_namespaceObject.sprintf)(
      // translators: 1: Type of block (i.e. Text, Image etc), 2: Position of selected block, 3: New position
      (0,external_wp_i18n_namespaceObject.__)(&#039;Move %1$s block from position %2$d right to position %3$d&#039;), type, position, position + 1);
    }
  }
  if (dir &gt; 0 &amp;&amp; isLast) {
    // Moving down, and is the last item.
    const movementDirection = getMovementDirection(&#039;down&#039;, orientation);
    if (movementDirection === &#039;down&#039;) {
      return (0,external_wp_i18n_namespaceObject.sprintf)(
      // translators: 1: Type of block (i.e. Text, Image etc)
      (0,external_wp_i18n_namespaceObject.__)(&#039;Block %1$s is at the end of the content and can’t be moved down&#039;), type);
    }
    if (movementDirection === &#039;left&#039;) {
      return (0,external_wp_i18n_namespaceObject.sprintf)(
      // translators: 1: Type of block (i.e. Text, Image etc)
      (0,external_wp_i18n_namespaceObject.__)(&#039;Block %1$s is at the end of the content and can’t be moved left&#039;), type);
    }
    if (movementDirection === &#039;right&#039;) {
      return (0,external_wp_i18n_namespaceObject.sprintf)(
      // translators: 1: Type of block (i.e. Text, Image etc)
      (0,external_wp_i18n_namespaceObject.__)(&#039;Block %1$s is at the end of the content and can’t be moved right&#039;), type);
    }
  }
  if (dir &lt; 0 &amp;&amp; !isFirst) {
    // Moving up.
    const movementDirection = getMovementDirection(&#039;up&#039;, orientation);
    if (movementDirection === &#039;up&#039;) {
      return (0,external_wp_i18n_namespaceObject.sprintf)(
      // translators: 1: Type of block (i.e. Text, Image etc), 2: Position of selected block, 3: New position
      (0,external_wp_i18n_namespaceObject.__)(&#039;Move %1$s block from position %2$d up to position %3$d&#039;), type, position, position - 1);
    }
    if (movementDirection === &#039;left&#039;) {
      return (0,external_wp_i18n_namespaceObject.sprintf)(
      // translators: 1: Type of block (i.e. Text, Image etc), 2: Position of selected block, 3: New position
      (0,external_wp_i18n_namespaceObject.__)(&#039;Move %1$s block from position %2$d left to position %3$d&#039;), type, position, position - 1);
    }
    if (movementDirection === &#039;right&#039;) {
      return (0,external_wp_i18n_namespaceObject.sprintf)(
      // translators: 1: Type of block (i.e. Text, Image etc), 2: Position of selected block, 3: New position
      (0,external_wp_i18n_namespaceObject.__)(&#039;Move %1$s block from position %2$d right to position %3$d&#039;), type, position, position - 1);
    }
  }
  if (dir &lt; 0 &amp;&amp; isFirst) {
    // Moving up, and is the first item.
    const movementDirection = getMovementDirection(&#039;up&#039;, orientation);
    if (movementDirection === &#039;up&#039;) {
      return (0,external_wp_i18n_namespaceObject.sprintf)(
      // translators: 1: Type of block (i.e. Text, Image etc)
      (0,external_wp_i18n_namespaceObject.__)(&#039;Block %1$s is at the beginning of the content and can’t be moved up&#039;), type);
    }
    if (movementDirection === &#039;left&#039;) {
      return (0,external_wp_i18n_namespaceObject.sprintf)(
      // translators: 1: Type of block (i.e. Text, Image etc)
      (0,external_wp_i18n_namespaceObject.__)(&#039;Block %1$s is at the beginning of the content and can’t be moved left&#039;), type);
    }
    if (movementDirection === &#039;right&#039;) {
      return (0,external_wp_i18n_namespaceObject.sprintf)(
      // translators: 1: Type of block (i.e. Text, Image etc)
      (0,external_wp_i18n_namespaceObject.__)(&#039;Block %1$s is at the beginning of the content and can’t be moved right&#039;), type);
    }
  }
}

/**
 * Return a label for the block movement controls depending on block position.
 *
 * @param {number}  selectedCount Number of blocks selected.
 * @param {number}  firstIndex    The index (position - 1) of the first block selected.
 * @param {boolean} isFirst       This is the first block.
 * @param {boolean} isLast        This is the last block.
 * @param {number}  dir           Direction of movement (&gt; 0 is considered to be going
 *                                down, &lt; 0 is up).
 * @param {string}  orientation   The orientation of the block movers, vertical or
 *                                horizontal.
 *
 * @return {string | undefined} Label for the block movement controls.
 */
function getMultiBlockMoverDescription(selectedCount, firstIndex, isFirst, isLast, dir, orientation) {
  const position = firstIndex + 1;
  if (isFirst &amp;&amp; isLast) {
    // All blocks are selected
    return (0,external_wp_i18n_namespaceObject.__)(&#039;All blocks are selected, and cannot be moved&#039;);
  }
  if (dir &gt; 0 &amp;&amp; !isLast) {
    // moving down
    const movementDirection = getMovementDirection(&#039;down&#039;, orientation);
    if (movementDirection === &#039;down&#039;) {
      return (0,external_wp_i18n_namespaceObject.sprintf)(
      // translators: 1: Number of selected blocks, 2: Position of selected blocks
      (0,external_wp_i18n_namespaceObject.__)(&#039;Move %1$d blocks from position %2$d down by one place&#039;), selectedCount, position);
    }
    if (movementDirection === &#039;left&#039;) {
      return (0,external_wp_i18n_namespaceObject.sprintf)(
      // translators: 1: Number of selected blocks, 2: Position of selected blocks
      (0,external_wp_i18n_namespaceObject.__)(&#039;Move %1$d blocks from position %2$d left by one place&#039;), selectedCount, position);
    }
    if (movementDirection === &#039;right&#039;) {
      return (0,external_wp_i18n_namespaceObject.sprintf)(
      // translators: 1: Number of selected blocks, 2: Position of selected blocks
      (0,external_wp_i18n_namespaceObject.__)(&#039;Move %1$d blocks from position %2$d right by one place&#039;), selectedCount, position);
    }
  }
  if (dir &gt; 0 &amp;&amp; isLast) {
    // moving down, and the selected blocks are the last item
    const movementDirection = getMovementDirection(&#039;down&#039;, orientation);
    if (movementDirection === &#039;down&#039;) {
      return (0,external_wp_i18n_namespaceObject.__)(&#039;Blocks cannot be moved down as they are already at the bottom&#039;);
    }
    if (movementDirection === &#039;left&#039;) {
      return (0,external_wp_i18n_namespaceObject.__)(&#039;Blocks cannot be moved left as they are already are at the leftmost position&#039;);
    }
    if (movementDirection === &#039;right&#039;) {
      return (0,external_wp_i18n_namespaceObject.__)(&#039;Blocks cannot be moved right as they are already are at the rightmost position&#039;);
    }
  }
  if (dir &lt; 0 &amp;&amp; !isFirst) {
    // moving up
    const movementDirection = getMovementDirection(&#039;up&#039;, orientation);
    if (movementDirection === &#039;up&#039;) {
      return (0,external_wp_i18n_namespaceObject.sprintf)(
      // translators: 1: Number of selected blocks, 2: Position of selected blocks
      (0,external_wp_i18n_namespaceObject.__)(&#039;Move %1$d blocks from position %2$d up by one place&#039;), selectedCount, position);
    }
    if (movementDirection === &#039;left&#039;) {
      return (0,external_wp_i18n_namespaceObject.sprintf)(
      // translators: 1: Number of selected blocks, 2: Position of selected blocks
      (0,external_wp_i18n_namespaceObject.__)(&#039;Move %1$d blocks from position %2$d left by one place&#039;), selectedCount, position);
    }
    if (movementDirection === &#039;right&#039;) {
      return (0,external_wp_i18n_namespaceObject.sprintf)(
      // translators: 1: Number of selected blocks, 2: Position of selected blocks
      (0,external_wp_i18n_namespaceObject.__)(&#039;Move %1$d blocks from position %2$d right by one place&#039;), selectedCount, position);
    }
  }
  if (dir &lt; 0 &amp;&amp; isFirst) {
    // moving up, and the selected blocks are the first item
    const movementDirection = getMovementDirection(&#039;up&#039;, orientation);
    if (movementDirection === &#039;up&#039;) {
      return (0,external_wp_i18n_namespaceObject.__)(&#039;Blocks cannot be moved up as they are already at the top&#039;);
    }
    if (movementDirection === &#039;left&#039;) {
      return (0,external_wp_i18n_namespaceObject.__)(&#039;Blocks cannot be moved left as they are already are at the leftmost position&#039;);
    }
    if (movementDirection === &#039;right&#039;) {
      return (0,external_wp_i18n_namespaceObject.__)(&#039;Blocks cannot be moved right as they are already are at the rightmost position&#039;);
    }
  }
}

;// ./node_modules/@wordpress/block-editor/build-module/components/block-mover/button.js
/**
 * External dependencies
 */


/**
 * WordPress dependencies
 */







/**
 * Internal dependencies
 */




const getArrowIcon = (direction, orientation) =&gt; {
  if (direction === &#039;up&#039;) {
    if (orientation === &#039;horizontal&#039;) {
      return (0,external_wp_i18n_namespaceObject.isRTL)() ? chevron_right : chevron_left;
    }
    return chevron_up;
  } else if (direction === &#039;down&#039;) {
    if (orientation === &#039;horizontal&#039;) {
      return (0,external_wp_i18n_namespaceObject.isRTL)() ? chevron_left : chevron_right;
    }
    return chevron_down;
  }
  return null;
};
const getMovementDirectionLabel = (moveDirection, orientation) =&gt; {
  if (moveDirection === &#039;up&#039;) {
    if (orientation === &#039;horizontal&#039;) {
      return (0,external_wp_i18n_namespaceObject.isRTL)() ? (0,external_wp_i18n_namespaceObject.__)(&#039;Move right&#039;) : (0,external_wp_i18n_namespaceObject.__)(&#039;Move left&#039;);
    }
    return (0,external_wp_i18n_namespaceObject.__)(&#039;Move up&#039;);
  } else if (moveDirection === &#039;down&#039;) {
    if (orientation === &#039;horizontal&#039;) {
      return (0,external_wp_i18n_namespaceObject.isRTL)() ? (0,external_wp_i18n_namespaceObject.__)(&#039;Move left&#039;) : (0,external_wp_i18n_namespaceObject.__)(&#039;Move right&#039;);
    }
    return (0,external_wp_i18n_namespaceObject.__)(&#039;Move down&#039;);
  }
  return null;
};
const BlockMoverButton = (0,external_wp_element_namespaceObject.forwardRef)(({
  clientIds,
  direction,
  orientation: moverOrientation,
  ...props
}, ref) =&gt; {
  const instanceId = (0,external_wp_compose_namespaceObject.useInstanceId)(BlockMoverButton);
  const normalizedClientIds = Array.isArray(clientIds) ? clientIds : [clientIds];
  const blocksCount = normalizedClientIds.length;
  const {
    disabled
  } = props;
  const {
    blockType,
    isDisabled,
    rootClientId,
    isFirst,
    isLast,
    firstIndex,
    orientation = &#039;vertical&#039;
  } = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      getBlockIndex,
      getBlockRootClientId,
      getBlockOrder,
      getBlock,
      getBlockListSettings
    } = select(store);
    const firstClientId = normalizedClientIds[0];
    const blockRootClientId = getBlockRootClientId(firstClientId);
    const firstBlockIndex = getBlockIndex(firstClientId);
    const lastBlockIndex = getBlockIndex(normalizedClientIds[normalizedClientIds.length - 1]);
    const blockOrder = getBlockOrder(blockRootClientId);
    const block = getBlock(firstClientId);
    const isFirstBlock = firstBlockIndex === 0;
    const isLastBlock = lastBlockIndex === blockOrder.length - 1;
    const {
      orientation: blockListOrientation
    } = getBlockListSettings(blockRootClientId) || {};
    return {
      blockType: block ? (0,external_wp_blocks_namespaceObject.getBlockType)(block.name) : null,
      isDisabled: disabled || (direction === &#039;up&#039; ? isFirstBlock : isLastBlock),
      rootClientId: blockRootClientId,
      firstIndex: firstBlockIndex,
      isFirst: isFirstBlock,
      isLast: isLastBlock,
      orientation: moverOrientation || blockListOrientation
    };
  }, [clientIds, direction]);
  const {
    moveBlocksDown,
    moveBlocksUp
  } = (0,external_wp_data_namespaceObject.useDispatch)(store);
  const moverFunction = direction === &#039;up&#039; ? moveBlocksUp : moveBlocksDown;
  const onClick = event =&gt; {
    moverFunction(clientIds, rootClientId);
    if (props.onClick) {
      props.onClick(event);
    }
  };
  const descriptionId = `block-editor-block-mover-button__description-${instanceId}`;
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
      __next40pxDefaultSize: true,
      ref: ref,
      className: dist_clsx(&#039;block-editor-block-mover-button&#039;, `is-${direction}-button`),
      icon: getArrowIcon(direction, orientation),
      label: getMovementDirectionLabel(direction, orientation),
      &quot;aria-describedby&quot;: descriptionId,
      ...props,
      onClick: isDisabled ? null : onClick,
      disabled: isDisabled,
      accessibleWhenDisabled: true
    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.VisuallyHidden, {
      id: descriptionId,
      children: getBlockMoverDescription(blocksCount, blockType &amp;&amp; blockType.title, firstIndex, isFirst, isLast, direction === &#039;up&#039; ? -1 : 1, orientation)
    })]
  });
});
const BlockMoverUpButton = (0,external_wp_element_namespaceObject.forwardRef)((props, ref) =&gt; {
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockMoverButton, {
    direction: &quot;up&quot;,
    ref: ref,
    ...props
  });
});
const BlockMoverDownButton = (0,external_wp_element_namespaceObject.forwardRef)((props, ref) =&gt; {
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockMoverButton, {
    direction: &quot;down&quot;,
    ref: ref,
    ...props
  });
});

;// ./node_modules/@wordpress/block-editor/build-module/components/block-mover/index.js
/**
 * External dependencies
 */


/**
 * WordPress dependencies
 */






/**
 * Internal dependencies
 */




function BlockMover({
  clientIds,
  hideDragHandle,
  isBlockMoverUpButtonDisabled,
  isBlockMoverDownButtonDisabled
}) {
  const {
    canMove,
    rootClientId,
    isFirst,
    isLast,
    orientation,
    isManualGrid
  } = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    var _getBlockAttributes;
    const {
      getBlockIndex,
      getBlockListSettings,
      canMoveBlocks,
      getBlockOrder,
      getBlockRootClientId,
      getBlockAttributes
    } = select(store);
    const normalizedClientIds = Array.isArray(clientIds) ? clientIds : [clientIds];
    const firstClientId = normalizedClientIds[0];
    const _rootClientId = getBlockRootClientId(firstClientId);
    const firstIndex = getBlockIndex(firstClientId);
    const lastIndex = getBlockIndex(normalizedClientIds[normalizedClientIds.length - 1]);
    const blockOrder = getBlockOrder(_rootClientId);
    const {
      layout = {}
    } = (_getBlockAttributes = getBlockAttributes(_rootClientId)) !== null &amp;&amp; _getBlockAttributes !== void 0 ? _getBlockAttributes : {};
    return {
      canMove: canMoveBlocks(clientIds),
      rootClientId: _rootClientId,
      isFirst: firstIndex === 0,
      isLast: lastIndex === blockOrder.length - 1,
      orientation: getBlockListSettings(_rootClientId)?.orientation,
      isManualGrid: layout.type === &#039;grid&#039; &amp;&amp; layout.isManualPlacement &amp;&amp; window.__experimentalEnableGridInteractivity
    };
  }, [clientIds]);
  if (!canMove || isFirst &amp;&amp; isLast &amp;&amp; !rootClientId || hideDragHandle &amp;&amp; isManualGrid) {
    return null;
  }
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.ToolbarGroup, {
    className: dist_clsx(&#039;block-editor-block-mover&#039;, {
      &#039;is-horizontal&#039;: orientation === &#039;horizontal&#039;
    }),
    children: [!hideDragHandle &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_draggable, {
      clientIds: clientIds,
      fadeWhenDisabled: true,
      children: draggableProps =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
        __next40pxDefaultSize: true,
        icon: drag_handle,
        className: &quot;block-editor-block-mover__drag-handle&quot;,
        label: (0,external_wp_i18n_namespaceObject.__)(&#039;Drag&#039;)
        // Should not be able to tab to drag handle as this
        // button can only be used with a pointer device.
        ,
        tabIndex: &quot;-1&quot;,
        ...draggableProps
      })
    }), !isManualGrid &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;div&quot;, {
      className: &quot;block-editor-block-mover__move-button-container&quot;,
      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarItem, {
        children: itemProps =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockMoverUpButton, {
          disabled: isBlockMoverUpButtonDisabled,
          clientIds: clientIds,
          ...itemProps
        })
      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarItem, {
        children: itemProps =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockMoverDownButton, {
          disabled: isBlockMoverDownButtonDisabled,
          clientIds: clientIds,
          ...itemProps
        })
      })]
    })]
  });
}

/**
 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/block-mover/README.md
 */
/* harmony default export */ const block_mover = (BlockMover);

;// ./node_modules/@wordpress/block-editor/build-module/components/block-toolbar/utils.js
/**
 * WordPress dependencies
 */



/**
 * Internal dependencies
 */

const {
  clearTimeout: utils_clearTimeout,
  setTimeout: utils_setTimeout
} = window;
const DEBOUNCE_TIMEOUT = 200;

/**
 * Hook that creates debounced callbacks when the node is hovered or focused.
 *
 * @param {Object}  props                       Component props.
 * @param {Object}  props.ref                   Element reference.
 * @param {boolean} props.isFocused             Whether the component has current focus.
 * @param {number}  props.highlightParent       Whether to highlight the parent block. It defaults in highlighting the selected block.
 * @param {number}  [props.debounceTimeout=250] Debounce timeout in milliseconds.
 */
function useDebouncedShowGestures({
  ref,
  isFocused,
  highlightParent,
  debounceTimeout = DEBOUNCE_TIMEOUT
}) {
  const {
    getSelectedBlockClientId,
    getBlockRootClientId
  } = (0,external_wp_data_namespaceObject.useSelect)(store);
  const {
    toggleBlockHighlight
  } = (0,external_wp_data_namespaceObject.useDispatch)(store);
  const timeoutRef = (0,external_wp_element_namespaceObject.useRef)();
  const isDistractionFree = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; select(store).getSettings().isDistractionFree, []);
  const handleOnChange = nextIsFocused =&gt; {
    if (nextIsFocused &amp;&amp; isDistractionFree) {
      return;
    }
    const selectedBlockClientId = getSelectedBlockClientId();
    const clientId = highlightParent ? getBlockRootClientId(selectedBlockClientId) : selectedBlockClientId;
    toggleBlockHighlight(clientId, nextIsFocused);
  };
  const getIsHovered = () =&gt; {
    return ref?.current &amp;&amp; ref.current.matches(&#039;:hover&#039;);
  };
  const shouldHideGestures = () =&gt; {
    const isHovered = getIsHovered();
    return !isFocused &amp;&amp; !isHovered;
  };
  const clearTimeoutRef = () =&gt; {
    const timeout = timeoutRef.current;
    if (timeout &amp;&amp; utils_clearTimeout) {
      utils_clearTimeout(timeout);
    }
  };
  const debouncedShowGestures = event =&gt; {
    if (event) {
      event.stopPropagation();
    }
    clearTimeoutRef();
    handleOnChange(true);
  };
  const debouncedHideGestures = event =&gt; {
    if (event) {
      event.stopPropagation();
    }
    clearTimeoutRef();
    timeoutRef.current = utils_setTimeout(() =&gt; {
      if (shouldHideGestures()) {
        handleOnChange(false);
      }
    }, debounceTimeout);
  };
  (0,external_wp_element_namespaceObject.useEffect)(() =&gt; () =&gt; {
    /**
     * We need to call the change handler with `isFocused`
     * set to false on unmount because we also clear the
     * timeout that would handle that.
     */
    handleOnChange(false);
    clearTimeoutRef();
  }, []);
  return {
    debouncedShowGestures,
    debouncedHideGestures
  };
}

/**
 * Hook that provides gesture events for DOM elements
 * that interact with the isFocused state.
 *
 * @param {Object} props                         Component props.
 * @param {Object} props.ref                     Element reference.
 * @param {number} [props.highlightParent=false] Whether to highlight the parent block. It defaults to highlighting the selected block.
 * @param {number} [props.debounceTimeout=250]   Debounce timeout in milliseconds.
 */
function useShowHoveredOrFocusedGestures({
  ref,
  highlightParent = false,
  debounceTimeout = DEBOUNCE_TIMEOUT
}) {
  const [isFocused, setIsFocused] = (0,external_wp_element_namespaceObject.useState)(false);
  const {
    debouncedShowGestures,
    debouncedHideGestures
  } = useDebouncedShowGestures({
    ref,
    debounceTimeout,
    isFocused,
    highlightParent
  });
  const registerRef = (0,external_wp_element_namespaceObject.useRef)(false);
  const isFocusedWithin = () =&gt; {
    return ref?.current &amp;&amp; ref.current.contains(ref.current.ownerDocument.activeElement);
  };
  (0,external_wp_element_namespaceObject.useEffect)(() =&gt; {
    const node = ref.current;
    const handleOnFocus = () =&gt; {
      if (isFocusedWithin()) {
        setIsFocused(true);
        debouncedShowGestures();
      }
    };
    const handleOnBlur = () =&gt; {
      if (!isFocusedWithin()) {
        setIsFocused(false);
        debouncedHideGestures();
      }
    };

    /**
     * Events are added via DOM events (vs. React synthetic events),
     * as the child React components swallow mouse events.
     */
    if (node &amp;&amp; !registerRef.current) {
      node.addEventListener(&#039;focus&#039;, handleOnFocus, true);
      node.addEventListener(&#039;blur&#039;, handleOnBlur, true);
      registerRef.current = true;
    }
    return () =&gt; {
      if (node) {
        node.removeEventListener(&#039;focus&#039;, handleOnFocus);
        node.removeEventListener(&#039;blur&#039;, handleOnBlur);
      }
    };
  }, [ref, registerRef, setIsFocused, debouncedShowGestures, debouncedHideGestures]);
  return {
    onMouseMove: debouncedShowGestures,
    onMouseLeave: debouncedHideGestures
  };
}

;// ./node_modules/@wordpress/block-editor/build-module/components/block-parent-selector/index.js
/**
 * WordPress dependencies
 */





/**
 * Internal dependencies
 */






/**
 * Block parent selector component, displaying the hierarchy of the
 * current block selection as a single icon to &quot;go up&quot; a level.
 *
 * @return {Component} Parent block selector.
 */

function BlockParentSelector() {
  const {
    selectBlock
  } = (0,external_wp_data_namespaceObject.useDispatch)(store);
  const {
    parentClientId
  } = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      getBlockParents,
      getSelectedBlockClientId,
      getParentSectionBlock
    } = unlock(select(store));
    const selectedBlockClientId = getSelectedBlockClientId();
    const parentSection = getParentSectionBlock(selectedBlockClientId);
    const parents = getBlockParents(selectedBlockClientId);
    const _parentClientId = parentSection !== null &amp;&amp; parentSection !== void 0 ? parentSection : parents[parents.length - 1];
    return {
      parentClientId: _parentClientId
    };
  }, []);
  const blockInformation = useBlockDisplayInformation(parentClientId);

  // Allows highlighting the parent block outline when focusing or hovering
  // the parent block selector within the child.
  const nodeRef = (0,external_wp_element_namespaceObject.useRef)();
  const showHoveredOrFocusedGestures = useShowHoveredOrFocusedGestures({
    ref: nodeRef,
    highlightParent: true
  });
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
    className: &quot;block-editor-block-parent-selector&quot;,
    ref: nodeRef,
    ...showHoveredOrFocusedGestures,
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarButton, {
      className: &quot;block-editor-block-parent-selector__button&quot;,
      onClick: () =&gt; selectBlock(parentClientId),
      label: (0,external_wp_i18n_namespaceObject.sprintf)(/* translators: %s: Name of the block&#039;s parent. */
      (0,external_wp_i18n_namespaceObject.__)(&#039;Select parent block: %s&#039;), blockInformation?.title),
      showTooltip: true,
      icon: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_icon, {
        icon: blockInformation?.icon
      })
    })
  }, parentClientId);
}

;// ./node_modules/@wordpress/icons/build-module/library/copy.js
/**
 * WordPress dependencies
 */


const copy_copy = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    fillRule: &quot;evenodd&quot;,
    clipRule: &quot;evenodd&quot;,
    d: &quot;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&quot;
  })
});
/* harmony default export */ const library_copy = (copy_copy);

;// ./node_modules/@wordpress/block-editor/build-module/components/block-switcher/preview-block-popover.js
/**
 * WordPress dependencies
 */




/**
 * Internal dependencies
 */


function PreviewBlockPopover({
  blocks
}) {
  const isMobile = (0,external_wp_compose_namespaceObject.useViewportMatch)(&#039;medium&#039;, &#039;&lt;&#039;);
  if (isMobile) {
    return null;
  }
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
    className: &quot;block-editor-block-switcher__popover-preview-container&quot;,
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Popover, {
      className: &quot;block-editor-block-switcher__popover-preview&quot;,
      placement: &quot;right-start&quot;,
      focusOnMount: false,
      offset: 16,
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;div&quot;, {
        className: &quot;block-editor-block-switcher__preview&quot;,
        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
          className: &quot;block-editor-block-switcher__preview-title&quot;,
          children: (0,external_wp_i18n_namespaceObject.__)(&#039;Preview&#039;)
        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_preview, {
          viewportWidth: 500,
          blocks: blocks
        })]
      })
    })
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/block-switcher/block-variation-transformations.js
/**
 * WordPress dependencies
 */





/**
 * Internal dependencies
 */




const block_variation_transformations_EMPTY_OBJECT = {};
function useBlockVariationTransforms({
  clientIds,
  blocks
}) {
  const {
    activeBlockVariation,
    blockVariationTransformations
  } = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      getBlockAttributes,
      canRemoveBlocks
    } = select(store);
    const {
      getActiveBlockVariation,
      getBlockVariations
    } = select(external_wp_blocks_namespaceObject.store);
    const canRemove = canRemoveBlocks(clientIds);
    // Only handle single selected blocks for now.
    if (blocks.length !== 1 || !canRemove) {
      return block_variation_transformations_EMPTY_OBJECT;
    }
    const [firstBlock] = blocks;
    return {
      blockVariationTransformations: getBlockVariations(firstBlock.name, &#039;transform&#039;),
      activeBlockVariation: getActiveBlockVariation(firstBlock.name, getBlockAttributes(firstBlock.clientId))
    };
  }, [clientIds, blocks]);
  const transformations = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; {
    return blockVariationTransformations?.filter(({
      name
    }) =&gt; name !== activeBlockVariation?.name);
  }, [blockVariationTransformations, activeBlockVariation]);
  return transformations;
}
const BlockVariationTransformations = ({
  transformations,
  onSelect,
  blocks
}) =&gt; {
  const [hoveredTransformItemName, setHoveredTransformItemName] = (0,external_wp_element_namespaceObject.useState)();
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
    children: [hoveredTransformItemName &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PreviewBlockPopover, {
      blocks: (0,external_wp_blocks_namespaceObject.cloneBlock)(blocks[0], transformations.find(({
        name
      }) =&gt; name === hoveredTransformItemName).attributes)
    }), transformations?.map(item =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockVariationTransformationItem, {
      item: item,
      onSelect: onSelect,
      setHoveredTransformItemName: setHoveredTransformItemName
    }, item.name))]
  });
};
function BlockVariationTransformationItem({
  item,
  onSelect,
  setHoveredTransformItemName
}) {
  const {
    name,
    icon,
    title
  } = item;
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.MenuItem, {
    className: (0,external_wp_blocks_namespaceObject.getBlockMenuDefaultClassName)(name),
    onClick: event =&gt; {
      event.preventDefault();
      onSelect(name);
    },
    onMouseLeave: () =&gt; setHoveredTransformItemName(null),
    onMouseEnter: () =&gt; setHoveredTransformItemName(name),
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_icon, {
      icon: icon,
      showColors: true
    }), title]
  });
}
/* harmony default export */ const block_variation_transformations = (BlockVariationTransformations);

;// ./node_modules/@wordpress/block-editor/build-module/components/block-switcher/block-transformations-menu.js
/**
 * WordPress dependencies
 */





/**
 * Internal dependencies
 */




/**
 * Helper hook to group transformations to display them in a specific order in the UI.
 * For now we group only priority content driven transformations(ex. paragraph -&gt; heading).
 *
 * Later on we could also group &#039;layout&#039; transformations(ex. paragraph -&gt; group) and
 * display them in different sections.
 *
 * @param {Object[]} possibleBlockTransformations The available block transformations.
 * @return {Record&lt;string, Object[]&gt;} The grouped block transformations.
 */

function useGroupedTransforms(possibleBlockTransformations) {
  const priorityContentTransformationBlocks = {
    &#039;core/paragraph&#039;: 1,
    &#039;core/heading&#039;: 2,
    &#039;core/list&#039;: 3,
    &#039;core/quote&#039;: 4
  };
  const transformations = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; {
    const priorityTextTransformsNames = Object.keys(priorityContentTransformationBlocks);
    const groupedPossibleTransforms = possibleBlockTransformations.reduce((accumulator, item) =&gt; {
      const {
        name
      } = item;
      if (priorityTextTransformsNames.includes(name)) {
        accumulator.priorityTextTransformations.push(item);
      } else {
        accumulator.restTransformations.push(item);
      }
      return accumulator;
    }, {
      priorityTextTransformations: [],
      restTransformations: []
    });
    /**
     * If there is only one priority text transformation and it&#039;s a Quote,
     * is should move to the rest transformations. This is because Quote can
     * be a container for any block type, so in multi-block selection it will
     * always be suggested, even for non-text blocks.
     */
    if (groupedPossibleTransforms.priorityTextTransformations.length === 1 &amp;&amp; groupedPossibleTransforms.priorityTextTransformations[0].name === &#039;core/quote&#039;) {
      const singleQuote = groupedPossibleTransforms.priorityTextTransformations.pop();
      groupedPossibleTransforms.restTransformations.push(singleQuote);
    }
    return groupedPossibleTransforms;
  }, [possibleBlockTransformations]);

  // Order the priority text transformations.
  transformations.priorityTextTransformations.sort(({
    name: currentName
  }, {
    name: nextName
  }) =&gt; {
    return priorityContentTransformationBlocks[currentName] &lt; priorityContentTransformationBlocks[nextName] ? -1 : 1;
  });
  return transformations;
}
const BlockTransformationsMenu = ({
  className,
  possibleBlockTransformations,
  possibleBlockVariationTransformations,
  onSelect,
  onSelectVariation,
  blocks
}) =&gt; {
  const [hoveredTransformItemName, setHoveredTransformItemName] = (0,external_wp_element_namespaceObject.useState)();
  const {
    priorityTextTransformations,
    restTransformations
  } = useGroupedTransforms(possibleBlockTransformations);
  // We have to check if both content transformations(priority and rest) are set
  // in order to create a separate MenuGroup for them.
  const hasBothContentTransformations = priorityTextTransformations.length &amp;&amp; restTransformations.length;
  const restTransformItems = !!restTransformations.length &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(RestTransformationItems, {
    restTransformations: restTransformations,
    onSelect: onSelect,
    setHoveredTransformItemName: setHoveredTransformItemName
  });
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.MenuGroup, {
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Transform to&#039;),
      className: className,
      children: [hoveredTransformItemName &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PreviewBlockPopover, {
        blocks: (0,external_wp_blocks_namespaceObject.switchToBlockType)(blocks, hoveredTransformItemName)
      }), !!possibleBlockVariationTransformations?.length &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_variation_transformations, {
        transformations: possibleBlockVariationTransformations,
        blocks: blocks,
        onSelect: onSelectVariation
      }), priorityTextTransformations.map(item =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockTransformationItem, {
        item: item,
        onSelect: onSelect,
        setHoveredTransformItemName: setHoveredTransformItemName
      }, item.name)), !hasBothContentTransformations &amp;&amp; restTransformItems]
    }), !!hasBothContentTransformations &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuGroup, {
      className: className,
      children: restTransformItems
    })]
  });
};
function RestTransformationItems({
  restTransformations,
  onSelect,
  setHoveredTransformItemName
}) {
  return restTransformations.map(item =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockTransformationItem, {
    item: item,
    onSelect: onSelect,
    setHoveredTransformItemName: setHoveredTransformItemName
  }, item.name));
}
function BlockTransformationItem({
  item,
  onSelect,
  setHoveredTransformItemName
}) {
  const {
    name,
    icon,
    title,
    isDisabled
  } = item;
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.MenuItem, {
    className: (0,external_wp_blocks_namespaceObject.getBlockMenuDefaultClassName)(name),
    onClick: event =&gt; {
      event.preventDefault();
      onSelect(name);
    },
    disabled: isDisabled,
    onMouseLeave: () =&gt; setHoveredTransformItemName(null),
    onMouseEnter: () =&gt; setHoveredTransformItemName(name),
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_icon, {
      icon: icon,
      showColors: true
    }), title]
  });
}
/* harmony default export */ const block_transformations_menu = (BlockTransformationsMenu);

;// ./node_modules/@wordpress/block-editor/build-module/components/block-styles/utils.js
/**
 * WordPress dependencies
 */



/**
 * Returns the active style from the given className.
 *
 * @param {Array}  styles    Block styles.
 * @param {string} className Class name
 *
 * @return {?Object} The active style.
 */
function getActiveStyle(styles, className) {
  for (const style of new (external_wp_tokenList_default())(className).values()) {
    if (style.indexOf(&#039;is-style-&#039;) === -1) {
      continue;
    }
    const potentialStyleName = style.substring(9);
    const activeStyle = styles?.find(({
      name
    }) =&gt; name === potentialStyleName);
    if (activeStyle) {
      return activeStyle;
    }
  }
  return getDefaultStyle(styles);
}

/**
 * Replaces the active style in the block&#039;s className.
 *
 * @param {string}  className   Class name.
 * @param {?Object} activeStyle The replaced style.
 * @param {Object}  newStyle    The replacing style.
 *
 * @return {string} The updated className.
 */
function replaceActiveStyle(className, activeStyle, newStyle) {
  const list = new (external_wp_tokenList_default())(className);
  if (activeStyle) {
    list.remove(&#039;is-style-&#039; + activeStyle.name);
  }
  list.add(&#039;is-style-&#039; + newStyle.name);
  return list.value;
}

/**
 * Returns a collection of styles that can be represented on the frontend.
 * The function checks a style collection for a default style. If none is found, it adds one to
 * act as a fallback for when there is no active style applied to a block. The default item also serves
 * as a switch on the frontend to deactivate non-default styles.
 *
 * @param {Array} styles Block styles.
 *
 * @return {Array&lt;Object?&gt;}        The style collection.
 */
function getRenderedStyles(styles) {
  if (!styles || styles.length === 0) {
    return [];
  }
  return getDefaultStyle(styles) ? styles : [{
    name: &#039;default&#039;,
    label: (0,external_wp_i18n_namespaceObject._x)(&#039;Default&#039;, &#039;block style&#039;),
    isDefault: true
  }, ...styles];
}

/**
 * Returns a style object from a collection of styles where that style object is the default block style.
 *
 * @param {Array} styles Block styles.
 *
 * @return {?Object}        The default style object, if found.
 */
function getDefaultStyle(styles) {
  return styles?.find(style =&gt; style.isDefault);
}

;// ./node_modules/@wordpress/block-editor/build-module/components/block-styles/use-styles-for-block.js
/**
 * WordPress dependencies
 */




/**
 * Internal dependencies
 */



/**
 *
 * @param {WPBlock}     block Block object.
 * @param {WPBlockType} type  Block type settings.
 * @return {WPBlock}          A generic block ready for styles preview.
 */
function useGenericPreviewBlock(block, type) {
  return (0,external_wp_element_namespaceObject.useMemo)(() =&gt; {
    const example = type?.example;
    const blockName = type?.name;
    if (example &amp;&amp; blockName) {
      return (0,external_wp_blocks_namespaceObject.getBlockFromExample)(blockName, {
        attributes: example.attributes,
        innerBlocks: example.innerBlocks
      });
    }
    if (block) {
      return (0,external_wp_blocks_namespaceObject.cloneBlock)(block);
    }
  }, [type?.example ? block?.name : block, type]);
}

/**
 * @typedef useStylesForBlocksArguments
 * @property {string}     clientId Block client ID.
 * @property {() =&gt; void} onSwitch Block style switch callback function.
 */

/**
 *
 * @param {useStylesForBlocksArguments} useStylesForBlocks arguments.
 * @return {Object}                                         Results of the select methods.
 */
function useStylesForBlocks({
  clientId,
  onSwitch
}) {
  const selector = select =&gt; {
    const {
      getBlock
    } = select(store);
    const block = getBlock(clientId);
    if (!block) {
      return {};
    }
    const blockType = (0,external_wp_blocks_namespaceObject.getBlockType)(block.name);
    const {
      getBlockStyles
    } = select(external_wp_blocks_namespaceObject.store);
    return {
      block,
      blockType,
      styles: getBlockStyles(block.name),
      className: block.attributes.className || &#039;&#039;
    };
  };
  const {
    styles,
    block,
    blockType,
    className
  } = (0,external_wp_data_namespaceObject.useSelect)(selector, [clientId]);
  const {
    updateBlockAttributes
  } = (0,external_wp_data_namespaceObject.useDispatch)(store);
  const stylesToRender = getRenderedStyles(styles);
  const activeStyle = getActiveStyle(stylesToRender, className);
  const genericPreviewBlock = useGenericPreviewBlock(block, blockType);
  const onSelect = style =&gt; {
    const styleClassName = replaceActiveStyle(className, activeStyle, style);
    updateBlockAttributes(clientId, {
      className: styleClassName
    });
    onSwitch();
  };
  return {
    onSelect,
    stylesToRender,
    activeStyle,
    genericPreviewBlock,
    className
  };
}

;// ./node_modules/@wordpress/block-editor/build-module/components/block-styles/menu-items.js
/**
 * WordPress dependencies
 */



/**
 * Internal dependencies
 */


const menu_items_noop = () =&gt; {};
function BlockStylesMenuItems({
  clientId,
  onSwitch = menu_items_noop
}) {
  const {
    onSelect,
    stylesToRender,
    activeStyle
  } = useStylesForBlocks({
    clientId,
    onSwitch
  });
  if (!stylesToRender || stylesToRender.length === 0) {
    return null;
  }
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_ReactJSXRuntime_namespaceObject.Fragment, {
    children: stylesToRender.map(style =&gt; {
      const menuItemText = style.label || style.name;
      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, {
        icon: activeStyle.name === style.name ? library_check : null,
        onClick: () =&gt; onSelect(style),
        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalText, {
          as: &quot;span&quot;,
          limit: 18,
          ellipsizeMode: &quot;tail&quot;,
          truncate: true,
          children: menuItemText
        })
      }, style.name);
    })
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/block-switcher/block-styles-menu.js
/**
 * WordPress dependencies
 */



/**
 * Internal dependencies
 */


function BlockStylesMenu({
  hoveredBlock,
  onSwitch
}) {
  const {
    clientId
  } = hoveredBlock;
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuGroup, {
    label: (0,external_wp_i18n_namespaceObject.__)(&#039;Styles&#039;),
    className: &quot;block-editor-block-switcher__styles__menugroup&quot;,
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockStylesMenuItems, {
      clientId: clientId,
      onSwitch: onSwitch
    })
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/block-switcher/utils.js
/**
 * WordPress dependencies
 */


/**
 * Try to find a matching block by a block&#039;s name in a provided
 * block. We recurse through InnerBlocks and return the reference
 * of the matched block (it could be an InnerBlock).
 * If no match is found return nothing.
 *
 * @param {WPBlock} block             The block to try to find a match.
 * @param {string}  selectedBlockName The block&#039;s name to use for matching condition.
 * @param {Set}     consumedBlocks    A set holding the previously matched/consumed blocks.
 *
 * @return {WPBlock | undefined} The matched block if found or nothing(`undefined`).
 */
const getMatchingBlockByName = (block, selectedBlockName, consumedBlocks = new Set()) =&gt; {
  const {
    clientId,
    name,
    innerBlocks = []
  } = block;
  // Check if block has been consumed already.
  if (consumedBlocks.has(clientId)) {
    return;
  }
  if (name === selectedBlockName) {
    return block;
  }
  // Try to find a matching block from InnerBlocks recursively.
  for (const innerBlock of innerBlocks) {
    const match = getMatchingBlockByName(innerBlock, selectedBlockName, consumedBlocks);
    if (match) {
      return match;
    }
  }
};

/**
 * Find and return the block attributes to retain through
 * the transformation, based on Block Type&#039;s `role:content`
 * attributes. If no `role:content` attributes exist,
 * return selected block&#039;s attributes.
 *
 * @param {string} name       Block type&#039;s namespaced name.
 * @param {Object} attributes Selected block&#039;s attributes.
 * @return {Object} The block&#039;s attributes to retain.
 */
const getRetainedBlockAttributes = (name, attributes) =&gt; {
  const contentAttributes = (0,external_wp_blocks_namespaceObject.getBlockAttributesNamesByRole)(name, &#039;content&#039;);
  if (!contentAttributes?.length) {
    return attributes;
  }
  return contentAttributes.reduce((_accumulator, attribute) =&gt; {
    if (attributes[attribute]) {
      _accumulator[attribute] = attributes[attribute];
    }
    return _accumulator;
  }, {});
};

;// ./node_modules/@wordpress/block-editor/build-module/components/block-switcher/use-transformed-patterns.js
/**
 * WordPress dependencies
 */



/**
 * Internal dependencies
 */


/**
 * Mutate the matched block&#039;s attributes by getting
 * which block type&#039;s attributes to retain and prioritize
 * them in the merging of the attributes.
 *
 * @param {WPBlock} match         The matched block.
 * @param {WPBlock} selectedBlock The selected block.
 * @return {void}
 */
const transformMatchingBlock = (match, selectedBlock) =&gt; {
  // Get the block attributes to retain through the transformation.
  const retainedBlockAttributes = getRetainedBlockAttributes(selectedBlock.name, selectedBlock.attributes);
  match.attributes = {
    ...match.attributes,
    ...retainedBlockAttributes
  };
};

/**
 * By providing the selected blocks and pattern&#039;s blocks
 * find the matching blocks, transform them and return them.
 * If not all selected blocks are matched, return nothing.
 *
 * @param {WPBlock[]} selectedBlocks The selected blocks.
 * @param {WPBlock[]} patternBlocks  The pattern&#039;s blocks.
 * @return {WPBlock[]|void} The transformed pattern&#039;s blocks or undefined if not all selected blocks have been matched.
 */
const getPatternTransformedBlocks = (selectedBlocks, patternBlocks) =&gt; {
  // Clone Pattern&#039;s blocks to produce new clientIds and be able to mutate the matches.
  const _patternBlocks = patternBlocks.map(block =&gt; (0,external_wp_blocks_namespaceObject.cloneBlock)(block));
  /**
   * Keep track of the consumed pattern blocks.
   * This is needed because we loop the selected blocks
   * and for example we may have selected two paragraphs and
   * the pattern&#039;s blocks could have more `paragraphs`.
   */
  const consumedBlocks = new Set();
  for (const selectedBlock of selectedBlocks) {
    let isMatch = false;
    for (const patternBlock of _patternBlocks) {
      const match = getMatchingBlockByName(patternBlock, selectedBlock.name, consumedBlocks);
      if (!match) {
        continue;
      }
      isMatch = true;
      consumedBlocks.add(match.clientId);
      // We update (mutate) the matching pattern block.
      transformMatchingBlock(match, selectedBlock);
      // No need to loop through other pattern&#039;s blocks.
      break;
    }
    // Bail early if a selected block has not been matched.
    if (!isMatch) {
      return;
    }
  }
  return _patternBlocks;
};

/**
 * @typedef {WPBlockPattern &amp; {transformedBlocks: WPBlock[]}} TransformedBlockPattern
 */

/**
 * Custom hook that accepts patterns from state and the selected
 * blocks and tries to match these with the pattern&#039;s blocks.
 * If all selected blocks are matched with a Pattern&#039;s block,
 * we transform them by retaining block&#039;s attributes with `role:content`.
 * The transformed pattern&#039;s blocks are set to a new pattern
 * property `transformedBlocks`.
 *
 * @param {WPBlockPattern[]} patterns       Patterns from state.
 * @param {WPBlock[]}        selectedBlocks The currently selected blocks.
 * @return {TransformedBlockPattern[]} Returns the eligible matched patterns with all the selected blocks.
 */
const useTransformedPatterns = (patterns, selectedBlocks) =&gt; {
  return (0,external_wp_element_namespaceObject.useMemo)(() =&gt; patterns.reduce((accumulator, _pattern) =&gt; {
    const transformedBlocks = getPatternTransformedBlocks(selectedBlocks, _pattern.blocks);
    if (transformedBlocks) {
      accumulator.push({
        ..._pattern,
        transformedBlocks
      });
    }
    return accumulator;
  }, []), [patterns, selectedBlocks]);
};
/* harmony default export */ const use_transformed_patterns = (useTransformedPatterns);

;// ./node_modules/@wordpress/block-editor/build-module/components/block-switcher/pattern-transformations-menu.js
/**
 * WordPress dependencies
 */






/**
 * Internal dependencies
 */



function PatternTransformationsMenu({
  blocks,
  patterns: statePatterns,
  onSelect
}) {
  const [showTransforms, setShowTransforms] = (0,external_wp_element_namespaceObject.useState)(false);
  const patterns = use_transformed_patterns(statePatterns, blocks);
  if (!patterns.length) {
    return null;
  }
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.MenuGroup, {
    className: &quot;block-editor-block-switcher__pattern__transforms__menugroup&quot;,
    children: [showTransforms &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PreviewPatternsPopover, {
      patterns: patterns,
      onSelect: onSelect
    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, {
      onClick: event =&gt; {
        event.preventDefault();
        setShowTransforms(!showTransforms);
      },
      icon: chevron_right,
      children: (0,external_wp_i18n_namespaceObject.__)(&#039;Patterns&#039;)
    })]
  });
}
function PreviewPatternsPopover({
  patterns,
  onSelect
}) {
  const isMobile = (0,external_wp_compose_namespaceObject.useViewportMatch)(&#039;medium&#039;, &#039;&lt;&#039;);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
    className: &quot;block-editor-block-switcher__popover-preview-container&quot;,
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Popover, {
      className: &quot;block-editor-block-switcher__popover-preview&quot;,
      placement: isMobile ? &#039;bottom&#039; : &#039;right-start&#039;,
      offset: 16,
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
        className: &quot;block-editor-block-switcher__preview is-pattern-list-preview&quot;,
        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(pattern_transformations_menu_BlockPatternsList, {
          patterns: patterns,
          onSelect: onSelect
        })
      })
    })
  });
}
function pattern_transformations_menu_BlockPatternsList({
  patterns,
  onSelect
}) {
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Composite, {
    role: &quot;listbox&quot;,
    className: &quot;block-editor-block-switcher__preview-patterns-container&quot;,
    &quot;aria-label&quot;: (0,external_wp_i18n_namespaceObject.__)(&#039;Patterns list&#039;),
    children: patterns.map(pattern =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(pattern_transformations_menu_BlockPattern, {
      pattern: pattern,
      onSelect: onSelect
    }, pattern.name))
  });
}
function pattern_transformations_menu_BlockPattern({
  pattern,
  onSelect
}) {
  // TODO check pattern/preview width...
  const baseClassName = &#039;block-editor-block-switcher__preview-patterns-container&#039;;
  const descriptionId = (0,external_wp_compose_namespaceObject.useInstanceId)(pattern_transformations_menu_BlockPattern, `${baseClassName}-list__item-description`);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;div&quot;, {
    className: `${baseClassName}-list__list-item`,
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.Composite.Item, {
      render: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
        role: &quot;option&quot;,
        &quot;aria-label&quot;: pattern.title,
        &quot;aria-describedby&quot;: pattern.description ? descriptionId : undefined,
        className: `${baseClassName}-list__item`
      }),
      onClick: () =&gt; onSelect(pattern.transformedBlocks),
      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_preview, {
        blocks: pattern.transformedBlocks,
        viewportWidth: pattern.viewportWidth || 500
      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
        className: `${baseClassName}-list__item-title`,
        children: pattern.title
      })]
    }), !!pattern.description &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.VisuallyHidden, {
      id: descriptionId,
      children: pattern.description
    })]
  });
}
/* harmony default export */ const pattern_transformations_menu = (PatternTransformationsMenu);

;// ./node_modules/@wordpress/block-editor/build-module/components/block-switcher/index.js
/**
 * WordPress dependencies
 */







/**
 * Internal dependencies
 */








function BlockSwitcherDropdownMenuContents({
  onClose,
  clientIds,
  hasBlockStyles,
  canRemove
}) {
  const {
    replaceBlocks,
    multiSelect,
    updateBlockAttributes
  } = (0,external_wp_data_namespaceObject.useDispatch)(store);
  const {
    possibleBlockTransformations,
    patterns,
    blocks,
    isUsingBindings
  } = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      getBlockAttributes,
      getBlocksByClientId,
      getBlockRootClientId,
      getBlockTransformItems,
      __experimentalGetPatternTransformItems
    } = select(store);
    const rootClientId = getBlockRootClientId(clientIds[0]);
    const _blocks = getBlocksByClientId(clientIds);
    return {
      blocks: _blocks,
      possibleBlockTransformations: getBlockTransformItems(_blocks, rootClientId),
      patterns: __experimentalGetPatternTransformItems(_blocks, rootClientId),
      isUsingBindings: clientIds.every(clientId =&gt; !!getBlockAttributes(clientId)?.metadata?.bindings)
    };
  }, [clientIds]);
  const blockVariationTransformations = useBlockVariationTransforms({
    clientIds,
    blocks
  });
  function selectForMultipleBlocks(insertedBlocks) {
    if (insertedBlocks.length &gt; 1) {
      multiSelect(insertedBlocks[0].clientId, insertedBlocks[insertedBlocks.length - 1].clientId);
    }
  }
  // Simple block transformation based on the `Block Transforms` API.
  function onBlockTransform(name) {
    const newBlocks = (0,external_wp_blocks_namespaceObject.switchToBlockType)(blocks, name);
    replaceBlocks(clientIds, newBlocks);
    selectForMultipleBlocks(newBlocks);
  }
  function onBlockVariationTransform(name) {
    updateBlockAttributes(blocks[0].clientId, {
      ...blockVariationTransformations.find(({
        name: variationName
      }) =&gt; variationName === name).attributes
    });
  }
  // Pattern transformation through the `Patterns` API.
  function onPatternTransform(transformedBlocks) {
    replaceBlocks(clientIds, transformedBlocks);
    selectForMultipleBlocks(transformedBlocks);
  }
  /**
   * The `isTemplate` check is a stopgap solution here.
   * Ideally, the Transforms API should handle this
   * by allowing to exclude blocks from wildcard transformations.
   */
  const isSingleBlock = blocks.length === 1;
  const isTemplate = isSingleBlock &amp;&amp; (0,external_wp_blocks_namespaceObject.isTemplatePart)(blocks[0]);
  const hasPossibleBlockTransformations = !!possibleBlockTransformations.length &amp;&amp; canRemove &amp;&amp; !isTemplate;
  const hasPossibleBlockVariationTransformations = !!blockVariationTransformations?.length;
  const hasPatternTransformation = !!patterns?.length &amp;&amp; canRemove;
  const hasBlockOrBlockVariationTransforms = hasPossibleBlockTransformations || hasPossibleBlockVariationTransformations;
  const hasContents = hasBlockStyles || hasBlockOrBlockVariationTransforms || hasPatternTransformation;
  if (!hasContents) {
    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;p&quot;, {
      className: &quot;block-editor-block-switcher__no-transforms&quot;,
      children: (0,external_wp_i18n_namespaceObject.__)(&#039;No transforms.&#039;)
    });
  }
  const connectedBlockDescription = isSingleBlock ? (0,external_wp_i18n_namespaceObject._x)(&#039;This block is connected.&#039;, &#039;block toolbar button label and description&#039;) : (0,external_wp_i18n_namespaceObject._x)(&#039;These blocks are connected.&#039;, &#039;block toolbar button label and description&#039;);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;div&quot;, {
    className: &quot;block-editor-block-switcher__container&quot;,
    children: [hasPatternTransformation &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(pattern_transformations_menu, {
      blocks: blocks,
      patterns: patterns,
      onSelect: transformedBlocks =&gt; {
        onPatternTransform(transformedBlocks);
        onClose();
      }
    }), hasBlockOrBlockVariationTransforms &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_transformations_menu, {
      className: &quot;block-editor-block-switcher__transforms__menugroup&quot;,
      possibleBlockTransformations: possibleBlockTransformations,
      possibleBlockVariationTransformations: blockVariationTransformations,
      blocks: blocks,
      onSelect: name =&gt; {
        onBlockTransform(name);
        onClose();
      },
      onSelectVariation: name =&gt; {
        onBlockVariationTransform(name);
        onClose();
      }
    }), hasBlockStyles &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockStylesMenu, {
      hoveredBlock: blocks[0],
      onSwitch: onClose
    }), isUsingBindings &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuGroup, {
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalText, {
        className: &quot;block-editor-block-switcher__binding-indicator&quot;,
        children: connectedBlockDescription
      })
    })]
  });
}
const BlockSwitcher = ({
  clientIds
}) =&gt; {
  const {
    hasContentOnlyLocking,
    canRemove,
    hasBlockStyles,
    icon,
    invalidBlocks,
    isReusable,
    isTemplate,
    isDisabled
  } = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      getTemplateLock,
      getBlocksByClientId,
      getBlockAttributes,
      canRemoveBlocks,
      getBlockEditingMode
    } = select(store);
    const {
      getBlockStyles,
      getBlockType,
      getActiveBlockVariation
    } = select(external_wp_blocks_namespaceObject.store);
    const _blocks = getBlocksByClientId(clientIds);
    if (!_blocks.length || _blocks.some(block =&gt; !block)) {
      return {
        invalidBlocks: true
      };
    }
    const [{
      name: firstBlockName
    }] = _blocks;
    const _isSingleBlockSelected = _blocks.length === 1;
    const blockType = getBlockType(firstBlockName);
    const editingMode = getBlockEditingMode(clientIds[0]);
    let _icon;
    let _hasTemplateLock;
    if (_isSingleBlockSelected) {
      const match = getActiveBlockVariation(firstBlockName, getBlockAttributes(clientIds[0]));
      // Take into account active block variations.
      _icon = match?.icon || blockType.icon;
      _hasTemplateLock = getTemplateLock(clientIds[0]) === &#039;contentOnly&#039;;
    } else {
      const isSelectionOfSameType = new Set(_blocks.map(({
        name
      }) =&gt; name)).size === 1;
      _hasTemplateLock = clientIds.some(id =&gt; getTemplateLock(id) === &#039;contentOnly&#039;);
      // When selection consists of blocks of multiple types, display an
      // appropriate icon to communicate the non-uniformity.
      _icon = isSelectionOfSameType ? blockType.icon : library_copy;
    }
    return {
      canRemove: canRemoveBlocks(clientIds),
      hasBlockStyles: _isSingleBlockSelected &amp;&amp; !!getBlockStyles(firstBlockName)?.length,
      icon: _icon,
      isReusable: _isSingleBlockSelected &amp;&amp; (0,external_wp_blocks_namespaceObject.isReusableBlock)(_blocks[0]),
      isTemplate: _isSingleBlockSelected &amp;&amp; (0,external_wp_blocks_namespaceObject.isTemplatePart)(_blocks[0]),
      hasContentOnlyLocking: _hasTemplateLock,
      isDisabled: editingMode !== &#039;default&#039;
    };
  }, [clientIds]);
  const blockTitle = useBlockDisplayTitle({
    clientId: clientIds?.[0],
    maximumLength: 35
  });
  const showIconLabels = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; select(external_wp_preferences_namespaceObject.store).get(&#039;core&#039;, &#039;showIconLabels&#039;), []);
  if (invalidBlocks) {
    return null;
  }
  const isSingleBlock = clientIds.length === 1;
  const blockSwitcherLabel = isSingleBlock ? blockTitle : (0,external_wp_i18n_namespaceObject.__)(&#039;Multiple blocks selected&#039;);
  const blockIndicatorText = (isReusable || isTemplate) &amp;&amp; !showIconLabels &amp;&amp; blockTitle ? blockTitle : undefined;
  const hideDropdown = isDisabled || !hasBlockStyles &amp;&amp; !canRemove || hasContentOnlyLocking;
  if (hideDropdown) {
    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarGroup, {
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarButton, {
        disabled: true,
        className: &quot;block-editor-block-switcher__no-switcher-icon&quot;,
        title: blockSwitcherLabel,
        icon: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_icon, {
          className: &quot;block-editor-block-switcher__toggle&quot;,
          icon: icon,
          showColors: true
        }),
        text: blockIndicatorText
      })
    });
  }
  const blockSwitcherDescription = isSingleBlock ? (0,external_wp_i18n_namespaceObject.__)(&#039;Change block type or style&#039;) : (0,external_wp_i18n_namespaceObject.sprintf)(/* translators: %d: number of blocks. */
  (0,external_wp_i18n_namespaceObject._n)(&#039;Change type of %d block&#039;, &#039;Change type of %d blocks&#039;, clientIds.length), clientIds.length);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarGroup, {
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarItem, {
      children: toggleProps =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.DropdownMenu, {
        className: &quot;block-editor-block-switcher&quot;,
        label: blockSwitcherLabel,
        popoverProps: {
          placement: &#039;bottom-start&#039;,
          className: &#039;block-editor-block-switcher__popover&#039;
        },
        icon: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_icon, {
          className: &quot;block-editor-block-switcher__toggle&quot;,
          icon: icon,
          showColors: true
        }),
        text: blockIndicatorText,
        toggleProps: {
          description: blockSwitcherDescription,
          ...toggleProps
        },
        menuProps: {
          orientation: &#039;both&#039;
        },
        children: ({
          onClose
        }) =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockSwitcherDropdownMenuContents, {
          onClose: onClose,
          clientIds: clientIds,
          hasBlockStyles: hasBlockStyles,
          canRemove: canRemove
        })
      })
    })
  });
};
/* harmony default export */ const block_switcher = (BlockSwitcher);

;// ./node_modules/@wordpress/block-editor/build-module/components/block-toolbar/block-toolbar-last-item.js
/**
 * WordPress dependencies
 */

const {
  Fill: __unstableBlockToolbarLastItem,
  Slot: block_toolbar_last_item_Slot
} = (0,external_wp_components_namespaceObject.createSlotFill)(&#039;__unstableBlockToolbarLastItem&#039;);
__unstableBlockToolbarLastItem.Slot = block_toolbar_last_item_Slot;
/* harmony default export */ const block_toolbar_last_item = (__unstableBlockToolbarLastItem);

;// ./node_modules/@wordpress/block-editor/build-module/hooks/supports.js
/**
 * WordPress dependencies
 */


const ALIGN_SUPPORT_KEY = &#039;align&#039;;
const ALIGN_WIDE_SUPPORT_KEY = &#039;alignWide&#039;;
const supports_BORDER_SUPPORT_KEY = &#039;__experimentalBorder&#039;;
const supports_COLOR_SUPPORT_KEY = &#039;color&#039;;
const CUSTOM_CLASS_NAME_SUPPORT_KEY = &#039;customClassName&#039;;
const supports_FONT_FAMILY_SUPPORT_KEY = &#039;typography.__experimentalFontFamily&#039;;
const supports_FONT_SIZE_SUPPORT_KEY = &#039;typography.fontSize&#039;;
const supports_LINE_HEIGHT_SUPPORT_KEY = &#039;typography.lineHeight&#039;;
/**
 * Key within block settings&#039; support array indicating support for font style.
 */
const supports_FONT_STYLE_SUPPORT_KEY = &#039;typography.__experimentalFontStyle&#039;;
/**
 * Key within block settings&#039; support array indicating support for font weight.
 */
const supports_FONT_WEIGHT_SUPPORT_KEY = &#039;typography.__experimentalFontWeight&#039;;
/**
 * Key within block settings&#039; supports array indicating support for text
 * align e.g. settings found in `block.json`.
 */
const supports_TEXT_ALIGN_SUPPORT_KEY = &#039;typography.textAlign&#039;;
/**
 * Key within block settings&#039; supports array indicating support for text
 * columns e.g. settings found in `block.json`.
 */
const supports_TEXT_COLUMNS_SUPPORT_KEY = &#039;typography.textColumns&#039;;
/**
 * Key within block settings&#039; supports array indicating support for text
 * decorations e.g. settings found in `block.json`.
 */
const supports_TEXT_DECORATION_SUPPORT_KEY = &#039;typography.__experimentalTextDecoration&#039;;
/**
 * Key within block settings&#039; supports array indicating support for writing mode
 * e.g. settings found in `block.json`.
 */
const supports_WRITING_MODE_SUPPORT_KEY = &#039;typography.__experimentalWritingMode&#039;;
/**
 * Key within block settings&#039; supports array indicating support for text
 * transforms e.g. settings found in `block.json`.
 */
const supports_TEXT_TRANSFORM_SUPPORT_KEY = &#039;typography.__experimentalTextTransform&#039;;

/**
 * Key within block settings&#039; supports array indicating support for letter-spacing
 * e.g. settings found in `block.json`.
 */
const supports_LETTER_SPACING_SUPPORT_KEY = &#039;typography.__experimentalLetterSpacing&#039;;
const LAYOUT_SUPPORT_KEY = &#039;layout&#039;;
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];
const EFFECTS_SUPPORT_KEYS = [&#039;shadow&#039;];
const supports_SPACING_SUPPORT_KEY = &#039;spacing&#039;;
const supports_styleSupportKeys = [...EFFECTS_SUPPORT_KEYS, ...supports_TYPOGRAPHY_SUPPORT_KEYS, supports_BORDER_SUPPORT_KEY, supports_COLOR_SUPPORT_KEY, supports_SPACING_SUPPORT_KEY];

/**
 * Returns true if the block defines support for align.
 *
 * @param {string|Object} nameOrType Block name or type object.
 * @return {boolean} Whether the block supports the feature.
 */
const hasAlignSupport = nameOrType =&gt; (0,external_wp_blocks_namespaceObject.hasBlockSupport)(nameOrType, ALIGN_SUPPORT_KEY);

/**
 * Returns the block support value for align, if defined.
 *
 * @param {string|Object} nameOrType Block name or type object.
 * @return {unknown} The block support value.
 */
const getAlignSupport = nameOrType =&gt; getBlockSupport(nameOrType, ALIGN_SUPPORT_KEY);

/**
 * Returns true if the block defines support for align wide.
 *
 * @param {string|Object} nameOrType Block name or type object.
 * @return {boolean} Whether the block supports the feature.
 */
const hasAlignWideSupport = nameOrType =&gt; hasBlockSupport(nameOrType, ALIGN_WIDE_SUPPORT_KEY);

/**
 * Returns the block support value for align wide, if defined.
 *
 * @param {string|Object} nameOrType Block name or type object.
 * @return {unknown} The block support value.
 */
const getAlignWideSupport = nameOrType =&gt; getBlockSupport(nameOrType, ALIGN_WIDE_SUPPORT_KEY);

/**
 * Determine whether there is block support for border properties.
 *
 * @param {string|Object} nameOrType Block name or type object.
 * @param {string}        feature    Border feature to check support for.
 *
 * @return {boolean} Whether there is support.
 */
function supports_hasBorderSupport(nameOrType, feature = &#039;any&#039;) {
  if (external_wp_element_namespaceObject.Platform.OS !== &#039;web&#039;) {
    return false;
  }
  const support = (0,external_wp_blocks_namespaceObject.getBlockSupport)(nameOrType, supports_BORDER_SUPPORT_KEY);
  if (support === true) {
    return true;
  }
  if (feature === &#039;any&#039;) {
    return !!(support?.color || support?.radius || support?.width || support?.style);
  }
  return !!support?.[feature];
}

/**
 * Get block support for border properties.
 *
 * @param {string|Object} nameOrType Block name or type object.
 * @param {string}        feature    Border feature to get.
 *
 * @return {unknown} The block support.
 */
const getBorderSupport = (nameOrType, feature) =&gt; getBlockSupport(nameOrType, [supports_BORDER_SUPPORT_KEY, feature]);

/**
 * Returns true if the block defines support for color.
 *
 * @param {string|Object} nameOrType Block name or type object.
 * @return {boolean} Whether the block supports the feature.
 */
const supports_hasColorSupport = nameOrType =&gt; {
  const colorSupport = getBlockSupport(nameOrType, supports_COLOR_SUPPORT_KEY);
  return colorSupport &amp;&amp; (colorSupport.link === true || colorSupport.gradient === true || colorSupport.background !== false || colorSupport.text !== false);
};

/**
 * Returns true if the block defines support for link color.
 *
 * @param {string|Object} nameOrType Block name or type object.
 * @return {boolean} Whether the block supports the feature.
 */
const supports_hasLinkColorSupport = nameOrType =&gt; {
  if (Platform.OS !== &#039;web&#039;) {
    return false;
  }
  const colorSupport = getBlockSupport(nameOrType, supports_COLOR_SUPPORT_KEY);
  return colorSupport !== null &amp;&amp; typeof colorSupport === &#039;object&#039; &amp;&amp; !!colorSupport.link;
};

/**
 * Returns true if the block defines support for gradient color.
 *
 * @param {string|Object} nameOrType Block name or type object.
 * @return {boolean} Whether the block supports the feature.
 */
const supports_hasGradientSupport = nameOrType =&gt; {
  const colorSupport = (0,external_wp_blocks_namespaceObject.getBlockSupport)(nameOrType, supports_COLOR_SUPPORT_KEY);
  return colorSupport !== null &amp;&amp; typeof colorSupport === &#039;object&#039; &amp;&amp; !!colorSupport.gradients;
};

/**
 * Returns true if the block defines support for background color.
 *
 * @param {string|Object} nameOrType Block name or type object.
 * @return {boolean} Whether the block supports the feature.
 */
const supports_hasBackgroundColorSupport = nameOrType =&gt; {
  const colorSupport = (0,external_wp_blocks_namespaceObject.getBlockSupport)(nameOrType, supports_COLOR_SUPPORT_KEY);
  return colorSupport &amp;&amp; colorSupport.background !== false;
};

/**
 * Returns true if the block defines support for text-align.
 *
 * @param {string|Object} nameOrType Block name or type object.
 * @return {boolean} Whether the block supports the feature.
 */
const hasTextAlignSupport = nameOrType =&gt; (0,external_wp_blocks_namespaceObject.hasBlockSupport)(nameOrType, supports_TEXT_ALIGN_SUPPORT_KEY);

/**
 * Returns the block support value for text-align, if defined.
 *
 * @param {string|Object} nameOrType Block name or type object.
 * @return {unknown} The block support value.
 */
const getTextAlignSupport = nameOrType =&gt; getBlockSupport(nameOrType, supports_TEXT_ALIGN_SUPPORT_KEY);

/**
 * Returns true if the block defines support for background color.
 *
 * @param {string|Object} nameOrType Block name or type object.
 * @return {boolean} Whether the block supports the feature.
 */
const supports_hasTextColorSupport = nameOrType =&gt; {
  const colorSupport = (0,external_wp_blocks_namespaceObject.getBlockSupport)(nameOrType, supports_COLOR_SUPPORT_KEY);
  return colorSupport &amp;&amp; colorSupport.text !== false;
};

/**
 * Get block support for color properties.
 *
 * @param {string|Object} nameOrType Block name or type object.
 * @param {string}        feature    Color feature to get.
 *
 * @return {unknown} The block support.
 */
const getColorSupport = (nameOrType, feature) =&gt; getBlockSupport(nameOrType, [supports_COLOR_SUPPORT_KEY, feature]);

/**
 * Returns true if the block defines support for custom class name.
 *
 * @param {string|Object} nameOrType Block name or type object.
 * @return {boolean} Whether the block supports the feature.
 */
const hasCustomClassNameSupport = nameOrType =&gt; (0,external_wp_blocks_namespaceObject.hasBlockSupport)(nameOrType, CUSTOM_CLASS_NAME_SUPPORT_KEY, true);

/**
 * Returns the block support value for custom class name, if defined.
 *
 * @param {string|Object} nameOrType Block name or type object.
 * @return {unknown} The block support value.
 */
const getCustomClassNameSupport = nameOrType =&gt; getBlockSupport(nameOrType, CUSTOM_CLASS_NAME_SUPPORT_KEY, true);

/**
 * Returns true if the block defines support for font family.
 *
 * @param {string|Object} nameOrType Block name or type object.
 * @return {boolean} Whether the block supports the feature.
 */
const hasFontFamilySupport = nameOrType =&gt; (0,external_wp_blocks_namespaceObject.hasBlockSupport)(nameOrType, supports_FONT_FAMILY_SUPPORT_KEY);

/**
 * Returns the block support value for font family, if defined.
 *
 * @param {string|Object} nameOrType Block name or type object.
 * @return {unknown} The block support value.
 */
const getFontFamilySupport = nameOrType =&gt; getBlockSupport(nameOrType, supports_FONT_FAMILY_SUPPORT_KEY);

/**
 * Returns true if the block defines support for font size.
 *
 * @param {string|Object} nameOrType Block name or type object.
 * @return {boolean} Whether the block supports the feature.
 */
const hasFontSizeSupport = nameOrType =&gt; (0,external_wp_blocks_namespaceObject.hasBlockSupport)(nameOrType, supports_FONT_SIZE_SUPPORT_KEY);

/**
 * Returns the block support value for font size, if defined.
 *
 * @param {string|Object} nameOrType Block name or type object.
 * @return {unknown} The block support value.
 */
const getFontSizeSupport = nameOrType =&gt; getBlockSupport(nameOrType, supports_FONT_SIZE_SUPPORT_KEY);

/**
 * Returns true if the block defines support for layout.
 *
 * @param {string|Object} nameOrType Block name or type object.
 * @return {boolean} Whether the block supports the feature.
 */
const hasLayoutSupport = nameOrType =&gt; (0,external_wp_blocks_namespaceObject.hasBlockSupport)(nameOrType, LAYOUT_SUPPORT_KEY);

/**
 * Returns the block support value for layout, if defined.
 *
 * @param {string|Object} nameOrType Block name or type object.
 * @return {unknown} The block support value.
 */
const getLayoutSupport = nameOrType =&gt; getBlockSupport(nameOrType, LAYOUT_SUPPORT_KEY);

/**
 * Returns true if the block defines support for style.
 *
 * @param {string|Object} nameOrType Block name or type object.
 * @return {boolean} Whether the block supports the feature.
 */
const supports_hasStyleSupport = nameOrType =&gt; supports_styleSupportKeys.some(key =&gt; (0,external_wp_blocks_namespaceObject.hasBlockSupport)(nameOrType, key));

;// ./node_modules/@wordpress/block-editor/build-module/components/use-paste-styles/index.js
/**
 * WordPress dependencies
 */






/**
 * Internal dependencies
 */



/**
 * Determine if the copied text looks like serialized blocks or not.
 * Since plain text will always get parsed into a freeform block,
 * we check that if the parsed blocks is anything other than that.
 *
 * @param {string} text The copied text.
 * @return {boolean} True if the text looks like serialized blocks, false otherwise.
 */
function hasSerializedBlocks(text) {
  try {
    const blocks = (0,external_wp_blocks_namespaceObject.parse)(text, {
      __unstableSkipMigrationLogs: true,
      __unstableSkipAutop: true
    });
    if (blocks.length === 1 &amp;&amp; blocks[0].name === &#039;core/freeform&#039;) {
      // It&#039;s likely that the text is just plain text and not serialized blocks.
      return false;
    }
    return true;
  } catch (err) {
    // Parsing error, the text is not serialized blocks.
    // (Even though that it technically won&#039;t happen)
    return false;
  }
}

/**
 * Style attributes are attributes being added in `block-editor/src/hooks/*`.
 * (Except for some unrelated to style like `anchor` or `settings`.)
 * They generally represent the default block supports.
 */
const STYLE_ATTRIBUTES = {
  align: hasAlignSupport,
  borderColor: nameOrType =&gt; supports_hasBorderSupport(nameOrType, &#039;color&#039;),
  backgroundColor: supports_hasBackgroundColorSupport,
  textAlign: hasTextAlignSupport,
  textColor: supports_hasTextColorSupport,
  gradient: supports_hasGradientSupport,
  className: hasCustomClassNameSupport,
  fontFamily: hasFontFamilySupport,
  fontSize: hasFontSizeSupport,
  layout: hasLayoutSupport,
  style: supports_hasStyleSupport
};

/**
 * Get the &quot;style attributes&quot; from a given block to a target block.
 *
 * @param {WPBlock} sourceBlock The source block.
 * @param {WPBlock} targetBlock The target block.
 * @return {Object} the filtered attributes object.
 */
function getStyleAttributes(sourceBlock, targetBlock) {
  return Object.entries(STYLE_ATTRIBUTES).reduce((attributes, [attributeKey, hasSupport]) =&gt; {
    // Only apply the attribute if both blocks support it.
    if (hasSupport(sourceBlock.name) &amp;&amp; hasSupport(targetBlock.name)) {
      // Override attributes that are not present in the block to their defaults.
      attributes[attributeKey] = sourceBlock.attributes[attributeKey];
    }
    return attributes;
  }, {});
}

/**
 * Update the target blocks with style attributes recursively.
 *
 * @param {WPBlock[]} targetBlocks          The target blocks to be updated.
 * @param {WPBlock[]} sourceBlocks          The source blocks to get th style attributes from.
 * @param {Function}  updateBlockAttributes The function to update the attributes.
 */
function recursivelyUpdateBlockAttributes(targetBlocks, sourceBlocks, updateBlockAttributes) {
  for (let index = 0; index &lt; Math.min(sourceBlocks.length, targetBlocks.length); index += 1) {
    updateBlockAttributes(targetBlocks[index].clientId, getStyleAttributes(sourceBlocks[index], targetBlocks[index]));
    recursivelyUpdateBlockAttributes(targetBlocks[index].innerBlocks, sourceBlocks[index].innerBlocks, updateBlockAttributes);
  }
}

/**
 * A hook to return a pasteStyles event function for handling pasting styles to blocks.
 *
 * @return {Function} A function to update the styles to the blocks.
 */
function usePasteStyles() {
  const registry = (0,external_wp_data_namespaceObject.useRegistry)();
  const {
    updateBlockAttributes
  } = (0,external_wp_data_namespaceObject.useDispatch)(store);
  const {
    createSuccessNotice,
    createWarningNotice,
    createErrorNotice
  } = (0,external_wp_data_namespaceObject.useDispatch)(external_wp_notices_namespaceObject.store);
  return (0,external_wp_element_namespaceObject.useCallback)(async targetBlocks =&gt; {
    let html = &#039;&#039;;
    try {
      // `http:` sites won&#039;t have the clipboard property on navigator.
      // (with the exception of localhost.)
      if (!window.navigator.clipboard) {
        createErrorNotice((0,external_wp_i18n_namespaceObject.__)(&#039;Unable to paste styles. This feature is only available on secure (https) sites in supporting browsers.&#039;), {
          type: &#039;snackbar&#039;
        });
        return;
      }
      html = await window.navigator.clipboard.readText();
    } catch (error) {
      // Possibly the permission is denied.
      createErrorNotice((0,external_wp_i18n_namespaceObject.__)(&#039;Unable to paste styles. Please allow browser clipboard permissions before continuing.&#039;), {
        type: &#039;snackbar&#039;
      });
      return;
    }

    // Abort if the copied text is empty or doesn&#039;t look like serialized blocks.
    if (!html || !hasSerializedBlocks(html)) {
      createWarningNotice((0,external_wp_i18n_namespaceObject.__)(&quot;Unable to paste styles. Block styles couldn&#039;t be found within the copied content.&quot;), {
        type: &#039;snackbar&#039;
      });
      return;
    }
    const copiedBlocks = (0,external_wp_blocks_namespaceObject.parse)(html);
    if (copiedBlocks.length === 1) {
      // Apply styles of the block to all the target blocks.
      registry.batch(() =&gt; {
        recursivelyUpdateBlockAttributes(targetBlocks, targetBlocks.map(() =&gt; copiedBlocks[0]), updateBlockAttributes);
      });
    } else {
      registry.batch(() =&gt; {
        recursivelyUpdateBlockAttributes(targetBlocks, copiedBlocks, updateBlockAttributes);
      });
    }
    if (targetBlocks.length === 1) {
      const title = (0,external_wp_blocks_namespaceObject.getBlockType)(targetBlocks[0].name)?.title;
      createSuccessNotice((0,external_wp_i18n_namespaceObject.sprintf)(
      // Translators: Name of the block being pasted, e.g. &quot;Paragraph&quot;.
      (0,external_wp_i18n_namespaceObject.__)(&#039;Pasted styles to %s.&#039;), title), {
        type: &#039;snackbar&#039;
      });
    } else {
      createSuccessNotice((0,external_wp_i18n_namespaceObject.sprintf)(
      // Translators: The number of the blocks.
      (0,external_wp_i18n_namespaceObject.__)(&#039;Pasted styles to %d blocks.&#039;), targetBlocks.length), {
        type: &#039;snackbar&#039;
      });
    }
  }, [registry.batch, updateBlockAttributes, createSuccessNotice, createWarningNotice, createErrorNotice]);
}

;// ./node_modules/@wordpress/block-editor/build-module/components/block-actions/index.js
/**
 * WordPress dependencies
 */



/**
 * Internal dependencies
 */


function BlockActions({
  clientIds,
  children,
  __experimentalUpdateSelection: updateSelection
}) {
  const {
    getDefaultBlockName,
    getGroupingBlockName
  } = (0,external_wp_data_namespaceObject.useSelect)(external_wp_blocks_namespaceObject.store);
  const selected = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      canInsertBlockType,
      getBlockRootClientId,
      getBlocksByClientId,
      getDirectInsertBlock,
      canRemoveBlocks
    } = select(store);
    const blocks = getBlocksByClientId(clientIds);
    const rootClientId = getBlockRootClientId(clientIds[0]);
    const canInsertDefaultBlock = canInsertBlockType(getDefaultBlockName(), rootClientId);
    const directInsertBlock = rootClientId ? getDirectInsertBlock(rootClientId) : null;
    return {
      canRemove: canRemoveBlocks(clientIds),
      canInsertBlock: canInsertDefaultBlock || !!directInsertBlock,
      canCopyStyles: blocks.every(block =&gt; {
        return !!block &amp;&amp; ((0,external_wp_blocks_namespaceObject.hasBlockSupport)(block.name, &#039;color&#039;) || (0,external_wp_blocks_namespaceObject.hasBlockSupport)(block.name, &#039;typography&#039;));
      }),
      canDuplicate: blocks.every(block =&gt; {
        return !!block &amp;&amp; (0,external_wp_blocks_namespaceObject.hasBlockSupport)(block.name, &#039;multiple&#039;, true) &amp;&amp; canInsertBlockType(block.name, rootClientId);
      })
    };
  }, [clientIds, getDefaultBlockName]);
  const {
    getBlocksByClientId,
    getBlocks
  } = (0,external_wp_data_namespaceObject.useSelect)(store);
  const {
    canRemove,
    canInsertBlock,
    canCopyStyles,
    canDuplicate
  } = selected;
  const {
    removeBlocks,
    replaceBlocks,
    duplicateBlocks,
    insertAfterBlock,
    insertBeforeBlock,
    flashBlock
  } = (0,external_wp_data_namespaceObject.useDispatch)(store);
  const pasteStyles = usePasteStyles();
  return children({
    canCopyStyles,
    canDuplicate,
    canInsertBlock,
    canRemove,
    onDuplicate() {
      return duplicateBlocks(clientIds, updateSelection);
    },
    onRemove() {
      return removeBlocks(clientIds, updateSelection);
    },
    onInsertBefore() {
      insertBeforeBlock(clientIds[0]);
    },
    onInsertAfter() {
      insertAfterBlock(clientIds[clientIds.length - 1]);
    },
    onGroup() {
      if (!clientIds.length) {
        return;
      }
      const groupingBlockName = getGroupingBlockName();

      // Activate the `transform` on `core/group` which does the conversion.
      const newBlocks = (0,external_wp_blocks_namespaceObject.switchToBlockType)(getBlocksByClientId(clientIds), groupingBlockName);
      if (!newBlocks) {
        return;
      }
      replaceBlocks(clientIds, newBlocks);
    },
    onUngroup() {
      if (!clientIds.length) {
        return;
      }
      const innerBlocks = getBlocks(clientIds[0]);
      if (!innerBlocks.length) {
        return;
      }
      replaceBlocks(clientIds, innerBlocks);
    },
    onCopy() {
      if (clientIds.length === 1) {
        flashBlock(clientIds[0]);
      }
    },
    async onPasteStyles() {
      await pasteStyles(getBlocksByClientId(clientIds));
    }
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/collab/block-comment-icon-slot.js
/**
 * WordPress dependencies
 */

const CommentIconSlotFill = (0,external_wp_components_namespaceObject.createSlotFill)(Symbol(&#039;CommentIconSlotFill&#039;));
/* harmony default export */ const block_comment_icon_slot = (CommentIconSlotFill);

;// ./node_modules/@wordpress/block-editor/build-module/components/block-settings-menu/block-html-convert-button.js
/**
 * WordPress dependencies
 */





/**
 * Internal dependencies
 */


function BlockHTMLConvertButton({
  clientId
}) {
  const block = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; select(store).getBlock(clientId), [clientId]);
  const {
    replaceBlocks
  } = (0,external_wp_data_namespaceObject.useDispatch)(store);
  if (!block || block.name !== &#039;core/html&#039;) {
    return null;
  }
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, {
    onClick: () =&gt; replaceBlocks(clientId, (0,external_wp_blocks_namespaceObject.rawHandler)({
      HTML: (0,external_wp_blocks_namespaceObject.getBlockContent)(block)
    })),
    children: (0,external_wp_i18n_namespaceObject.__)(&#039;Convert to Blocks&#039;)
  });
}
/* harmony default export */ const block_html_convert_button = (BlockHTMLConvertButton);

;// ./node_modules/@wordpress/block-editor/build-module/components/block-settings-menu/block-settings-menu-first-item.js
/**
 * WordPress dependencies
 */

const {
  Fill: __unstableBlockSettingsMenuFirstItem,
  Slot: block_settings_menu_first_item_Slot
} = (0,external_wp_components_namespaceObject.createSlotFill)(&#039;__unstableBlockSettingsMenuFirstItem&#039;);
__unstableBlockSettingsMenuFirstItem.Slot = block_settings_menu_first_item_Slot;
/* harmony default export */ const block_settings_menu_first_item = (__unstableBlockSettingsMenuFirstItem);

;// ./node_modules/@wordpress/block-editor/build-module/components/convert-to-group-buttons/use-convert-to-group-button-props.js
/**
 * WordPress dependencies
 */



/**
 * Internal dependencies
 */


/**
 * Contains the properties `ConvertToGroupButton` component needs.
 *
 * @typedef {Object} ConvertToGroupButtonProps
 * @property {string[]}  clientIds         An array of the selected client ids.
 * @property {boolean}   isGroupable       Indicates if the selected blocks can be grouped.
 * @property {boolean}   isUngroupable     Indicates if the selected blocks can be ungrouped.
 * @property {WPBlock[]} blocksSelection   An array of the selected blocks.
 * @property {string}    groupingBlockName The name of block used for handling grouping interactions.
 */

/**
 * Returns the properties `ConvertToGroupButton` component needs to work properly.
 * It is used in `BlockSettingsMenuControls` to know if `ConvertToGroupButton`
 * should be rendered, to avoid ending up with an empty MenuGroup.
 *
 * @param {?string[]} selectedClientIds An optional array of clientIds to group. The selected blocks
 *                                      from the block editor store are used if this is not provided.
 *
 * @return {ConvertToGroupButtonProps} Returns the properties needed by `ConvertToGroupButton`.
 */
function useConvertToGroupButtonProps(selectedClientIds) {
  return (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      getBlocksByClientId,
      getSelectedBlockClientIds,
      isUngroupable,
      isGroupable
    } = select(store);
    const {
      getGroupingBlockName,
      getBlockType
    } = select(external_wp_blocks_namespaceObject.store);
    const clientIds = selectedClientIds?.length ? selectedClientIds : getSelectedBlockClientIds();
    const blocksSelection = getBlocksByClientId(clientIds);
    const [firstSelectedBlock] = blocksSelection;
    const _isUngroupable = clientIds.length === 1 &amp;&amp; isUngroupable(clientIds[0]);
    return {
      clientIds,
      isGroupable: isGroupable(clientIds),
      isUngroupable: _isUngroupable,
      blocksSelection,
      groupingBlockName: getGroupingBlockName(),
      onUngroup: _isUngroupable &amp;&amp; getBlockType(firstSelectedBlock.name)?.transforms?.ungroup
    };
  }, [selectedClientIds]);
}

;// ./node_modules/@wordpress/block-editor/build-module/components/convert-to-group-buttons/index.js
/**
 * WordPress dependencies
 */






/**
 * Internal dependencies
 */




function ConvertToGroupButton({
  clientIds,
  isGroupable,
  isUngroupable,
  onUngroup,
  blocksSelection,
  groupingBlockName,
  onClose = () =&gt; {}
}) {
  const {
    getSelectedBlockClientIds
  } = (0,external_wp_data_namespaceObject.useSelect)(store);
  const {
    replaceBlocks
  } = (0,external_wp_data_namespaceObject.useDispatch)(store);
  const onConvertToGroup = () =&gt; {
    // Activate the `transform` on the Grouping Block which does the conversion.
    const newBlocks = (0,external_wp_blocks_namespaceObject.switchToBlockType)(blocksSelection, groupingBlockName);
    if (newBlocks) {
      replaceBlocks(clientIds, newBlocks);
    }
  };
  const onConvertFromGroup = () =&gt; {
    let innerBlocks = blocksSelection[0].innerBlocks;
    if (!innerBlocks.length) {
      return;
    }
    if (onUngroup) {
      innerBlocks = onUngroup(blocksSelection[0].attributes, blocksSelection[0].innerBlocks);
    }
    replaceBlocks(clientIds, innerBlocks);
  };
  if (!isGroupable &amp;&amp; !isUngroupable) {
    return null;
  }
  const selectedBlockClientIds = getSelectedBlockClientIds();
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
    children: [isGroupable &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, {
      shortcut: selectedBlockClientIds.length &gt; 1 ? external_wp_keycodes_namespaceObject.displayShortcut.primary(&#039;g&#039;) : undefined,
      onClick: () =&gt; {
        onConvertToGroup();
        onClose();
      },
      children: (0,external_wp_i18n_namespaceObject._x)(&#039;Group&#039;, &#039;verb&#039;)
    }), isUngroupable &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, {
      onClick: () =&gt; {
        onConvertFromGroup();
        onClose();
      },
      children: (0,external_wp_i18n_namespaceObject._x)(&#039;Ungroup&#039;, &#039;Ungrouping blocks from within a grouping block back into individual blocks within the Editor&#039;)
    })]
  });
}


;// ./node_modules/@wordpress/block-editor/build-module/components/block-lock/use-block-lock.js
/**
 * WordPress dependencies
 */


/**
 * Internal dependencies
 */


/**
 * Return details about the block lock status.
 *
 * @param {string} clientId The block client Id.
 *
 * @return {Object} Block lock status
 */
function useBlockLock(clientId) {
  return (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      canEditBlock,
      canMoveBlock,
      canRemoveBlock,
      canLockBlockType,
      getBlockName,
      getTemplateLock
    } = select(store);
    const canEdit = canEditBlock(clientId);
    const canMove = canMoveBlock(clientId);
    const canRemove = canRemoveBlock(clientId);
    return {
      canEdit,
      canMove,
      canRemove,
      canLock: canLockBlockType(getBlockName(clientId)),
      isContentLocked: getTemplateLock(clientId) === &#039;contentOnly&#039;,
      isLocked: !canEdit || !canMove || !canRemove
    };
  }, [clientId]);
}

;// ./node_modules/@wordpress/icons/build-module/library/unlock.js
/**
 * WordPress dependencies
 */


const unlock_unlock = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  viewBox: &quot;0 0 24 24&quot;,
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;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&quot;
  })
});
/* harmony default export */ const library_unlock = (unlock_unlock);

;// ./node_modules/@wordpress/icons/build-module/library/lock-outline.js
/**
 * WordPress dependencies
 */


const lockOutline = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  viewBox: &quot;0 0 24 24&quot;,
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;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&quot;
  })
});
/* harmony default export */ const lock_outline = (lockOutline);

;// ./node_modules/@wordpress/icons/build-module/library/lock.js
/**
 * WordPress dependencies
 */


const lock_lock = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  viewBox: &quot;0 0 24 24&quot;,
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;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&quot;
  })
});
/* harmony default export */ const library_lock = (lock_lock);

;// ./node_modules/@wordpress/block-editor/build-module/components/block-lock/modal.js
/**
 * WordPress dependencies
 */







/**
 * Internal dependencies
 */




// Entity based blocks which allow edit locking

const ALLOWS_EDIT_LOCKING = [&#039;core/navigation&#039;];
function getTemplateLockValue(lock) {
  // Prevents all operations.
  if (lock.remove &amp;&amp; lock.move) {
    return &#039;all&#039;;
  }

  // Prevents inserting or removing blocks, but allows moving existing blocks.
  if (lock.remove &amp;&amp; !lock.move) {
    return &#039;insert&#039;;
  }
  return false;
}
function BlockLockModal({
  clientId,
  onClose
}) {
  const [lock, setLock] = (0,external_wp_element_namespaceObject.useState)({
    move: false,
    remove: false
  });
  const {
    canEdit,
    canMove,
    canRemove
  } = useBlockLock(clientId);
  const {
    allowsEditLocking,
    templateLock,
    hasTemplateLock
  } = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      getBlockName,
      getBlockAttributes
    } = select(store);
    const blockName = getBlockName(clientId);
    const blockType = (0,external_wp_blocks_namespaceObject.getBlockType)(blockName);
    return {
      allowsEditLocking: ALLOWS_EDIT_LOCKING.includes(blockName),
      templateLock: getBlockAttributes(clientId)?.templateLock,
      hasTemplateLock: !!blockType?.attributes?.templateLock
    };
  }, [clientId]);
  const [applyTemplateLock, setApplyTemplateLock] = (0,external_wp_element_namespaceObject.useState)(!!templateLock);
  const {
    updateBlockAttributes
  } = (0,external_wp_data_namespaceObject.useDispatch)(store);
  const blockInformation = useBlockDisplayInformation(clientId);
  (0,external_wp_element_namespaceObject.useEffect)(() =&gt; {
    setLock({
      move: !canMove,
      remove: !canRemove,
      ...(allowsEditLocking ? {
        edit: !canEdit
      } : {})
    });
  }, [canEdit, canMove, canRemove, allowsEditLocking]);
  const isAllChecked = Object.values(lock).every(Boolean);
  const isMixed = Object.values(lock).some(Boolean) &amp;&amp; !isAllChecked;
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Modal, {
    title: (0,external_wp_i18n_namespaceObject.sprintf)(/* translators: %s: Name of the block. */
    (0,external_wp_i18n_namespaceObject.__)(&#039;Lock %s&#039;), blockInformation.title),
    overlayClassName: &quot;block-editor-block-lock-modal&quot;,
    onRequestClose: onClose,
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;form&quot;, {
      onSubmit: event =&gt; {
        event.preventDefault();
        updateBlockAttributes([clientId], {
          lock,
          templateLock: applyTemplateLock ? getTemplateLockValue(lock) : undefined
        });
        onClose();
      },
      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;fieldset&quot;, {
        className: &quot;block-editor-block-lock-modal__options&quot;,
        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;legend&quot;, {
          children: (0,external_wp_i18n_namespaceObject.__)(&#039;Select the features you want to lock&#039;)
        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;ul&quot;, {
          role: &quot;list&quot;,
          className: &quot;block-editor-block-lock-modal__checklist&quot;,
          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;li&quot;, {
            children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.CheckboxControl, {
              __nextHasNoMarginBottom: true,
              className: &quot;block-editor-block-lock-modal__options-all&quot;,
              label: (0,external_wp_i18n_namespaceObject.__)(&#039;Lock all&#039;),
              checked: isAllChecked,
              indeterminate: isMixed,
              onChange: newValue =&gt; setLock({
                move: newValue,
                remove: newValue,
                ...(allowsEditLocking ? {
                  edit: newValue
                } : {})
              })
            }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;ul&quot;, {
              role: &quot;list&quot;,
              className: &quot;block-editor-block-lock-modal__checklist&quot;,
              children: [allowsEditLocking &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;li&quot;, {
                className: &quot;block-editor-block-lock-modal__checklist-item&quot;,
                children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.CheckboxControl, {
                  __nextHasNoMarginBottom: true,
                  label: (0,external_wp_i18n_namespaceObject.__)(&#039;Lock editing&#039;),
                  checked: !!lock.edit,
                  onChange: edit =&gt; setLock(prevLock =&gt; ({
                    ...prevLock,
                    edit
                  }))
                }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Icon, {
                  className: &quot;block-editor-block-lock-modal__lock-icon&quot;,
                  icon: lock.edit ? library_lock : library_unlock
                })]
              }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;li&quot;, {
                className: &quot;block-editor-block-lock-modal__checklist-item&quot;,
                children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.CheckboxControl, {
                  __nextHasNoMarginBottom: true,
                  label: (0,external_wp_i18n_namespaceObject.__)(&#039;Lock movement&#039;),
                  checked: lock.move,
                  onChange: move =&gt; setLock(prevLock =&gt; ({
                    ...prevLock,
                    move
                  }))
                }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Icon, {
                  className: &quot;block-editor-block-lock-modal__lock-icon&quot;,
                  icon: lock.move ? library_lock : library_unlock
                })]
              }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;li&quot;, {
                className: &quot;block-editor-block-lock-modal__checklist-item&quot;,
                children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.CheckboxControl, {
                  __nextHasNoMarginBottom: true,
                  label: (0,external_wp_i18n_namespaceObject.__)(&#039;Lock removal&#039;),
                  checked: lock.remove,
                  onChange: remove =&gt; setLock(prevLock =&gt; ({
                    ...prevLock,
                    remove
                  }))
                }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Icon, {
                  className: &quot;block-editor-block-lock-modal__lock-icon&quot;,
                  icon: lock.remove ? library_lock : library_unlock
                })]
              })]
            })]
          })
        }), hasTemplateLock &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToggleControl, {
          __nextHasNoMarginBottom: true,
          className: &quot;block-editor-block-lock-modal__template-lock&quot;,
          label: (0,external_wp_i18n_namespaceObject.__)(&#039;Apply to all blocks inside&#039;),
          checked: applyTemplateLock,
          disabled: lock.move &amp;&amp; !lock.remove,
          onChange: () =&gt; setApplyTemplateLock(!applyTemplateLock)
        })]
      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.Flex, {
        className: &quot;block-editor-block-lock-modal__actions&quot;,
        justify: &quot;flex-end&quot;,
        expanded: false,
        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FlexItem, {
          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
            variant: &quot;tertiary&quot;,
            onClick: onClose,
            __next40pxDefaultSize: true,
            children: (0,external_wp_i18n_namespaceObject.__)(&#039;Cancel&#039;)
          })
        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FlexItem, {
          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
            variant: &quot;primary&quot;,
            type: &quot;submit&quot;,
            __next40pxDefaultSize: true,
            children: (0,external_wp_i18n_namespaceObject.__)(&#039;Apply&#039;)
          })
        })]
      })]
    })
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/block-lock/menu-item.js
/**
 * WordPress dependencies
 */





/**
 * Internal dependencies
 */



function BlockLockMenuItem({
  clientId
}) {
  const {
    canLock,
    isLocked
  } = useBlockLock(clientId);
  const [isModalOpen, toggleModal] = (0,external_wp_element_namespaceObject.useReducer)(isActive =&gt; !isActive, false);
  if (!canLock) {
    return null;
  }
  const label = isLocked ? (0,external_wp_i18n_namespaceObject.__)(&#039;Unlock&#039;) : (0,external_wp_i18n_namespaceObject.__)(&#039;Lock&#039;);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, {
      icon: isLocked ? library_unlock : lock_outline,
      onClick: toggleModal,
      &quot;aria-expanded&quot;: isModalOpen,
      &quot;aria-haspopup&quot;: &quot;dialog&quot;,
      children: label
    }), isModalOpen &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockLockModal, {
      clientId: clientId,
      onClose: toggleModal
    })]
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/block-settings-menu/block-mode-toggle.js
/**
 * WordPress dependencies
 */





/**
 * Internal dependencies
 */


const block_mode_toggle_noop = () =&gt; {};
function BlockModeToggle({
  clientId,
  onToggle = block_mode_toggle_noop
}) {
  const {
    blockType,
    mode,
    isCodeEditingEnabled
  } = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      getBlock,
      getBlockMode,
      getSettings
    } = select(store);
    const block = getBlock(clientId);
    return {
      mode: getBlockMode(clientId),
      blockType: block ? (0,external_wp_blocks_namespaceObject.getBlockType)(block.name) : null,
      isCodeEditingEnabled: getSettings().codeEditingEnabled
    };
  }, [clientId]);
  const {
    toggleBlockMode
  } = (0,external_wp_data_namespaceObject.useDispatch)(store);
  if (!blockType || !(0,external_wp_blocks_namespaceObject.hasBlockSupport)(blockType, &#039;html&#039;, true) || !isCodeEditingEnabled) {
    return null;
  }
  const label = mode === &#039;visual&#039; ? (0,external_wp_i18n_namespaceObject.__)(&#039;Edit as HTML&#039;) : (0,external_wp_i18n_namespaceObject.__)(&#039;Edit visually&#039;);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, {
    onClick: () =&gt; {
      toggleBlockMode(clientId);
      onToggle();
    },
    children: label
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/content-lock/modify-content-lock-menu-item.js
/**
 * WordPress dependencies
 */




/**
 * Internal dependencies
 */



// The implementation of content locking is mainly in this file, although the mechanism
// to stop temporarily editing as blocks when an outside block is selected is on component StopEditingAsBlocksOnOutsideSelect
// at block-editor/src/components/block-list/index.js.
// Besides the components on this file and the file referenced above the implementation
// also includes artifacts on the store (actions, reducers, and selector).

function ModifyContentLockMenuItem({
  clientId,
  onClose
}) {
  const {
    templateLock,
    isLockedByParent,
    isEditingAsBlocks
  } = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      getContentLockingParent,
      getTemplateLock,
      getTemporarilyEditingAsBlocks
    } = unlock(select(store));
    return {
      templateLock: getTemplateLock(clientId),
      isLockedByParent: !!getContentLockingParent(clientId),
      isEditingAsBlocks: getTemporarilyEditingAsBlocks() === clientId
    };
  }, [clientId]);
  const blockEditorActions = (0,external_wp_data_namespaceObject.useDispatch)(store);
  const isContentLocked = !isLockedByParent &amp;&amp; templateLock === &#039;contentOnly&#039;;
  if (!isContentLocked &amp;&amp; !isEditingAsBlocks) {
    return null;
  }
  const {
    modifyContentLockBlock
  } = unlock(blockEditorActions);
  const showStartEditingAsBlocks = !isEditingAsBlocks &amp;&amp; isContentLocked;
  return showStartEditingAsBlocks &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, {
    onClick: () =&gt; {
      modifyContentLockBlock(clientId);
      onClose();
    },
    children: (0,external_wp_i18n_namespaceObject._x)(&#039;Modify&#039;, &#039;Unlock content locked blocks&#039;)
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/block-rename/use-block-rename.js
/**
 * WordPress dependencies
 */

function useBlockRename(name) {
  return {
    canRename: (0,external_wp_blocks_namespaceObject.getBlockSupport)(name, &#039;renaming&#039;, true)
  };
}

;// ./node_modules/@wordpress/block-editor/build-module/components/block-rename/is-empty-string.js
function isEmptyString(testString) {
  return testString?.trim()?.length === 0;
}

;// ./node_modules/@wordpress/block-editor/build-module/components/block-rename/modal.js
/**
 * WordPress dependencies
 */






/**
 * Internal dependencies
 */




function BlockRenameModal({
  clientId,
  onClose
}) {
  const [editedBlockName, setEditedBlockName] = (0,external_wp_element_namespaceObject.useState)();
  const blockInformation = useBlockDisplayInformation(clientId);
  const {
    metadata
  } = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      getBlockAttributes
    } = select(store);
    return {
      metadata: getBlockAttributes(clientId)?.metadata
    };
  }, [clientId]);
  const {
    updateBlockAttributes
  } = (0,external_wp_data_namespaceObject.useDispatch)(store);
  const blockName = metadata?.name || &#039;&#039;;
  const originalBlockName = blockInformation?.title;
  // Pattern Overrides is a WordPress-only feature but it also uses the Block Binding API.
  // Ideally this should not be inside the block editor package, but we keep it here for simplicity.
  const hasOverridesWarning = !!blockName &amp;&amp; !!metadata?.bindings &amp;&amp; Object.values(metadata.bindings).some(binding =&gt; binding.source === &#039;core/pattern-overrides&#039;);
  const nameHasChanged = editedBlockName !== undefined &amp;&amp; editedBlockName !== blockName;
  const nameIsOriginal = editedBlockName === originalBlockName;
  const nameIsEmpty = isEmptyString(editedBlockName);
  const isNameValid = nameHasChanged || nameIsOriginal;
  const autoSelectInputText = event =&gt; event.target.select();
  const handleSubmit = () =&gt; {
    const newName = nameIsOriginal || nameIsEmpty ? undefined : editedBlockName;
    const message = nameIsOriginal || nameIsEmpty ? (0,external_wp_i18n_namespaceObject.sprintf)(/* translators: %s: new name/label for the block */
    (0,external_wp_i18n_namespaceObject.__)(&#039;Block name reset to: &quot;%s&quot;.&#039;), editedBlockName) : (0,external_wp_i18n_namespaceObject.sprintf)(/* translators: %s: new name/label for the block */
    (0,external_wp_i18n_namespaceObject.__)(&#039;Block name changed to: &quot;%s&quot;.&#039;), editedBlockName);

    // Must be assertive to immediately announce change.
    (0,external_wp_a11y_namespaceObject.speak)(message, &#039;assertive&#039;);
    updateBlockAttributes([clientId], {
      metadata: {
        ...metadata,
        name: newName
      }
    });

    // Immediate close avoids ability to hit save multiple times.
    onClose();
  };
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Modal, {
    title: (0,external_wp_i18n_namespaceObject.__)(&#039;Rename&#039;),
    onRequestClose: onClose,
    overlayClassName: &quot;block-editor-block-rename-modal&quot;,
    focusOnMount: &quot;firstContentElement&quot;,
    size: &quot;small&quot;,
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;form&quot;, {
      onSubmit: e =&gt; {
        e.preventDefault();
        if (!isNameValid) {
          return;
        }
        handleSubmit();
      },
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalVStack, {
        spacing: &quot;3&quot;,
        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.TextControl, {
          __nextHasNoMarginBottom: true,
          __next40pxDefaultSize: true,
          value: editedBlockName !== null &amp;&amp; editedBlockName !== void 0 ? editedBlockName : blockName,
          label: (0,external_wp_i18n_namespaceObject.__)(&#039;Name&#039;),
          help: hasOverridesWarning ? (0,external_wp_i18n_namespaceObject.__)(&#039;This block allows overrides. Changing the name can cause problems with content entered into instances of this pattern.&#039;) : undefined,
          placeholder: originalBlockName,
          onChange: setEditedBlockName,
          onFocus: autoSelectInputText
        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalHStack, {
          justify: &quot;right&quot;,
          children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
            __next40pxDefaultSize: true,
            variant: &quot;tertiary&quot;,
            onClick: onClose,
            children: (0,external_wp_i18n_namespaceObject.__)(&#039;Cancel&#039;)
          }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
            __next40pxDefaultSize: true,
            accessibleWhenDisabled: true,
            disabled: !isNameValid,
            variant: &quot;primary&quot;,
            type: &quot;submit&quot;,
            children: (0,external_wp_i18n_namespaceObject.__)(&#039;Save&#039;)
          })]
        })]
      })
    })
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/block-rename/rename-control.js
/**
 * WordPress dependencies
 */




/**
 * Internal dependencies
 */


function BlockRenameControl({
  clientId
}) {
  const [renamingBlock, setRenamingBlock] = (0,external_wp_element_namespaceObject.useState)(false);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, {
      onClick: () =&gt; {
        setRenamingBlock(true);
      },
      &quot;aria-expanded&quot;: renamingBlock,
      &quot;aria-haspopup&quot;: &quot;dialog&quot;,
      children: (0,external_wp_i18n_namespaceObject.__)(&#039;Rename&#039;)
    }), renamingBlock &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockRenameModal, {
      clientId: clientId,
      onClose: () =&gt; setRenamingBlock(false)
    })]
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/block-settings-menu-controls/index.js
/**
 * WordPress dependencies
 */



/**
 * Internal dependencies
 */







const {
  Fill,
  Slot: block_settings_menu_controls_Slot
} = (0,external_wp_components_namespaceObject.createSlotFill)(&#039;BlockSettingsMenuControls&#039;);
const BlockSettingsMenuControlsSlot = ({
  fillProps,
  clientIds = null
}) =&gt; {
  const {
    selectedBlocks,
    selectedClientIds,
    isContentOnly
  } = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      getBlockNamesByClientId,
      getSelectedBlockClientIds,
      getBlockEditingMode
    } = select(store);
    const ids = clientIds !== null ? clientIds : getSelectedBlockClientIds();
    return {
      selectedBlocks: getBlockNamesByClientId(ids),
      selectedClientIds: ids,
      isContentOnly: getBlockEditingMode(ids[0]) === &#039;contentOnly&#039;
    };
  }, [clientIds]);
  const {
    canLock
  } = useBlockLock(selectedClientIds[0]);
  const {
    canRename
  } = useBlockRename(selectedBlocks[0]);
  const showLockButton = selectedClientIds.length === 1 &amp;&amp; canLock &amp;&amp; !isContentOnly;
  const showRenameButton = selectedClientIds.length === 1 &amp;&amp; canRename &amp;&amp; !isContentOnly;

  // Check if current selection of blocks is Groupable or Ungroupable
  // and pass this props down to ConvertToGroupButton.
  const convertToGroupButtonProps = useConvertToGroupButtonProps(selectedClientIds);
  const {
    isGroupable,
    isUngroupable
  } = convertToGroupButtonProps;
  const showConvertToGroupButton = (isGroupable || isUngroupable) &amp;&amp; !isContentOnly;
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_settings_menu_controls_Slot, {
    fillProps: {
      ...fillProps,
      selectedBlocks,
      selectedClientIds
    },
    children: fills =&gt; {
      if (!fills?.length &gt; 0 &amp;&amp; !showConvertToGroupButton &amp;&amp; !showLockButton) {
        return null;
      }
      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.MenuGroup, {
        children: [showConvertToGroupButton &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ConvertToGroupButton, {
          ...convertToGroupButtonProps,
          onClose: fillProps?.onClose
        }), showLockButton &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockLockMenuItem, {
          clientId: selectedClientIds[0]
        }), showRenameButton &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockRenameControl, {
          clientId: selectedClientIds[0]
        }), fills, selectedClientIds.length === 1 &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ModifyContentLockMenuItem, {
          clientId: selectedClientIds[0],
          onClose: fillProps?.onClose
        }), fillProps?.count === 1 &amp;&amp; !isContentOnly &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockModeToggle, {
          clientId: fillProps?.firstBlockClientId,
          onToggle: fillProps?.onClose
        })]
      });
    }
  });
};

/**
 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/block-settings-menu-controls/README.md
 *
 * @param {Object} props Fill props.
 * @return {Element} Element.
 */
function BlockSettingsMenuControls({
  ...props
}) {
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalStyleProvider, {
    document: document,
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Fill, {
      ...props
    })
  });
}
BlockSettingsMenuControls.Slot = BlockSettingsMenuControlsSlot;
/* harmony default export */ const block_settings_menu_controls = (BlockSettingsMenuControls);

;// ./node_modules/@wordpress/block-editor/build-module/components/block-settings-menu/block-parent-selector-menu-item.js
/**
 * WordPress dependencies
 */






/**
 * Internal dependencies
 */




function BlockParentSelectorMenuItem({
  parentClientId,
  parentBlockType
}) {
  const isSmallViewport = (0,external_wp_compose_namespaceObject.useViewportMatch)(&#039;medium&#039;, &#039;&lt;&#039;);
  const {
    selectBlock
  } = (0,external_wp_data_namespaceObject.useDispatch)(store);

  // Allows highlighting the parent block outline when focusing or hovering
  // the parent block selector within the child.
  const menuItemRef = (0,external_wp_element_namespaceObject.useRef)();
  const gesturesProps = useShowHoveredOrFocusedGestures({
    ref: menuItemRef,
    highlightParent: true
  });
  if (!isSmallViewport) {
    return null;
  }
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, {
    ...gesturesProps,
    ref: menuItemRef,
    icon: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_icon, {
      icon: parentBlockType.icon
    }),
    onClick: () =&gt; selectBlock(parentClientId),
    children: (0,external_wp_i18n_namespaceObject.sprintf)(/* translators: %s: Name of the block&#039;s parent. */
    (0,external_wp_i18n_namespaceObject.__)(&#039;Select parent block (%s)&#039;), parentBlockType.title)
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/block-settings-menu/block-settings-dropdown.js
/**
 * WordPress dependencies
 */









/**
 * Internal dependencies
 */










const block_settings_dropdown_POPOVER_PROPS = {
  className: &#039;block-editor-block-settings-menu__popover&#039;,
  placement: &#039;bottom-start&#039;
};
function CopyMenuItem({
  clientIds,
  onCopy,
  label,
  shortcut,
  eventType = &#039;copy&#039;,
  __experimentalUpdateSelection: updateSelection = false
}) {
  const {
    getBlocksByClientId
  } = (0,external_wp_data_namespaceObject.useSelect)(store);
  const {
    removeBlocks
  } = (0,external_wp_data_namespaceObject.useDispatch)(store);
  const notifyCopy = useNotifyCopy();
  const ref = (0,external_wp_compose_namespaceObject.useCopyToClipboard)(() =&gt; (0,external_wp_blocks_namespaceObject.serialize)(getBlocksByClientId(clientIds)), () =&gt; {
    switch (eventType) {
      case &#039;copy&#039;:
      case &#039;copyStyles&#039;:
        onCopy();
        notifyCopy(eventType, clientIds);
        break;
      case &#039;cut&#039;:
        notifyCopy(eventType, clientIds);
        removeBlocks(clientIds, updateSelection);
        break;
      default:
        break;
    }
  });
  const copyMenuItemLabel = label ? label : (0,external_wp_i18n_namespaceObject.__)(&#039;Copy&#039;);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, {
    ref: ref,
    shortcut: shortcut,
    children: copyMenuItemLabel
  });
}
function BlockSettingsDropdown({
  block,
  clientIds,
  children,
  __experimentalSelectBlock,
  ...props
}) {
  // Get the client id of the current block for this menu, if one is set.
  const currentClientId = block?.clientId;
  const count = clientIds.length;
  const firstBlockClientId = clientIds[0];
  const {
    firstParentClientId,
    parentBlockType,
    previousBlockClientId,
    selectedBlockClientIds,
    openedBlockSettingsMenu,
    isContentOnly
  } = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      getBlockName,
      getBlockRootClientId,
      getPreviousBlockClientId,
      getSelectedBlockClientIds,
      getBlockAttributes,
      getOpenedBlockSettingsMenu,
      getBlockEditingMode
    } = unlock(select(store));
    const {
      getActiveBlockVariation
    } = select(external_wp_blocks_namespaceObject.store);
    const _firstParentClientId = getBlockRootClientId(firstBlockClientId);
    const parentBlockName = _firstParentClientId &amp;&amp; getBlockName(_firstParentClientId);
    return {
      firstParentClientId: _firstParentClientId,
      parentBlockType: _firstParentClientId &amp;&amp; (getActiveBlockVariation(parentBlockName, getBlockAttributes(_firstParentClientId)) || (0,external_wp_blocks_namespaceObject.getBlockType)(parentBlockName)),
      previousBlockClientId: getPreviousBlockClientId(firstBlockClientId),
      selectedBlockClientIds: getSelectedBlockClientIds(),
      openedBlockSettingsMenu: getOpenedBlockSettingsMenu(),
      isContentOnly: getBlockEditingMode(firstBlockClientId) === &#039;contentOnly&#039;
    };
  }, [firstBlockClientId]);
  const {
    getBlockOrder,
    getSelectedBlockClientIds
  } = (0,external_wp_data_namespaceObject.useSelect)(store);
  const {
    setOpenedBlockSettingsMenu
  } = unlock((0,external_wp_data_namespaceObject.useDispatch)(store));
  const shortcuts = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      getShortcutRepresentation
    } = select(external_wp_keyboardShortcuts_namespaceObject.store);
    return {
      copy: getShortcutRepresentation(&#039;core/block-editor/copy&#039;),
      cut: getShortcutRepresentation(&#039;core/block-editor/cut&#039;),
      duplicate: getShortcutRepresentation(&#039;core/block-editor/duplicate&#039;),
      remove: getShortcutRepresentation(&#039;core/block-editor/remove&#039;),
      insertAfter: getShortcutRepresentation(&#039;core/block-editor/insert-after&#039;),
      insertBefore: getShortcutRepresentation(&#039;core/block-editor/insert-before&#039;)
    };
  }, []);
  const hasSelectedBlocks = selectedBlockClientIds.length &gt; 0;
  async function updateSelectionAfterDuplicate(clientIdsPromise) {
    if (!__experimentalSelectBlock) {
      return;
    }
    const ids = await clientIdsPromise;
    if (ids &amp;&amp; ids[0]) {
      __experimentalSelectBlock(ids[0], false);
    }
  }
  function updateSelectionAfterRemove() {
    if (!__experimentalSelectBlock) {
      return;
    }
    let blockToFocus = previousBlockClientId || firstParentClientId;

    // Focus the first block if there&#039;s no previous block nor parent block.
    if (!blockToFocus) {
      blockToFocus = getBlockOrder()[0];
    }

    // Only update the selection if the original selection is removed.
    const shouldUpdateSelection = hasSelectedBlocks &amp;&amp; getSelectedBlockClientIds().length === 0;
    __experimentalSelectBlock(blockToFocus, shouldUpdateSelection);
  }

  // This can occur when the selected block (the parent)
  // displays child blocks within a List View.
  const parentBlockIsSelected = selectedBlockClientIds?.includes(firstParentClientId);

  // When a currentClientId is in use, treat the menu as a controlled component.
  // This ensures that only one block settings menu is open at a time.
  // This is a temporary solution to work around an issue with `onFocusOutside`
  // where it does not allow a dropdown to be closed if focus was never within
  // the dropdown to begin with. Examples include a user either CMD+Clicking or
  // right clicking into an inactive window.
  // See: https://github.com/WordPress/gutenberg/pull/54083
  const open = !currentClientId ? undefined : openedBlockSettingsMenu === currentClientId || false;
  function onToggle(localOpen) {
    if (localOpen &amp;&amp; openedBlockSettingsMenu !== currentClientId) {
      setOpenedBlockSettingsMenu(currentClientId);
    } else if (!localOpen &amp;&amp; openedBlockSettingsMenu &amp;&amp; openedBlockSettingsMenu === currentClientId) {
      setOpenedBlockSettingsMenu(undefined);
    }
  }
  const shouldShowBlockParentMenuItem = !parentBlockIsSelected &amp;&amp; !!firstParentClientId;
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockActions, {
    clientIds: clientIds,
    __experimentalUpdateSelection: !__experimentalSelectBlock,
    children: ({
      canCopyStyles,
      canDuplicate,
      canInsertBlock,
      canRemove,
      onDuplicate,
      onInsertAfter,
      onInsertBefore,
      onRemove,
      onCopy,
      onPasteStyles
    }) =&gt; {
      // It is possible that some plugins register fills for this menu
      // even if Core doesn&#039;t render anything in the block settings menu.
      // in which case, we may want to render the menu anyway.
      // That said for now, we can start more conservative.
      const isEmpty = !canRemove &amp;&amp; !canDuplicate &amp;&amp; !canInsertBlock &amp;&amp; isContentOnly;
      if (isEmpty) {
        return null;
      }
      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.DropdownMenu, {
        icon: more_vertical,
        label: (0,external_wp_i18n_namespaceObject.__)(&#039;Options&#039;),
        className: &quot;block-editor-block-settings-menu&quot;,
        popoverProps: block_settings_dropdown_POPOVER_PROPS,
        open: open,
        onToggle: onToggle,
        noIcons: true,
        ...props,
        children: ({
          onClose
        }) =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
          children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.MenuGroup, {
            children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_settings_menu_first_item.Slot, {
              fillProps: {
                onClose
              }
            }), shouldShowBlockParentMenuItem &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockParentSelectorMenuItem, {
              parentClientId: firstParentClientId,
              parentBlockType: parentBlockType
            }), count === 1 &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_html_convert_button, {
              clientId: firstBlockClientId
            }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(CopyMenuItem, {
              clientIds: clientIds,
              onCopy: onCopy,
              shortcut: shortcuts.copy
            }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(CopyMenuItem, {
              clientIds: clientIds,
              label: (0,external_wp_i18n_namespaceObject.__)(&#039;Cut&#039;),
              eventType: &quot;cut&quot;,
              shortcut: shortcuts.cut,
              __experimentalUpdateSelection: !__experimentalSelectBlock
            }), canDuplicate &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, {
              onClick: (0,external_wp_compose_namespaceObject.pipe)(onClose, onDuplicate, updateSelectionAfterDuplicate),
              shortcut: shortcuts.duplicate,
              children: (0,external_wp_i18n_namespaceObject.__)(&#039;Duplicate&#039;)
            }), canInsertBlock &amp;&amp; !isContentOnly &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
              children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, {
                onClick: (0,external_wp_compose_namespaceObject.pipe)(onClose, onInsertBefore),
                shortcut: shortcuts.insertBefore,
                children: (0,external_wp_i18n_namespaceObject.__)(&#039;Add before&#039;)
              }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, {
                onClick: (0,external_wp_compose_namespaceObject.pipe)(onClose, onInsertAfter),
                shortcut: shortcuts.insertAfter,
                children: (0,external_wp_i18n_namespaceObject.__)(&#039;Add after&#039;)
              })]
            }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_comment_icon_slot.Slot, {
              fillProps: {
                onClose
              }
            })]
          }), canCopyStyles &amp;&amp; !isContentOnly &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.MenuGroup, {
            children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(CopyMenuItem, {
              clientIds: clientIds,
              onCopy: onCopy,
              label: (0,external_wp_i18n_namespaceObject.__)(&#039;Copy styles&#039;),
              eventType: &quot;copyStyles&quot;
            }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, {
              onClick: onPasteStyles,
              children: (0,external_wp_i18n_namespaceObject.__)(&#039;Paste styles&#039;)
            })]
          }), !isContentOnly &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_settings_menu_controls.Slot, {
            fillProps: {
              onClose,
              count,
              firstBlockClientId
            },
            clientIds: clientIds
          }), typeof children === &#039;function&#039; ? children({
            onClose
          }) : external_wp_element_namespaceObject.Children.map(child =&gt; (0,external_wp_element_namespaceObject.cloneElement)(child, {
            onClose
          })), canRemove &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuGroup, {
            children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, {
              onClick: (0,external_wp_compose_namespaceObject.pipe)(onClose, onRemove, updateSelectionAfterRemove),
              shortcut: shortcuts.remove,
              children: (0,external_wp_i18n_namespaceObject.__)(&#039;Delete&#039;)
            })
          })]
        })
      });
    }
  });
}
/* harmony default export */ const block_settings_dropdown = (BlockSettingsDropdown);

;// ./node_modules/@wordpress/block-editor/build-module/components/collab/block-comment-icon-toolbar-slot.js
/**
 * WordPress dependencies
 */

const CommentIconToolbarSlotFill = (0,external_wp_components_namespaceObject.createSlotFill)(Symbol(&#039;CommentIconToolbarSlotFill&#039;));
/* harmony default export */ const block_comment_icon_toolbar_slot = (CommentIconToolbarSlotFill);

;// ./node_modules/@wordpress/block-editor/build-module/components/block-settings-menu/index.js
/**
 * WordPress dependencies
 */


/**
 * Internal dependencies
 */



function BlockSettingsMenu({
  clientIds,
  ...props
}) {
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.ToolbarGroup, {
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_comment_icon_toolbar_slot.Slot, {}), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarItem, {
      children: toggleProps =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_settings_dropdown, {
        clientIds: clientIds,
        toggleProps: toggleProps,
        ...props
      })
    })]
  });
}
/* harmony default export */ const block_settings_menu = (BlockSettingsMenu);

;// ./node_modules/@wordpress/block-editor/build-module/components/block-lock/toolbar.js
/**
 * WordPress dependencies
 */





/**
 * Internal dependencies
 */



function BlockLockToolbar({
  clientId
}) {
  const {
    canLock,
    isLocked
  } = useBlockLock(clientId);
  const [isModalOpen, toggleModal] = (0,external_wp_element_namespaceObject.useReducer)(isActive =&gt; !isActive, false);
  const hasLockButtonShownRef = (0,external_wp_element_namespaceObject.useRef)(false);

  // If the block lock button has been shown, we don&#039;t want to remove it
  // from the toolbar until the toolbar is rendered again without it.
  // Removing it beforehand can cause focus loss issues, such as when
  // unlocking the block from the modal. It needs to return focus from
  // whence it came, and to do that, we need to leave the button in the toolbar.
  (0,external_wp_element_namespaceObject.useEffect)(() =&gt; {
    if (isLocked) {
      hasLockButtonShownRef.current = true;
    }
  }, [isLocked]);
  if (!isLocked &amp;&amp; !hasLockButtonShownRef.current) {
    return null;
  }
  let label = isLocked ? (0,external_wp_i18n_namespaceObject.__)(&#039;Unlock&#039;) : (0,external_wp_i18n_namespaceObject.__)(&#039;Lock&#039;);
  if (!canLock &amp;&amp; isLocked) {
    label = (0,external_wp_i18n_namespaceObject.__)(&#039;Locked&#039;);
  }
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarGroup, {
      className: &quot;block-editor-block-lock-toolbar&quot;,
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarButton, {
        disabled: !canLock,
        icon: isLocked ? library_lock : library_unlock,
        label: label,
        onClick: toggleModal,
        &quot;aria-expanded&quot;: isModalOpen,
        &quot;aria-haspopup&quot;: &quot;dialog&quot;
      })
    }), isModalOpen &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockLockModal, {
      clientId: clientId,
      onClose: toggleModal
    })]
  });
}

;// ./node_modules/@wordpress/icons/build-module/library/group.js
/**
 * WordPress dependencies
 */


const group_group = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  viewBox: &quot;0 0 24 24&quot;,
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;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&quot;
  })
});
/* harmony default export */ const library_group = (group_group);

;// ./node_modules/@wordpress/icons/build-module/library/row.js
/**
 * WordPress dependencies
 */


const row = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;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&quot;
  })
});
/* harmony default export */ const library_row = (row);

;// ./node_modules/@wordpress/icons/build-module/library/stack.js
/**
 * WordPress dependencies
 */


const stack = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;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&quot;
  })
});
/* harmony default export */ const library_stack = (stack);

;// ./node_modules/@wordpress/icons/build-module/library/grid.js
/**
 * WordPress dependencies
 */


const grid_grid = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;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&quot;,
    fillRule: &quot;evenodd&quot;,
    clipRule: &quot;evenodd&quot;
  })
});
/* harmony default export */ const library_grid = (grid_grid);

;// ./node_modules/@wordpress/block-editor/build-module/components/convert-to-group-buttons/toolbar.js
/**
 * WordPress dependencies
 */






/**
 * Internal dependencies
 */



const layouts = {
  group: {
    type: &#039;constrained&#039;
  },
  row: {
    type: &#039;flex&#039;,
    flexWrap: &#039;nowrap&#039;
  },
  stack: {
    type: &#039;flex&#039;,
    orientation: &#039;vertical&#039;
  },
  grid: {
    type: &#039;grid&#039;
  }
};
function BlockGroupToolbar() {
  const {
    blocksSelection,
    clientIds,
    groupingBlockName,
    isGroupable
  } = useConvertToGroupButtonProps();
  const {
    replaceBlocks
  } = (0,external_wp_data_namespaceObject.useDispatch)(store);
  const {
    canRemove,
    variations
  } = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      canRemoveBlocks
    } = select(store);
    const {
      getBlockVariations
    } = select(external_wp_blocks_namespaceObject.store);
    return {
      canRemove: canRemoveBlocks(clientIds),
      variations: getBlockVariations(groupingBlockName, &#039;transform&#039;)
    };
  }, [clientIds, groupingBlockName]);
  const onConvertToGroup = layout =&gt; {
    const newBlocks = (0,external_wp_blocks_namespaceObject.switchToBlockType)(blocksSelection, groupingBlockName);
    if (typeof layout !== &#039;string&#039;) {
      layout = &#039;group&#039;;
    }
    if (newBlocks &amp;&amp; newBlocks.length &gt; 0) {
      // Because the block is not in the store yet we can&#039;t use
      // updateBlockAttributes so need to manually update attributes.
      newBlocks[0].attributes.layout = layouts[layout];
      replaceBlocks(clientIds, newBlocks);
    }
  };
  const onConvertToRow = () =&gt; onConvertToGroup(&#039;row&#039;);
  const onConvertToStack = () =&gt; onConvertToGroup(&#039;stack&#039;);
  const onConvertToGrid = () =&gt; onConvertToGroup(&#039;grid&#039;);

  // Don&#039;t render the button if the current selection cannot be grouped.
  // A good example is selecting multiple button blocks within a Buttons block:
  // The group block is not a valid child of Buttons, so we should not show the button.
  // Any blocks that are locked against removal also cannot be grouped.
  if (!isGroupable || !canRemove) {
    return null;
  }
  const canInsertRow = !!variations.find(({
    name
  }) =&gt; name === &#039;group-row&#039;);
  const canInsertStack = !!variations.find(({
    name
  }) =&gt; name === &#039;group-stack&#039;);
  const canInsertGrid = !!variations.find(({
    name
  }) =&gt; name === &#039;group-grid&#039;);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.ToolbarGroup, {
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarButton, {
      icon: library_group,
      label: (0,external_wp_i18n_namespaceObject._x)(&#039;Group&#039;, &#039;action: convert blocks to group&#039;),
      onClick: onConvertToGroup
    }), canInsertRow &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarButton, {
      icon: library_row,
      label: (0,external_wp_i18n_namespaceObject._x)(&#039;Row&#039;, &#039;action: convert blocks to row&#039;),
      onClick: onConvertToRow
    }), canInsertStack &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarButton, {
      icon: library_stack,
      label: (0,external_wp_i18n_namespaceObject._x)(&#039;Stack&#039;, &#039;action: convert blocks to stack&#039;),
      onClick: onConvertToStack
    }), canInsertGrid &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarButton, {
      icon: library_grid,
      label: (0,external_wp_i18n_namespaceObject._x)(&#039;Grid&#039;, &#039;action: convert blocks to grid&#039;),
      onClick: onConvertToGrid
    })]
  });
}
/* harmony default export */ const toolbar = (BlockGroupToolbar);

;// ./node_modules/@wordpress/block-editor/build-module/components/block-edit-visually-button/index.js
/**
 * WordPress dependencies
 */




/**
 * Internal dependencies
 */


function BlockEditVisuallyButton({
  clientIds
}) {
  // Edit visually only works for single block selection.
  const clientId = clientIds.length === 1 ? clientIds[0] : undefined;
  const canEditVisually = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; !!clientId &amp;&amp; select(store).getBlockMode(clientId) === &#039;html&#039;, [clientId]);
  const {
    toggleBlockMode
  } = (0,external_wp_data_namespaceObject.useDispatch)(store);
  if (!canEditVisually) {
    return null;
  }
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarGroup, {
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarButton, {
      onClick: () =&gt; {
        toggleBlockMode(clientId);
      },
      children: (0,external_wp_i18n_namespaceObject.__)(&#039;Edit visually&#039;)
    })
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/block-toolbar/block-name-context.js
/**
 * WordPress dependencies
 */

const __unstableBlockNameContext = (0,external_wp_element_namespaceObject.createContext)(&#039;&#039;);
/* harmony default export */ const block_name_context = (__unstableBlockNameContext);

;// ./node_modules/@wordpress/block-editor/build-module/components/navigable-toolbar/index.js
/**
 * WordPress dependencies
 */








/**
 * Internal dependencies
 */



function hasOnlyToolbarItem(elements) {
  const dataProp = &#039;toolbarItem&#039;;
  return !elements.some(element =&gt; !(dataProp in element.dataset));
}
function getAllFocusableToolbarItemsIn(container) {
  return Array.from(container.querySelectorAll(&#039;[data-toolbar-item]:not([disabled])&#039;));
}
function hasFocusWithin(container) {
  return container.contains(container.ownerDocument.activeElement);
}
function focusFirstTabbableIn(container) {
  const [firstTabbable] = external_wp_dom_namespaceObject.focus.tabbable.find(container);
  if (firstTabbable) {
    firstTabbable.focus({
      // When focusing newly mounted toolbars,
      // the position of the popover is often not right on the first render
      // This prevents the layout shifts when focusing the dialogs.
      preventScroll: true
    });
  }
}
function useIsAccessibleToolbar(toolbarRef) {
  /*
   * By default, we&#039;ll assume the starting accessible state of the Toolbar
   * is true, as it seems to be the most common case.
   *
   * Transitioning from an (initial) false to true state causes the
   * &lt;Toolbar /&gt; component to mount twice, which is causing undesired
   * side-effects. These side-effects appear to only affect certain
   * E2E tests.
   *
   * This was initial discovered in this pull-request:
   * https://github.com/WordPress/gutenberg/pull/23425
   */
  const initialAccessibleToolbarState = true;

  // By default, it&#039;s gonna render NavigableMenu. If all the tabbable elements
  // inside the toolbar are ToolbarItem components (or derived components like
  // ToolbarButton), then we can wrap them with the accessible Toolbar
  // component.
  const [isAccessibleToolbar, setIsAccessibleToolbar] = (0,external_wp_element_namespaceObject.useState)(initialAccessibleToolbarState);
  const determineIsAccessibleToolbar = (0,external_wp_element_namespaceObject.useCallback)(() =&gt; {
    const tabbables = external_wp_dom_namespaceObject.focus.tabbable.find(toolbarRef.current);
    const onlyToolbarItem = hasOnlyToolbarItem(tabbables);
    if (!onlyToolbarItem) {
      external_wp_deprecated_default()(&#039;Using custom components as toolbar controls&#039;, {
        since: &#039;5.6&#039;,
        alternative: &#039;ToolbarItem, ToolbarButton or ToolbarDropdownMenu components&#039;,
        link: &#039;https://developer.wordpress.org/block-editor/components/toolbar-button/#inside-blockcontrols&#039;
      });
    }
    setIsAccessibleToolbar(onlyToolbarItem);
  }, [toolbarRef]);
  (0,external_wp_element_namespaceObject.useLayoutEffect)(() =&gt; {
    // Toolbar buttons may be rendered asynchronously, so we use
    // MutationObserver to check if the toolbar subtree has been modified.
    const observer = new window.MutationObserver(determineIsAccessibleToolbar);
    observer.observe(toolbarRef.current, {
      childList: true,
      subtree: true
    });
    return () =&gt; observer.disconnect();
  }, [determineIsAccessibleToolbar, isAccessibleToolbar, toolbarRef]);
  return isAccessibleToolbar;
}
function useToolbarFocus({
  toolbarRef,
  focusOnMount,
  isAccessibleToolbar,
  defaultIndex,
  onIndexChange,
  shouldUseKeyboardFocusShortcut,
  focusEditorOnEscape
}) {
  // Make sure we don&#039;t use modified versions of this prop.
  const [initialFocusOnMount] = (0,external_wp_element_namespaceObject.useState)(focusOnMount);
  const [initialIndex] = (0,external_wp_element_namespaceObject.useState)(defaultIndex);
  const focusToolbar = (0,external_wp_element_namespaceObject.useCallback)(() =&gt; {
    focusFirstTabbableIn(toolbarRef.current);
  }, [toolbarRef]);
  const focusToolbarViaShortcut = () =&gt; {
    if (shouldUseKeyboardFocusShortcut) {
      focusToolbar();
    }
  };

  // Focus on toolbar when pressing alt+F10 when the toolbar is visible.
  (0,external_wp_keyboardShortcuts_namespaceObject.useShortcut)(&#039;core/block-editor/focus-toolbar&#039;, focusToolbarViaShortcut);
  (0,external_wp_element_namespaceObject.useEffect)(() =&gt; {
    if (initialFocusOnMount) {
      focusToolbar();
    }
  }, [isAccessibleToolbar, initialFocusOnMount, focusToolbar]);
  (0,external_wp_element_namespaceObject.useEffect)(() =&gt; {
    // Store ref so we have access on useEffect cleanup: https://legacy.reactjs.org/blog/2020/08/10/react-v17-rc.html#effect-cleanup-timing
    const navigableToolbarRef = toolbarRef.current;
    // If initialIndex is passed, we focus on that toolbar item when the
    // toolbar gets mounted and initial focus is not forced.
    // We have to wait for the next browser paint because block controls aren&#039;t
    // rendered right away when the toolbar gets mounted.
    let raf = 0;

    // If the toolbar already had focus before the render, we don&#039;t want to move it.
    // https://github.com/WordPress/gutenberg/issues/58511
    if (!initialFocusOnMount &amp;&amp; !hasFocusWithin(navigableToolbarRef)) {
      raf = window.requestAnimationFrame(() =&gt; {
        const items = getAllFocusableToolbarItemsIn(navigableToolbarRef);
        const index = initialIndex || 0;
        if (items[index] &amp;&amp; hasFocusWithin(navigableToolbarRef)) {
          items[index].focus({
            // When focusing newly mounted toolbars,
            // the position of the popover is often not right on the first render
            // This prevents the layout shifts when focusing the dialogs.
            preventScroll: true
          });
        }
      });
    }
    return () =&gt; {
      window.cancelAnimationFrame(raf);
      if (!onIndexChange || !navigableToolbarRef) {
        return;
      }
      // When the toolbar element is unmounted and onIndexChange is passed, we
      // pass the focused toolbar item index so it can be hydrated later.
      const items = getAllFocusableToolbarItemsIn(navigableToolbarRef);
      const index = items.findIndex(item =&gt; item.tabIndex === 0);
      onIndexChange(index);
    };
  }, [initialIndex, initialFocusOnMount, onIndexChange, toolbarRef]);
  const {
    getLastFocus
  } = unlock((0,external_wp_data_namespaceObject.useSelect)(store));
  /**
   * Handles returning focus to the block editor canvas when pressing escape.
   */
  (0,external_wp_element_namespaceObject.useEffect)(() =&gt; {
    const navigableToolbarRef = toolbarRef.current;
    if (focusEditorOnEscape) {
      const handleKeyDown = event =&gt; {
        const lastFocus = getLastFocus();
        if (event.keyCode === external_wp_keycodes_namespaceObject.ESCAPE &amp;&amp; lastFocus?.current) {
          // Focus the last focused element when pressing escape.
          event.preventDefault();
          lastFocus.current.focus();
        }
      };
      navigableToolbarRef.addEventListener(&#039;keydown&#039;, handleKeyDown);
      return () =&gt; {
        navigableToolbarRef.removeEventListener(&#039;keydown&#039;, handleKeyDown);
      };
    }
  }, [focusEditorOnEscape, getLastFocus, toolbarRef]);
}
function NavigableToolbar({
  children,
  focusOnMount,
  focusEditorOnEscape = false,
  shouldUseKeyboardFocusShortcut = true,
  __experimentalInitialIndex: initialIndex,
  __experimentalOnIndexChange: onIndexChange,
  orientation = &#039;horizontal&#039;,
  ...props
}) {
  const toolbarRef = (0,external_wp_element_namespaceObject.useRef)();
  const isAccessibleToolbar = useIsAccessibleToolbar(toolbarRef);
  useToolbarFocus({
    toolbarRef,
    focusOnMount,
    defaultIndex: initialIndex,
    onIndexChange,
    isAccessibleToolbar,
    shouldUseKeyboardFocusShortcut,
    focusEditorOnEscape
  });
  if (isAccessibleToolbar) {
    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Toolbar, {
      label: props[&#039;aria-label&#039;],
      ref: toolbarRef,
      orientation: orientation,
      ...props,
      children: children
    });
  }
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.NavigableMenu, {
    orientation: orientation,
    role: &quot;toolbar&quot;,
    ref: toolbarRef,
    ...props,
    children: children
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/block-toolbar/use-has-block-toolbar.js
/**
 * WordPress dependencies
 */


/**
 * Internal dependencies
 */


/**
 * Returns true if the block toolbar should be shown.
 *
 * @return {boolean} Whether the block toolbar component will be rendered.
 */
function useHasBlockToolbar() {
  const {
    isToolbarEnabled,
    isBlockDisabled
  } = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      getBlockEditingMode,
      getBlockName,
      getBlockSelectionStart
    } = select(store);

    // we only care about the 1st selected block
    // for the toolbar, so we use getBlockSelectionStart
    // instead of getSelectedBlockClientIds
    const selectedBlockClientId = getBlockSelectionStart();
    const blockType = selectedBlockClientId &amp;&amp; (0,external_wp_blocks_namespaceObject.getBlockType)(getBlockName(selectedBlockClientId));
    return {
      isToolbarEnabled: blockType &amp;&amp; (0,external_wp_blocks_namespaceObject.hasBlockSupport)(blockType, &#039;__experimentalToolbar&#039;, true),
      isBlockDisabled: getBlockEditingMode(selectedBlockClientId) === &#039;disabled&#039;
    };
  }, []);
  if (!isToolbarEnabled || isBlockDisabled) {
    return false;
  }
  return true;
}

;// ./node_modules/@wordpress/block-editor/build-module/components/block-toolbar/change-design.js
/**
 * WordPress dependencies
 */






/**
 * Internal dependencies
 */



const change_design_EMPTY_ARRAY = [];
const MAX_PATTERNS_TO_SHOW = 6;
const change_design_POPOVER_PROPS = {
  placement: &#039;bottom-start&#039;
};
function ChangeDesign({
  clientId
}) {
  const {
    categories,
    currentPatternName,
    patterns
  } = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      getBlockAttributes,
      getBlockRootClientId,
      __experimentalGetAllowedPatterns
    } = select(store);
    const attributes = getBlockAttributes(clientId);
    const _categories = attributes?.metadata?.categories || change_design_EMPTY_ARRAY;
    const rootBlock = getBlockRootClientId(clientId);

    // Calling `__experimentalGetAllowedPatterns` is expensive.
    // Checking if the block can be changed prevents unnecessary selector calls.
    // See: https://github.com/WordPress/gutenberg/pull/64736.
    const _patterns = _categories.length &gt; 0 ? __experimentalGetAllowedPatterns(rootBlock) : change_design_EMPTY_ARRAY;
    return {
      categories: _categories,
      currentPatternName: attributes?.metadata?.patternName,
      patterns: _patterns
    };
  }, [clientId]);
  const {
    replaceBlocks
  } = (0,external_wp_data_namespaceObject.useDispatch)(store);
  const sameCategoryPatternsWithSingleWrapper = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; {
    if (categories.length === 0 || !patterns || patterns.length === 0) {
      return change_design_EMPTY_ARRAY;
    }
    return patterns.filter(pattern =&gt; {
      const isCorePattern = pattern.source === &#039;core&#039; || pattern.source?.startsWith(&#039;pattern-directory&#039;) &amp;&amp; pattern.source !== &#039;pattern-directory/theme&#039;;
      return (
        // Check if the pattern has only one top level block,
        // otherwise we may switch to a pattern that doesn&#039;t have replacement suggestions.
        pattern.blocks.length === 1 &amp;&amp;
        // We exclude the core patterns and pattern directory patterns that are not theme patterns.
        !isCorePattern &amp;&amp;
        // Exclude current pattern.
        currentPatternName !== pattern.name &amp;&amp; pattern.categories?.some(category =&gt; {
          return categories.includes(category);
        }) &amp;&amp; (
        // Check if the pattern is not a synced pattern.
        pattern.syncStatus === &#039;unsynced&#039; || !pattern.id)
      );
    }).slice(0, MAX_PATTERNS_TO_SHOW);
  }, [categories, currentPatternName, patterns]);
  if (sameCategoryPatternsWithSingleWrapper.length &lt; 2) {
    return null;
  }
  const onClickPattern = pattern =&gt; {
    var _pattern$blocks;
    const newBlocks = ((_pattern$blocks = pattern.blocks) !== null &amp;&amp; _pattern$blocks !== void 0 ? _pattern$blocks : []).map(block =&gt; {
      return (0,external_wp_blocks_namespaceObject.cloneBlock)(block);
    });
    newBlocks[0].attributes.metadata = {
      ...newBlocks[0].attributes.metadata,
      categories
    };
    replaceBlocks(clientId, newBlocks);
  };
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Dropdown, {
    popoverProps: change_design_POPOVER_PROPS,
    renderToggle: ({
      onToggle,
      isOpen
    }) =&gt; {
      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarGroup, {
        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarButton, {
          onClick: () =&gt; onToggle(!isOpen),
          &quot;aria-expanded&quot;: isOpen,
          children: (0,external_wp_i18n_namespaceObject.__)(&#039;Change design&#039;)
        })
      });
    },
    renderContent: () =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalDropdownContentWrapper, {
      className: &quot;block-editor-block-toolbar-change-design-content-wrapper&quot;,
      paddingSize: &quot;none&quot;,
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_patterns_list, {
        blockPatterns: sameCategoryPatternsWithSingleWrapper,
        onClickPattern: onClickPattern,
        showTitlesAsTooltip: true
      })
    })
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/block-toolbar/switch-section-style.js
/**
 * WordPress dependencies
 */





/**
 * Internal dependencies
 */







const styleIcon = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.SVG, {
  viewBox: &quot;0 0 24 24&quot;,
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  width: &quot;24&quot;,
  height: &quot;24&quot;,
  &quot;aria-hidden&quot;: &quot;true&quot;,
  focusable: &quot;false&quot;,
  children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Path, {
    d: &quot;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&quot;
  }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Path, {
    stroke: &quot;currentColor&quot;,
    strokeWidth: &quot;1.5&quot;,
    d: &quot;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&quot;
  })]
});
function SwitchSectionStyle({
  clientId
}) {
  var _mergedConfig$setting, _mergedConfig$styles;
  const {
    stylesToRender,
    activeStyle,
    className
  } = useStylesForBlocks({
    clientId
  });
  const {
    updateBlockAttributes
  } = (0,external_wp_data_namespaceObject.useDispatch)(store);

  // Get global styles data
  const {
    merged: mergedConfig
  } = (0,external_wp_element_namespaceObject.useContext)(GlobalStylesContext);
  const {
    globalSettings,
    globalStyles,
    blockName
  } = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const settings = select(store).getSettings();
    return {
      globalSettings: settings.__experimentalFeatures,
      globalStyles: settings[globalStylesDataKey],
      blockName: select(store).getBlockName(clientId)
    };
  }, [clientId]);

  // Get the background color for the active style
  const activeStyleBackground = activeStyle?.name ? getVariationStylesWithRefValues({
    settings: (_mergedConfig$setting = mergedConfig?.settings) !== null &amp;&amp; _mergedConfig$setting !== void 0 ? _mergedConfig$setting : globalSettings,
    styles: (_mergedConfig$styles = mergedConfig?.styles) !== null &amp;&amp; _mergedConfig$styles !== void 0 ? _mergedConfig$styles : globalStyles
  }, blockName, activeStyle.name)?.color?.background : undefined;
  if (!stylesToRender || stylesToRender.length === 0) {
    return null;
  }
  const handleStyleSwitch = () =&gt; {
    const currentIndex = stylesToRender.findIndex(style =&gt; style.name === activeStyle.name);
    const nextIndex = (currentIndex + 1) % stylesToRender.length;
    const nextStyle = stylesToRender[nextIndex];
    const styleClassName = replaceActiveStyle(className, activeStyle, nextStyle);
    updateBlockAttributes(clientId, {
      className: styleClassName
    });
  };
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarGroup, {
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarButton, {
      onClick: handleStyleSwitch,
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Shuffle styles&#039;),
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Icon, {
        icon: styleIcon,
        style: {
          fill: activeStyleBackground || &#039;transparent&#039;
        }
      })
    })
  });
}
/* harmony default export */ const switch_section_style = (SwitchSectionStyle);

;// ./node_modules/@wordpress/block-editor/build-module/components/block-toolbar/index.js
/**
 * External dependencies
 */


/**
 * WordPress dependencies
 */







/**
 * Internal dependencies
 */


















/**
 * Renders the block toolbar.
 *
 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/block-toolbar/README.md
 *
 * @param {Object}   props                             Components props.
 * @param {boolean}  props.hideDragHandle              Show or hide the Drag Handle for drag and drop functionality.
 * @param {boolean}  props.focusOnMount                Focus the toolbar when mounted.
 * @param {number}   props.__experimentalInitialIndex  The initial index of the toolbar item to focus.
 * @param {Function} props.__experimentalOnIndexChange Callback function to be called when the index of the focused toolbar item changes.
 * @param {string}   props.variant                     Style variant of the toolbar, also passed to the Dropdowns rendered from Block Toolbar Buttons.
 */

function PrivateBlockToolbar({
  hideDragHandle,
  focusOnMount,
  __experimentalInitialIndex,
  __experimentalOnIndexChange,
  variant = &#039;unstyled&#039;
}) {
  const {
    blockClientId,
    blockClientIds,
    isDefaultEditingMode,
    blockType,
    toolbarKey,
    shouldShowVisualToolbar,
    showParentSelector,
    isUsingBindings,
    hasParentPattern,
    hasContentOnlyLocking,
    showShuffleButton,
    showSlots,
    showGroupButtons,
    showLockButtons,
    showSwitchSectionStyleButton,
    hasFixedToolbar,
    isNavigationMode
  } = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      getBlockName,
      getBlockMode,
      getBlockParents,
      getSelectedBlockClientIds,
      isBlockValid,
      getBlockEditingMode,
      getBlockAttributes,
      getBlockParentsByBlockName,
      getTemplateLock,
      getSettings,
      getParentSectionBlock,
      isZoomOut,
      isNavigationMode: _isNavigationMode
    } = unlock(select(store));
    const selectedBlockClientIds = getSelectedBlockClientIds();
    const selectedBlockClientId = selectedBlockClientIds[0];
    const parents = getBlockParents(selectedBlockClientId);
    const parentSection = getParentSectionBlock(selectedBlockClientId);
    const parentClientId = parentSection !== null &amp;&amp; parentSection !== void 0 ? parentSection : parents[parents.length - 1];
    const parentBlockName = getBlockName(parentClientId);
    const parentBlockType = (0,external_wp_blocks_namespaceObject.getBlockType)(parentBlockName);
    const editingMode = getBlockEditingMode(selectedBlockClientId);
    const _isDefaultEditingMode = editingMode === &#039;default&#039;;
    const _blockName = getBlockName(selectedBlockClientId);
    const isValid = selectedBlockClientIds.every(id =&gt; isBlockValid(id));
    const isVisual = selectedBlockClientIds.every(id =&gt; getBlockMode(id) === &#039;visual&#039;);
    const _isUsingBindings = selectedBlockClientIds.every(clientId =&gt; !!getBlockAttributes(clientId)?.metadata?.bindings);
    const _hasParentPattern = selectedBlockClientIds.every(clientId =&gt; getBlockParentsByBlockName(clientId, &#039;core/block&#039;, true).length &gt; 0);

    // If one or more selected blocks are locked, do not show the BlockGroupToolbar.
    const _hasTemplateLock = selectedBlockClientIds.some(id =&gt; getTemplateLock(id) === &#039;contentOnly&#039;);
    const _isZoomOut = isZoomOut();
    return {
      blockClientId: selectedBlockClientId,
      blockClientIds: selectedBlockClientIds,
      isDefaultEditingMode: _isDefaultEditingMode,
      blockType: selectedBlockClientId &amp;&amp; (0,external_wp_blocks_namespaceObject.getBlockType)(_blockName),
      shouldShowVisualToolbar: isValid &amp;&amp; isVisual,
      toolbarKey: `${selectedBlockClientId}${parentClientId}`,
      showParentSelector: !_isZoomOut &amp;&amp; parentBlockType &amp;&amp; editingMode !== &#039;contentOnly&#039; &amp;&amp; getBlockEditingMode(parentClientId) !== &#039;disabled&#039; &amp;&amp; (0,external_wp_blocks_namespaceObject.hasBlockSupport)(parentBlockType, &#039;__experimentalParentSelector&#039;, true) &amp;&amp; selectedBlockClientIds.length === 1,
      isUsingBindings: _isUsingBindings,
      hasParentPattern: _hasParentPattern,
      hasContentOnlyLocking: _hasTemplateLock,
      showShuffleButton: _isZoomOut,
      showSlots: !_isZoomOut,
      showGroupButtons: !_isZoomOut,
      showLockButtons: !_isZoomOut,
      showSwitchSectionStyleButton: _isZoomOut,
      hasFixedToolbar: getSettings().hasFixedToolbar,
      isNavigationMode: _isNavigationMode()
    };
  }, []);
  const toolbarWrapperRef = (0,external_wp_element_namespaceObject.useRef)(null);

  // Handles highlighting the current block outline on hover or focus of the
  // block type toolbar area.
  const nodeRef = (0,external_wp_element_namespaceObject.useRef)();
  const showHoveredOrFocusedGestures = useShowHoveredOrFocusedGestures({
    ref: nodeRef
  });
  const isLargeViewport = !(0,external_wp_compose_namespaceObject.useViewportMatch)(&#039;medium&#039;, &#039;&lt;&#039;);
  const hasBlockToolbar = useHasBlockToolbar();
  if (!hasBlockToolbar) {
    return null;
  }
  const isMultiToolbar = blockClientIds.length &gt; 1;
  const isSynced = (0,external_wp_blocks_namespaceObject.isReusableBlock)(blockType) || (0,external_wp_blocks_namespaceObject.isTemplatePart)(blockType);

  // Shifts the toolbar to make room for the parent block selector.
  const classes = dist_clsx(&#039;block-editor-block-contextual-toolbar&#039;, {
    &#039;has-parent&#039;: showParentSelector,
    &#039;is-inverted-toolbar&#039;: isNavigationMode &amp;&amp; !hasFixedToolbar
  });
  const innerClasses = dist_clsx(&#039;block-editor-block-toolbar&#039;, {
    &#039;is-synced&#039;: isSynced,
    &#039;is-connected&#039;: isUsingBindings
  });
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(NavigableToolbar, {
    focusEditorOnEscape: true,
    className: classes
    /* translators: accessibility text for the block toolbar */,
    &quot;aria-label&quot;: (0,external_wp_i18n_namespaceObject.__)(&#039;Block tools&#039;)
    // The variant is applied as &quot;toolbar&quot; when undefined, which is the black border style of the dropdown from the toolbar popover.
    ,
    variant: variant === &#039;toolbar&#039; ? undefined : variant,
    focusOnMount: focusOnMount,
    __experimentalInitialIndex: __experimentalInitialIndex,
    __experimentalOnIndexChange: __experimentalOnIndexChange
    // Resets the index whenever the active block changes so
    // this is not persisted. See https://github.com/WordPress/gutenberg/pull/25760#issuecomment-717906169
    ,
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;div&quot;, {
      ref: toolbarWrapperRef,
      className: innerClasses,
      children: [showParentSelector &amp;&amp; !isMultiToolbar &amp;&amp; isLargeViewport &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockParentSelector, {}), (shouldShowVisualToolbar || isMultiToolbar) &amp;&amp; !hasParentPattern &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
        ref: nodeRef,
        ...showHoveredOrFocusedGestures,
        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.ToolbarGroup, {
          className: &quot;block-editor-block-toolbar__block-controls&quot;,
          children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_switcher, {
            clientIds: blockClientIds
          }), !isMultiToolbar &amp;&amp; isDefaultEditingMode &amp;&amp; showLockButtons &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockLockToolbar, {
            clientId: blockClientId
          }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_mover, {
            clientIds: blockClientIds,
            hideDragHandle: hideDragHandle
          })]
        })
      }), !hasContentOnlyLocking &amp;&amp; shouldShowVisualToolbar &amp;&amp; isMultiToolbar &amp;&amp; showGroupButtons &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(toolbar, {}), showShuffleButton &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ChangeDesign, {
        clientId: blockClientIds[0]
      }), showSwitchSectionStyleButton &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(switch_section_style, {
        clientId: blockClientIds[0]
      }), shouldShowVisualToolbar &amp;&amp; showSlots &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_controls.Slot, {
          group: &quot;parent&quot;,
          className: &quot;block-editor-block-toolbar__slot&quot;
        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_controls.Slot, {
          group: &quot;block&quot;,
          className: &quot;block-editor-block-toolbar__slot&quot;
        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_controls.Slot, {
          className: &quot;block-editor-block-toolbar__slot&quot;
        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_controls.Slot, {
          group: &quot;inline&quot;,
          className: &quot;block-editor-block-toolbar__slot&quot;
        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_controls.Slot, {
          group: &quot;other&quot;,
          className: &quot;block-editor-block-toolbar__slot&quot;
        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_name_context.Provider, {
          value: blockType?.name,
          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_toolbar_last_item.Slot, {})
        })]
      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockEditVisuallyButton, {
        clientIds: blockClientIds
      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_settings_menu, {
        clientIds: blockClientIds
      })]
    })
  }, toolbarKey);
}

/**
 * Renders the block toolbar.
 *
 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/block-toolbar/README.md
 *
 * @param {Object}  props                Components props.
 * @param {boolean} props.hideDragHandle Show or hide the Drag Handle for drag and drop functionality.
 * @param {string}  props.variant        Style variant of the toolbar, also passed to the Dropdowns rendered from Block Toolbar Buttons.
 */
function BlockToolbar({
  hideDragHandle,
  variant
}) {
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PrivateBlockToolbar, {
    hideDragHandle: hideDragHandle,
    variant: variant,
    focusOnMount: undefined,
    __experimentalInitialIndex: undefined,
    __experimentalOnIndexChange: undefined
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/block-tools/block-toolbar-popover.js
/**
 * External dependencies
 */

/**
 * WordPress dependencies
 */



/**
 * Internal dependencies
 */






function BlockToolbarPopover({
  clientId,
  isTyping,
  __unstableContentRef
}) {
  const {
    capturingClientId,
    isInsertionPointVisible,
    lastClientId
  } = useSelectedBlockToolProps(clientId);

  // Stores the active toolbar item index so the block toolbar can return focus
  // to it when re-mounting.
  const initialToolbarItemIndexRef = (0,external_wp_element_namespaceObject.useRef)();
  (0,external_wp_element_namespaceObject.useEffect)(() =&gt; {
    // Resets the index whenever the active block changes so this is not
    // persisted. See https://github.com/WordPress/gutenberg/pull/25760#issuecomment-717906169
    initialToolbarItemIndexRef.current = undefined;
  }, [clientId]);
  const {
    stopTyping
  } = (0,external_wp_data_namespaceObject.useDispatch)(store);
  const isToolbarForcedRef = (0,external_wp_element_namespaceObject.useRef)(false);
  (0,external_wp_keyboardShortcuts_namespaceObject.useShortcut)(&#039;core/block-editor/focus-toolbar&#039;, () =&gt; {
    isToolbarForcedRef.current = true;
    stopTyping(true);
  });
  (0,external_wp_element_namespaceObject.useEffect)(() =&gt; {
    isToolbarForcedRef.current = false;
  });

  // If the block has a parent with __experimentalCaptureToolbars enabled,
  // the toolbar should be positioned over the topmost capturing parent.
  const clientIdToPositionOver = capturingClientId || clientId;
  const popoverProps = useBlockToolbarPopoverProps({
    contentElement: __unstableContentRef?.current,
    clientId: clientIdToPositionOver
  });
  return !isTyping &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PrivateBlockPopover, {
    clientId: clientIdToPositionOver,
    bottomClientId: lastClientId,
    className: dist_clsx(&#039;block-editor-block-list__block-popover&#039;, {
      &#039;is-insertion-point-visible&#039;: isInsertionPointVisible
    }),
    resize: false,
    ...popoverProps,
    __unstableContentRef: __unstableContentRef,
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PrivateBlockToolbar
    // If the toolbar is being shown because of being forced
    // it should focus the toolbar right after the mount.
    , {
      focusOnMount: isToolbarForcedRef.current,
      __experimentalInitialIndex: initialToolbarItemIndexRef.current,
      __experimentalOnIndexChange: index =&gt; {
        initialToolbarItemIndexRef.current = index;
      },
      variant: &quot;toolbar&quot;
    })
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/block-tools/zoom-out-mode-inserter-button.js
/**
 * External dependencies
 */


/**
 * WordPress dependencies
 */




function ZoomOutModeInserterButton({
  onClick
}) {
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
    variant: &quot;primary&quot;,
    icon: library_plus,
    size: &quot;compact&quot;,
    className: dist_clsx(&#039;block-editor-button-pattern-inserter__button&#039;, &#039;block-editor-block-tools__zoom-out-mode-inserter-button&#039;),
    onClick: onClick,
    label: (0,external_wp_i18n_namespaceObject._x)(&#039;Add pattern&#039;, &#039;Generic label for pattern inserter button&#039;)
  });
}
/* harmony default export */ const zoom_out_mode_inserter_button = (ZoomOutModeInserterButton);

;// ./node_modules/@wordpress/block-editor/build-module/components/block-tools/zoom-out-mode-inserters.js
/**
 * WordPress dependencies
 */



/**
 * Internal dependencies
 */





function ZoomOutModeInserters() {
  const [isReady, setIsReady] = (0,external_wp_element_namespaceObject.useState)(false);
  const {
    hasSelection,
    blockOrder,
    setInserterIsOpened,
    sectionRootClientId,
    selectedBlockClientId,
    blockInsertionPoint,
    insertionPointVisible
  } = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      getSettings,
      getBlockOrder,
      getSelectionStart,
      getSelectedBlockClientId,
      getSectionRootClientId,
      getBlockInsertionPoint,
      isBlockInsertionPointVisible
    } = unlock(select(store));
    const root = getSectionRootClientId();
    return {
      hasSelection: !!getSelectionStart().clientId,
      blockOrder: getBlockOrder(root),
      sectionRootClientId: root,
      setInserterIsOpened: getSettings().__experimentalSetIsInserterOpened,
      selectedBlockClientId: getSelectedBlockClientId(),
      blockInsertionPoint: getBlockInsertionPoint(),
      insertionPointVisible: isBlockInsertionPointVisible()
    };
  }, []);

  // eslint-disable-next-line @wordpress/no-unused-vars-before-return
  const {
    showInsertionPoint
  } = unlock((0,external_wp_data_namespaceObject.useDispatch)(store));

  // Defer the initial rendering to avoid the jumps due to the animation.
  (0,external_wp_element_namespaceObject.useEffect)(() =&gt; {
    const timeout = setTimeout(() =&gt; {
      setIsReady(true);
    }, 500);
    return () =&gt; {
      clearTimeout(timeout);
    };
  }, []);
  if (!isReady || !hasSelection) {
    return null;
  }
  const previousClientId = selectedBlockClientId;
  const index = blockOrder.findIndex(clientId =&gt; selectedBlockClientId === clientId);
  const insertionIndex = index + 1;
  const nextClientId = blockOrder[insertionIndex];

  // If the block insertion point is visible, and the insertion
  // Indices match then we don&#039;t need to render the inserter.
  if (insertionPointVisible &amp;&amp; blockInsertionPoint?.index === insertionIndex) {
    return null;
  }
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inbetween, {
    previousClientId: previousClientId,
    nextClientId: nextClientId,
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(zoom_out_mode_inserter_button, {
      onClick: () =&gt; {
        setInserterIsOpened({
          rootClientId: sectionRootClientId,
          insertionIndex,
          tab: &#039;patterns&#039;,
          category: &#039;all&#039;
        });
        showInsertionPoint(sectionRootClientId, insertionIndex, {
          operation: &#039;insert&#039;
        });
      }
    })
  });
}
/* harmony default export */ const zoom_out_mode_inserters = (ZoomOutModeInserters);

;// ./node_modules/@wordpress/block-editor/build-module/components/block-tools/use-show-block-tools.js
/**
 * WordPress dependencies
 */



/**
 * Internal dependencies
 */



/**
 * Source of truth for which block tools are showing in the block editor.
 *
 * @return {Object} Object of which block tools will be shown.
 */
function useShowBlockTools() {
  return (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      getSelectedBlockClientId,
      getFirstMultiSelectedBlockClientId,
      getBlock,
      getBlockMode,
      getSettings,
      __unstableGetEditorMode,
      isTyping
    } = unlock(select(store));
    const clientId = getSelectedBlockClientId() || getFirstMultiSelectedBlockClientId();
    const block = getBlock(clientId);
    const editorMode = __unstableGetEditorMode();
    const hasSelectedBlock = !!clientId &amp;&amp; !!block;
    const isEmptyDefaultBlock = hasSelectedBlock &amp;&amp; (0,external_wp_blocks_namespaceObject.isUnmodifiedDefaultBlock)(block) &amp;&amp; getBlockMode(clientId) !== &#039;html&#039;;
    const _showEmptyBlockSideInserter = clientId &amp;&amp; !isTyping() &amp;&amp;
    // Hide the block inserter on the navigation mode.
    // See https://github.com/WordPress/gutenberg/pull/66636#discussion_r1824728483.
    editorMode !== &#039;navigation&#039; &amp;&amp; isEmptyDefaultBlock;
    const _showBlockToolbarPopover = !getSettings().hasFixedToolbar &amp;&amp; !_showEmptyBlockSideInserter &amp;&amp; hasSelectedBlock &amp;&amp; !isEmptyDefaultBlock;
    return {
      showEmptyBlockSideInserter: _showEmptyBlockSideInserter,
      showBlockToolbarPopover: _showBlockToolbarPopover
    };
  }, []);
}

;// ./node_modules/@wordpress/block-editor/build-module/components/block-tools/index.js
/**
 * WordPress dependencies
 */









/**
 * Internal dependencies
 */









function block_tools_selector(select) {
  const {
    getSelectedBlockClientId,
    getFirstMultiSelectedBlockClientId,
    getSettings,
    isTyping,
    isDragging,
    isZoomOut
  } = unlock(select(store));
  const clientId = getSelectedBlockClientId() || getFirstMultiSelectedBlockClientId();
  return {
    clientId,
    hasFixedToolbar: getSettings().hasFixedToolbar,
    isTyping: isTyping(),
    isZoomOutMode: isZoomOut(),
    isDragging: isDragging()
  };
}

/**
 * Renders block tools (the block toolbar, select/navigation mode toolbar, the
 * insertion point and a slot for the inline rich text toolbar). Must be wrapped
 * around the block content and editor styles wrapper or iframe.
 *
 * @param {Object} $0                      Props.
 * @param {Object} $0.children             The block content and style container.
 * @param {Object} $0.__unstableContentRef Ref holding the content scroll container.
 */
function BlockTools({
  children,
  __unstableContentRef,
  ...props
}) {
  const {
    clientId,
    hasFixedToolbar,
    isTyping,
    isZoomOutMode,
    isDragging
  } = (0,external_wp_data_namespaceObject.useSelect)(block_tools_selector, []);
  const isMatch = (0,external_wp_keyboardShortcuts_namespaceObject.__unstableUseShortcutEventMatch)();
  const {
    getBlocksByClientId,
    getSelectedBlockClientIds,
    getBlockRootClientId,
    isGroupable
  } = (0,external_wp_data_namespaceObject.useSelect)(store);
  const {
    getGroupingBlockName
  } = (0,external_wp_data_namespaceObject.useSelect)(external_wp_blocks_namespaceObject.store);
  const {
    showEmptyBlockSideInserter,
    showBlockToolbarPopover
  } = useShowBlockTools();
  const {
    duplicateBlocks,
    removeBlocks,
    replaceBlocks,
    insertAfterBlock,
    insertBeforeBlock,
    selectBlock,
    moveBlocksUp,
    moveBlocksDown,
    expandBlock
  } = unlock((0,external_wp_data_namespaceObject.useDispatch)(store));
  function onKeyDown(event) {
    if (event.defaultPrevented) {
      return;
    }
    if (isMatch(&#039;core/block-editor/move-up&#039;, event) || isMatch(&#039;core/block-editor/move-down&#039;, event)) {
      const clientIds = getSelectedBlockClientIds();
      if (clientIds.length) {
        event.preventDefault();
        const rootClientId = getBlockRootClientId(clientIds[0]);
        const direction = isMatch(&#039;core/block-editor/move-up&#039;, event) ? &#039;up&#039; : &#039;down&#039;;
        if (direction === &#039;up&#039;) {
          moveBlocksUp(clientIds, rootClientId);
        } else {
          moveBlocksDown(clientIds, rootClientId);
        }
        const blockLength = Array.isArray(clientIds) ? clientIds.length : 1;
        const message = (0,external_wp_i18n_namespaceObject.sprintf)(
        // translators: %d: the name of the block that has been moved
        (0,external_wp_i18n_namespaceObject._n)(&#039;%d block moved.&#039;, &#039;%d blocks moved.&#039;, clientIds.length), blockLength);
        (0,external_wp_a11y_namespaceObject.speak)(message);
      }
    } else if (isMatch(&#039;core/block-editor/duplicate&#039;, event)) {
      const clientIds = getSelectedBlockClientIds();
      if (clientIds.length) {
        event.preventDefault();
        duplicateBlocks(clientIds);
      }
    } else if (isMatch(&#039;core/block-editor/remove&#039;, event)) {
      const clientIds = getSelectedBlockClientIds();
      if (clientIds.length) {
        event.preventDefault();
        removeBlocks(clientIds);
      }
    } else if (isMatch(&#039;core/block-editor/insert-after&#039;, event)) {
      const clientIds = getSelectedBlockClientIds();
      if (clientIds.length) {
        event.preventDefault();
        insertAfterBlock(clientIds[clientIds.length - 1]);
      }
    } else if (isMatch(&#039;core/block-editor/insert-before&#039;, event)) {
      const clientIds = getSelectedBlockClientIds();
      if (clientIds.length) {
        event.preventDefault();
        insertBeforeBlock(clientIds[0]);
      }
    } else if (isMatch(&#039;core/block-editor/unselect&#039;, event)) {
      if (event.target.closest(&#039;[role=toolbar]&#039;)) {
        // This shouldn&#039;t be necessary, but we have a combination of a few things all combining to create a situation where:
        // - Because the block toolbar uses createPortal to populate the block toolbar fills, we can&#039;t rely on the React event bubbling to hit the onKeyDown listener for the block toolbar
        // - Since we can&#039;t use the React tree, we use the DOM tree which _should_ handle the event bubbling correctly from a `createPortal` element.
        // - This bubbles via the React tree, which hits this `unselect` escape keypress before the block toolbar DOM event listener has access to it.
        // 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.
        return;
      }
      const clientIds = getSelectedBlockClientIds();
      if (clientIds.length &gt; 1) {
        event.preventDefault();
        // If there is more than one block selected, select the first
        // block so that focus is directed back to the beginning of the selection.
        // In effect, to the user this feels like deselecting the multi-selection.
        selectBlock(clientIds[0]);
      }
    } else if (isMatch(&#039;core/block-editor/collapse-list-view&#039;, event)) {
      // If focus is currently within a text field, such as a rich text block or other editable field,
      // skip collapsing the list view, and allow the keyboard shortcut to be handled by the text field.
      // This condition checks for both the active element and the active element within an iframed editor.
      if ((0,external_wp_dom_namespaceObject.isTextField)(event.target) || (0,external_wp_dom_namespaceObject.isTextField)(event.target?.contentWindow?.document?.activeElement)) {
        return;
      }
      event.preventDefault();
      expandBlock(clientId);
    } else if (isMatch(&#039;core/block-editor/group&#039;, event)) {
      const clientIds = getSelectedBlockClientIds();
      if (clientIds.length &gt; 1 &amp;&amp; isGroupable(clientIds)) {
        event.preventDefault();
        const blocks = getBlocksByClientId(clientIds);
        const groupingBlockName = getGroupingBlockName();
        const newBlocks = (0,external_wp_blocks_namespaceObject.switchToBlockType)(blocks, groupingBlockName);
        replaceBlocks(clientIds, newBlocks);
        (0,external_wp_a11y_namespaceObject.speak)((0,external_wp_i18n_namespaceObject.__)(&#039;Selected blocks are grouped.&#039;));
      }
    }
  }
  const blockToolbarRef = use_popover_scroll(__unstableContentRef);
  const blockToolbarAfterRef = use_popover_scroll(__unstableContentRef);
  return (
    /*#__PURE__*/
    // eslint-disable-next-line jsx-a11y/no-static-element-interactions
    (0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
      ...props,
      onKeyDown: onKeyDown,
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(insertion_point_InsertionPointOpenRef.Provider, {
        value: (0,external_wp_element_namespaceObject.useRef)(false),
        children: [!isTyping &amp;&amp; !isZoomOutMode &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(InsertionPoint, {
          __unstableContentRef: __unstableContentRef
        }), showEmptyBlockSideInserter &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(EmptyBlockInserter, {
          __unstableContentRef: __unstableContentRef,
          clientId: clientId
        }), showBlockToolbarPopover &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockToolbarPopover, {
          __unstableContentRef: __unstableContentRef,
          clientId: clientId,
          isTyping: isTyping
        }), !isZoomOutMode &amp;&amp; !hasFixedToolbar &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Popover.Slot, {
          name: &quot;block-toolbar&quot;,
          ref: blockToolbarRef
        }), children, /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Popover.Slot, {
          name: &quot;__unstable-block-tools-after&quot;,
          ref: blockToolbarAfterRef
        }), isZoomOutMode &amp;&amp; !isDragging &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(zoom_out_mode_inserters, {
          __unstableContentRef: __unstableContentRef
        })]
      })
    })
  );
}

;// external [&quot;wp&quot;,&quot;commands&quot;]
const external_wp_commands_namespaceObject = window[&quot;wp&quot;][&quot;commands&quot;];
;// ./node_modules/@wordpress/icons/build-module/library/ungroup.js
/**
 * WordPress dependencies
 */


const ungroup = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;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&quot;
  })
});
/* harmony default export */ const library_ungroup = (ungroup);

;// ./node_modules/@wordpress/icons/build-module/library/trash.js
/**
 * WordPress dependencies
 */


const trash = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    fillRule: &quot;evenodd&quot;,
    clipRule: &quot;evenodd&quot;,
    d: &quot;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&quot;
  })
});
/* harmony default export */ const library_trash = (trash);

;// ./node_modules/@wordpress/block-editor/build-module/components/use-block-commands/index.js
/**
 * WordPress dependencies
 */






/**
 * Internal dependencies
 */



const getTransformCommands = () =&gt; function useTransformCommands() {
  const {
    replaceBlocks,
    multiSelect
  } = (0,external_wp_data_namespaceObject.useDispatch)(store);
  const {
    blocks,
    clientIds,
    canRemove,
    possibleBlockTransformations,
    invalidSelection
  } = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      getBlockRootClientId,
      getBlockTransformItems,
      getSelectedBlockClientIds,
      getBlocksByClientId,
      canRemoveBlocks
    } = select(store);
    const selectedBlockClientIds = getSelectedBlockClientIds();
    const selectedBlocks = getBlocksByClientId(selectedBlockClientIds);

    // selectedBlocks can have `null`s when something tries to call `selectBlock` with an inexistent clientId.
    // These nulls will cause fatal errors down the line.
    // In order to prevent discrepancies between selectedBlockClientIds and selectedBlocks, we effectively treat the entire selection as invalid.
    // @see https://github.com/WordPress/gutenberg/pull/59410#issuecomment-2006304536
    if (selectedBlocks.filter(block =&gt; !block).length &gt; 0) {
      return {
        invalidSelection: true
      };
    }
    const rootClientId = getBlockRootClientId(selectedBlockClientIds[0]);
    return {
      blocks: selectedBlocks,
      clientIds: selectedBlockClientIds,
      possibleBlockTransformations: getBlockTransformItems(selectedBlocks, rootClientId),
      canRemove: canRemoveBlocks(selectedBlockClientIds),
      invalidSelection: false
    };
  }, []);
  if (invalidSelection) {
    return {
      isLoading: false,
      commands: []
    };
  }
  const isTemplate = blocks.length === 1 &amp;&amp; (0,external_wp_blocks_namespaceObject.isTemplatePart)(blocks[0]);
  function selectForMultipleBlocks(insertedBlocks) {
    if (insertedBlocks.length &gt; 1) {
      multiSelect(insertedBlocks[0].clientId, insertedBlocks[insertedBlocks.length - 1].clientId);
    }
  }

  // Simple block transformation based on the `Block Transforms` API.
  function onBlockTransform(name) {
    const newBlocks = (0,external_wp_blocks_namespaceObject.switchToBlockType)(blocks, name);
    replaceBlocks(clientIds, newBlocks);
    selectForMultipleBlocks(newBlocks);
  }

  /**
   * The `isTemplate` check is a stopgap solution here.
   * Ideally, the Transforms API should handle this
   * by allowing to exclude blocks from wildcard transformations.
   */
  const hasPossibleBlockTransformations = !!possibleBlockTransformations.length &amp;&amp; canRemove &amp;&amp; !isTemplate;
  if (!clientIds || clientIds.length &lt; 1 || !hasPossibleBlockTransformations) {
    return {
      isLoading: false,
      commands: []
    };
  }
  const commands = possibleBlockTransformations.map(transformation =&gt; {
    const {
      name,
      title,
      icon
    } = transformation;
    return {
      name: &#039;core/block-editor/transform-to-&#039; + name.replace(&#039;/&#039;, &#039;-&#039;),
      /* translators: %s: Block or block variation name. */
      label: (0,external_wp_i18n_namespaceObject.sprintf)((0,external_wp_i18n_namespaceObject.__)(&#039;Transform to %s&#039;), title),
      icon: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_icon, {
        icon: icon
      }),
      callback: ({
        close
      }) =&gt; {
        onBlockTransform(name);
        close();
      }
    };
  });
  return {
    isLoading: false,
    commands
  };
};
const getQuickActionsCommands = () =&gt; function useQuickActionsCommands() {
  const {
    clientIds,
    isUngroupable,
    isGroupable
  } = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      getSelectedBlockClientIds,
      isUngroupable: _isUngroupable,
      isGroupable: _isGroupable
    } = select(store);
    const selectedBlockClientIds = getSelectedBlockClientIds();
    return {
      clientIds: selectedBlockClientIds,
      isUngroupable: _isUngroupable(),
      isGroupable: _isGroupable()
    };
  }, []);
  const {
    canInsertBlockType,
    getBlockRootClientId,
    getBlocksByClientId,
    canRemoveBlocks
  } = (0,external_wp_data_namespaceObject.useSelect)(store);
  const {
    getDefaultBlockName,
    getGroupingBlockName
  } = (0,external_wp_data_namespaceObject.useSelect)(external_wp_blocks_namespaceObject.store);
  const blocks = getBlocksByClientId(clientIds);
  const {
    removeBlocks,
    replaceBlocks,
    duplicateBlocks,
    insertAfterBlock,
    insertBeforeBlock
  } = (0,external_wp_data_namespaceObject.useDispatch)(store);
  const onGroup = () =&gt; {
    if (!blocks.length) {
      return;
    }
    const groupingBlockName = getGroupingBlockName();

    // Activate the `transform` on `core/group` which does the conversion.
    const newBlocks = (0,external_wp_blocks_namespaceObject.switchToBlockType)(blocks, groupingBlockName);
    if (!newBlocks) {
      return;
    }
    replaceBlocks(clientIds, newBlocks);
  };
  const onUngroup = () =&gt; {
    if (!blocks.length) {
      return;
    }
    const innerBlocks = blocks[0].innerBlocks;
    if (!innerBlocks.length) {
      return;
    }
    replaceBlocks(clientIds, innerBlocks);
  };
  if (!clientIds || clientIds.length &lt; 1) {
    return {
      isLoading: false,
      commands: []
    };
  }
  const rootClientId = getBlockRootClientId(clientIds[0]);
  const canInsertDefaultBlock = canInsertBlockType(getDefaultBlockName(), rootClientId);
  const canDuplicate = blocks.every(block =&gt; {
    return !!block &amp;&amp; (0,external_wp_blocks_namespaceObject.hasBlockSupport)(block.name, &#039;multiple&#039;, true) &amp;&amp; canInsertBlockType(block.name, rootClientId);
  });
  const canRemove = canRemoveBlocks(clientIds);
  const commands = [];
  if (canDuplicate) {
    commands.push({
      name: &#039;duplicate&#039;,
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Duplicate&#039;),
      callback: () =&gt; duplicateBlocks(clientIds, true),
      icon: library_copy
    });
  }
  if (canInsertDefaultBlock) {
    commands.push({
      name: &#039;add-before&#039;,
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Add before&#039;),
      callback: () =&gt; {
        const clientId = Array.isArray(clientIds) ? clientIds[0] : clientId;
        insertBeforeBlock(clientId);
      },
      icon: library_plus
    }, {
      name: &#039;add-after&#039;,
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Add after&#039;),
      callback: () =&gt; {
        const clientId = Array.isArray(clientIds) ? clientIds[clientIds.length - 1] : clientId;
        insertAfterBlock(clientId);
      },
      icon: library_plus
    });
  }
  if (isGroupable) {
    commands.push({
      name: &#039;Group&#039;,
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Group&#039;),
      callback: onGroup,
      icon: library_group
    });
  }
  if (isUngroupable) {
    commands.push({
      name: &#039;ungroup&#039;,
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Ungroup&#039;),
      callback: onUngroup,
      icon: library_ungroup
    });
  }
  if (canRemove) {
    commands.push({
      name: &#039;remove&#039;,
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Delete&#039;),
      callback: () =&gt; removeBlocks(clientIds, true),
      icon: library_trash
    });
  }
  return {
    isLoading: false,
    commands: commands.map(command =&gt; ({
      ...command,
      name: &#039;core/block-editor/action-&#039; + command.name,
      callback: ({
        close
      }) =&gt; {
        command.callback();
        close();
      }
    }))
  };
};
const useBlockCommands = () =&gt; {
  (0,external_wp_commands_namespaceObject.useCommandLoader)({
    name: &#039;core/block-editor/blockTransforms&#039;,
    hook: getTransformCommands()
  });
  (0,external_wp_commands_namespaceObject.useCommandLoader)({
    name: &#039;core/block-editor/blockQuickActions&#039;,
    hook: getQuickActionsCommands(),
    context: &#039;block-selection-edit&#039;
  });
};

;// ./node_modules/@wordpress/block-editor/build-module/components/block-canvas/index.js
/**
 * WordPress dependencies
 */




/**
 * Internal dependencies
 */











// EditorStyles is a memoized component, so avoid passing a new
// object reference on each render.

const EDITOR_STYLE_TRANSFORM_OPTIONS = {
  // Don&#039;t transform selectors that already specify `.editor-styles-wrapper`.
  ignoredSelectors: [/\.editor-styles-wrapper/gi]
};
function ExperimentalBlockCanvas({
  shouldIframe = true,
  height = &#039;300px&#039;,
  children = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockList, {}),
  styles,
  contentRef: contentRefProp,
  iframeProps
}) {
  useBlockCommands();
  const isTabletViewport = (0,external_wp_compose_namespaceObject.useViewportMatch)(&#039;medium&#039;, &#039;&lt;&#039;);
  const resetTypingRef = useMouseMoveTypingReset();
  const clearerRef = useBlockSelectionClearer();
  const localRef = (0,external_wp_element_namespaceObject.useRef)();
  const contentRef = (0,external_wp_compose_namespaceObject.useMergeRefs)([contentRefProp, clearerRef, localRef]);
  const zoomLevel = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; unlock(select(store)).getZoomLevel(), []);
  const zoomOutIframeProps = zoomLevel !== 100 &amp;&amp; !isTabletViewport ? {
    scale: zoomLevel,
    frameSize: &#039;40px&#039;
  } : {};
  if (!shouldIframe) {
    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(BlockTools, {
      __unstableContentRef: localRef,
      className: &quot;block-editor-block-canvas&quot;,
      style: {
        height
      },
      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(editor_styles, {
        styles: styles,
        scope: &quot;:where(.editor-styles-wrapper)&quot;,
        transformOptions: EDITOR_STYLE_TRANSFORM_OPTIONS
      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(writing_flow, {
        ref: contentRef,
        className: &quot;editor-styles-wrapper&quot;,
        tabIndex: -1,
        children: children
      })]
    });
  }
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockTools, {
    __unstableContentRef: localRef,
    className: &quot;block-editor-block-canvas&quot;,
    style: {
      height,
      display: &#039;flex&#039;
    },
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(iframe, {
      ...iframeProps,
      ...zoomOutIframeProps,
      ref: resetTypingRef,
      contentRef: contentRef,
      style: {
        ...iframeProps?.style
      },
      name: &quot;editor-canvas&quot;,
      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(editor_styles, {
        styles: styles
      }), children]
    })
  });
}

/**
 * BlockCanvas component is a component used to display the canvas of the block editor.
 * What we call the canvas is an iframe containing the block list that you can manipulate.
 * The component is also responsible of wiring up all the necessary hooks to enable
 * the keyboard navigation across blocks in the editor and inject content styles into the iframe.
 *
 * @example
 *
 * ```jsx
 * function MyBlockEditor() {
 *   const [ blocks, updateBlocks ] = useState([]);
 *   return (
 *     &lt;BlockEditorProvider
 *       value={ blocks }
 *       onInput={ updateBlocks }
 *       onChange={ persistBlocks }
 *      &gt;
 *        &lt;BlockCanvas height=&quot;400px&quot; /&gt;
 *      &lt;/BlockEditorProvider&gt;
 *    );
 * }
 * ```
 *
 * @param {Object}  props          Component props.
 * @param {string}  props.height   Canvas height, defaults to 300px.
 * @param {Array}   props.styles   Content styles to inject into the iframe.
 * @param {Element} props.children Content of the canvas, defaults to the BlockList component.
 * @return {Element}               Block Breadcrumb.
 */
function BlockCanvas({
  children,
  height,
  styles
}) {
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ExperimentalBlockCanvas, {
    height: height,
    styles: styles,
    children: children
  });
}
/* harmony default export */ const block_canvas = (BlockCanvas);

;// ./node_modules/@wordpress/block-editor/build-module/components/color-style-selector/index.js
/**
 * WordPress dependencies
 */





const ColorSelectorSVGIcon = () =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 20 20&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Path, {
    d: &quot;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&quot;
  })
});

/**
 * Color Selector Icon component.
 *
 * @param {Object} props           Component properties.
 * @param {Object} props.style     Style object.
 * @param {string} props.className Class name for component.
 *
 * @return {*} React Icon component.
 */
const ColorSelectorIcon = ({
  style,
  className
}) =&gt; {
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
    className: &quot;block-library-colors-selector__icon-container&quot;,
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
      className: `${className} block-library-colors-selector__state-selection`,
      style: style,
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ColorSelectorSVGIcon, {})
    })
  });
};

/**
 * Renders the Colors Selector Toolbar with the icon button.
 *
 * @param {Object} props                 Component properties.
 * @param {Object} props.TextColor       Text color component that wraps icon.
 * @param {Object} props.BackgroundColor Background color component that wraps icon.
 *
 * @return {*} React toggle button component.
 */
const renderToggleComponent = ({
  TextColor,
  BackgroundColor
}) =&gt; ({
  onToggle,
  isOpen
}) =&gt; {
  const openOnArrowDown = event =&gt; {
    if (!isOpen &amp;&amp; event.keyCode === external_wp_keycodes_namespaceObject.DOWN) {
      event.preventDefault();
      onToggle();
    }
  };
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarGroup, {
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarButton, {
      className: &quot;components-toolbar__control block-library-colors-selector__toggle&quot;,
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Open Colors Selector&#039;),
      onClick: onToggle,
      onKeyDown: openOnArrowDown,
      icon: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BackgroundColor, {
        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(TextColor, {
          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ColorSelectorIcon, {})
        })
      })
    })
  });
};
const BlockColorsStyleSelector = ({
  children,
  ...other
}) =&gt; {
  external_wp_deprecated_default()(`wp.blockEditor.BlockColorsStyleSelector`, {
    alternative: &#039;block supports API&#039;,
    since: &#039;6.1&#039;,
    version: &#039;6.3&#039;
  });
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Dropdown, {
    popoverProps: {
      placement: &#039;bottom-start&#039;
    },
    className: &quot;block-library-colors-selector&quot;,
    contentClassName: &quot;block-library-colors-selector__popover&quot;,
    renderToggle: renderToggleComponent(other),
    renderContent: () =&gt; children
  });
};
/* harmony default export */ const color_style_selector = (BlockColorsStyleSelector);

;// ./node_modules/@wordpress/icons/build-module/library/list-view.js
/**
 * WordPress dependencies
 */


const listView = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  viewBox: &quot;0 0 24 24&quot;,
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;M3 6h11v1.5H3V6Zm3.5 5.5h11V13h-11v-1.5ZM21 17H10v1.5h11V17Z&quot;
  })
});
/* harmony default export */ const list_view = (listView);

;// ./node_modules/@wordpress/block-editor/build-module/components/list-view/context.js
/**
 * WordPress dependencies
 */

const ListViewContext = (0,external_wp_element_namespaceObject.createContext)({});
const useListViewContext = () =&gt; (0,external_wp_element_namespaceObject.useContext)(ListViewContext);

;// ./node_modules/@wordpress/block-editor/build-module/components/list-view/aria-referenced-text.js
/**
 * WordPress dependencies
 */


/**
 * A component specifically designed to be used as an element referenced
 * by ARIA attributes such as `aria-labelledby` or `aria-describedby`.
 *
 * @param {Object}                    props          Props.
 * @param {import(&#039;react&#039;).ReactNode} props.children
 */

function AriaReferencedText({
  children,
  ...props
}) {
  const ref = (0,external_wp_element_namespaceObject.useRef)();
  (0,external_wp_element_namespaceObject.useEffect)(() =&gt; {
    if (ref.current) {
      // This seems like a no-op, but it fixes a bug in Firefox where
      // it fails to recompute the text when only the text node changes.
      // @see https://github.com/WordPress/gutenberg/pull/51035
      ref.current.textContent = ref.current.textContent;
    }
  }, [children]);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
    hidden: true,
    ...props,
    ref: ref,
    children: children
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/list-view/appender.js
/**
 * WordPress dependencies
 */






/**
 * Internal dependencies
 */







const Appender = (0,external_wp_element_namespaceObject.forwardRef)(({
  nestingLevel,
  blockCount,
  clientId,
  ...props
}, ref) =&gt; {
  const {
    insertedBlock,
    setInsertedBlock
  } = useListViewContext();
  const instanceId = (0,external_wp_compose_namespaceObject.useInstanceId)(Appender);
  const hideInserter = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      getTemplateLock,
      isZoomOut
    } = unlock(select(store));
    return !!getTemplateLock(clientId) || isZoomOut();
  }, [clientId]);
  const blockTitle = useBlockDisplayTitle({
    clientId,
    context: &#039;list-view&#039;
  });
  const insertedBlockTitle = useBlockDisplayTitle({
    clientId: insertedBlock?.clientId,
    context: &#039;list-view&#039;
  });
  (0,external_wp_element_namespaceObject.useEffect)(() =&gt; {
    if (!insertedBlockTitle?.length) {
      return;
    }
    (0,external_wp_a11y_namespaceObject.speak)((0,external_wp_i18n_namespaceObject.sprintf)(
    // translators: %s: name of block being inserted (i.e. Paragraph, Image, Group etc)
    (0,external_wp_i18n_namespaceObject.__)(&#039;%s block inserted&#039;), insertedBlockTitle), &#039;assertive&#039;);
  }, [insertedBlockTitle]);
  if (hideInserter) {
    return null;
  }
  const descriptionId = `list-view-appender__${instanceId}`;
  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. */
  (0,external_wp_i18n_namespaceObject.__)(&#039;Append to %1$s block at position %2$d, Level %3$d&#039;), blockTitle, blockCount + 1, nestingLevel);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;div&quot;, {
    className: &quot;list-view-appender&quot;,
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inserter, {
      ref: ref,
      rootClientId: clientId,
      position: &quot;bottom right&quot;,
      isAppender: true,
      selectBlockOnInsert: false,
      shouldDirectInsert: false,
      __experimentalIsQuick: true,
      ...props,
      toggleProps: {
        &#039;aria-describedby&#039;: descriptionId
      },
      onSelectOrClose: maybeInsertedBlock =&gt; {
        if (maybeInsertedBlock?.clientId) {
          setInsertedBlock(maybeInsertedBlock);
        }
      }
    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(AriaReferencedText, {
      id: descriptionId,
      children: description
    })]
  });
});

;// ./node_modules/@wordpress/block-editor/build-module/components/list-view/leaf.js
/**
 * External dependencies
 */



/**
 * WordPress dependencies
 */




/**
 * Internal dependencies
 */


const AnimatedTreeGridRow = dist_esm_it(external_wp_components_namespaceObject.__experimentalTreeGridRow);
const ListViewLeaf = (0,external_wp_element_namespaceObject.forwardRef)(({
  isDragged,
  isSelected,
  position,
  level,
  rowCount,
  children,
  className,
  path,
  ...props
}, ref) =&gt; {
  const animationRef = use_moving_animation({
    clientId: props[&#039;data-block&#039;],
    enableAnimation: true,
    triggerAnimationOnChange: path
  });
  const mergedRef = (0,external_wp_compose_namespaceObject.useMergeRefs)([ref, animationRef]);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(AnimatedTreeGridRow, {
    ref: mergedRef,
    className: dist_clsx(&#039;block-editor-list-view-leaf&#039;, className),
    level: level,
    positionInSet: position,
    setSize: rowCount,
    isExpanded: undefined,
    ...props,
    children: children
  });
});
/* harmony default export */ const leaf = (ListViewLeaf);

;// ./node_modules/@wordpress/block-editor/build-module/components/list-view/use-list-view-scroll-into-view.js
/**
 * WordPress dependencies
 */


function useListViewScrollIntoView({
  isSelected,
  selectedClientIds,
  rowItemRef
}) {
  const isSingleSelection = selectedClientIds.length === 1;
  (0,external_wp_element_namespaceObject.useLayoutEffect)(() =&gt; {
    // Skip scrolling into view if this particular block isn&#039;t selected,
    // or if more than one block is selected overall. This is to avoid
    // scrolling the view in a multi selection where the user has intentionally
    // selected multiple blocks within the list view, but the initially
    // selected block may be out of view.
    if (!isSelected || !isSingleSelection || !rowItemRef.current) {
      return;
    }
    const scrollContainer = (0,external_wp_dom_namespaceObject.getScrollContainer)(rowItemRef.current);
    const {
      ownerDocument
    } = rowItemRef.current;
    const windowScroll = scrollContainer === ownerDocument.body || scrollContainer === ownerDocument.documentElement;

    // If the there is no scroll container, of if the scroll container is the window,
    // do not scroll into view, as the block is already in view.
    if (windowScroll || !scrollContainer) {
      return;
    }
    const rowRect = rowItemRef.current.getBoundingClientRect();
    const scrollContainerRect = scrollContainer.getBoundingClientRect();

    // If the selected block is not currently visible, scroll to it.
    if (rowRect.top &lt; scrollContainerRect.top || rowRect.bottom &gt; scrollContainerRect.bottom) {
      rowItemRef.current.scrollIntoView();
    }
  }, [isSelected, isSingleSelection, rowItemRef]);
}

;// ./node_modules/@wordpress/icons/build-module/library/pin-small.js
/**
 * WordPress dependencies
 */


const pinSmall = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  width: &quot;24&quot;,
  height: &quot;24&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;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&quot;
  })
});
/* harmony default export */ const pin_small = (pinSmall);

;// ./node_modules/@wordpress/icons/build-module/library/lock-small.js
/**
 * WordPress dependencies
 */


const lockSmall = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  viewBox: &quot;0 0 24 24&quot;,
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    fillRule: &quot;evenodd&quot;,
    clipRule: &quot;evenodd&quot;,
    d: &quot;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&quot;
  })
});
/* harmony default export */ const lock_small = (lockSmall);

;// ./node_modules/@wordpress/block-editor/build-module/components/list-view/expander.js
/**
 * WordPress dependencies
 */



function ListViewExpander({
  onClick
}) {
  return (
    /*#__PURE__*/
    // Keyboard events are handled by TreeGrid see: components/src/tree-grid/index.js
    //
    // The expander component is implemented as a pseudo element in the w3 example
    // https://www.w3.org/TR/wai-aria-practices/examples/treegrid/treegrid-1.html
    //
    // We&#039;ve mimicked this by adding an icon with aria-hidden set to true to hide this from the accessibility tree.
    // For the current tree grid implementation, please do not try to make this a button.
    //
    // eslint-disable-next-line jsx-a11y/click-events-have-key-events,jsx-a11y/no-static-element-interactions
    (0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;span&quot;, {
      className: &quot;block-editor-list-view__expander&quot;,
      onClick: event =&gt; onClick(event, {
        forceToggle: true
      }),
      &quot;aria-hidden&quot;: &quot;true&quot;,
      &quot;data-testid&quot;: &quot;list-view-expander&quot;,
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(build_module_icon, {
        icon: (0,external_wp_i18n_namespaceObject.isRTL)() ? chevron_left_small : chevron_right_small
      })
    })
  );
}

;// ./node_modules/@wordpress/block-editor/build-module/components/list-view/use-list-view-images.js
/**
 * WordPress dependencies
 */



/**
 * Internal dependencies
 */


// Maximum number of images to display in a list view row.
const MAX_IMAGES = 3;
function getImage(block) {
  if (block.name !== &#039;core/image&#039;) {
    return;
  }
  if (block.attributes?.url) {
    return {
      url: block.attributes.url,
      alt: block.attributes.alt,
      clientId: block.clientId
    };
  }
}
function getImagesFromGallery(block) {
  if (block.name !== &#039;core/gallery&#039; || !block.innerBlocks) {
    return [];
  }
  const images = [];
  for (const innerBlock of block.innerBlocks) {
    const img = getImage(innerBlock);
    if (img) {
      images.push(img);
    }
    if (images.length &gt;= MAX_IMAGES) {
      return images;
    }
  }
  return images;
}
function getImagesFromBlock(block, isExpanded) {
  const img = getImage(block);
  if (img) {
    return [img];
  }
  return isExpanded ? [] : getImagesFromGallery(block);
}

/**
 * Get a block&#039;s preview images for display within a list view row.
 *
 * TODO: Currently only supports images from the core/image and core/gallery
 * blocks. This should be expanded to support other blocks that have images,
 * potentially via an API that blocks can opt into / provide their own logic.
 *
 * @param {Object}  props            Hook properties.
 * @param {string}  props.clientId   The block&#039;s clientId.
 * @param {boolean} props.isExpanded Whether or not the block is expanded in the list view.
 * @return {Array} Images.
 */
function useListViewImages({
  clientId,
  isExpanded
}) {
  const {
    block
  } = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const _block = select(store).getBlock(clientId);
    return {
      block: _block
    };
  }, [clientId]);
  const images = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; {
    return getImagesFromBlock(block, isExpanded);
  }, [block, isExpanded]);
  return images;
}

;// ./node_modules/@wordpress/block-editor/build-module/components/list-view/block-select-button.js
/**
 * External dependencies
 */


/**
 * WordPress dependencies
 */






/**
 * Internal dependencies
 */









const {
  Badge: block_select_button_Badge
} = unlock(external_wp_components_namespaceObject.privateApis);
function ListViewBlockSelectButton({
  className,
  block: {
    clientId
  },
  onClick,
  onContextMenu,
  onMouseDown,
  onToggleExpanded,
  tabIndex,
  onFocus,
  onDragStart,
  onDragEnd,
  draggable,
  isExpanded,
  ariaDescribedBy
}, ref) {
  const blockInformation = useBlockDisplayInformation(clientId);
  const blockTitle = useBlockDisplayTitle({
    clientId,
    context: &#039;list-view&#039;
  });
  const {
    isLocked
  } = useBlockLock(clientId);
  const {
    isContentOnly
  } = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; ({
    isContentOnly: select(store).getBlockEditingMode(clientId) === &#039;contentOnly&#039;
  }), [clientId]);
  const shouldShowLockIcon = isLocked &amp;&amp; !isContentOnly;
  const isSticky = blockInformation?.positionType === &#039;sticky&#039;;
  const images = useListViewImages({
    clientId,
    isExpanded
  });

  // The `href` attribute triggers the browser&#039;s native HTML drag operations.
  // When the link is dragged, the element&#039;s outerHTML is set in DataTransfer object as text/html.
  // We need to clear any HTML drag data to prevent `pasteHandler` from firing
  // inside the `useOnBlockDrop` hook.
  const onDragStartHandler = event =&gt; {
    event.dataTransfer.clearData();
    onDragStart?.(event);
  };

  /**
   * @param {KeyboardEvent} event
   */
  function onKeyDown(event) {
    if (event.keyCode === external_wp_keycodes_namespaceObject.ENTER || event.keyCode === external_wp_keycodes_namespaceObject.SPACE) {
      onClick(event);
    }
  }
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;a&quot;, {
    className: dist_clsx(&#039;block-editor-list-view-block-select-button&#039;, className),
    onClick: onClick,
    onContextMenu: onContextMenu,
    onKeyDown: onKeyDown,
    onMouseDown: onMouseDown,
    ref: ref,
    tabIndex: tabIndex,
    onFocus: onFocus,
    onDragStart: onDragStartHandler,
    onDragEnd: onDragEnd,
    draggable: draggable,
    href: `#block-${clientId}`,
    &quot;aria-describedby&quot;: ariaDescribedBy,
    &quot;aria-expanded&quot;: isExpanded,
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ListViewExpander, {
      onClick: onToggleExpanded
    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_icon, {
      icon: blockInformation?.icon,
      showColors: true,
      context: &quot;list-view&quot;
    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalHStack, {
      alignment: &quot;center&quot;,
      className: &quot;block-editor-list-view-block-select-button__label-wrapper&quot;,
      justify: &quot;flex-start&quot;,
      spacing: 1,
      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;span&quot;, {
        className: &quot;block-editor-list-view-block-select-button__title&quot;,
        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalTruncate, {
          ellipsizeMode: &quot;auto&quot;,
          children: blockTitle
        })
      }), blockInformation?.anchor &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;span&quot;, {
        className: &quot;block-editor-list-view-block-select-button__anchor-wrapper&quot;,
        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_select_button_Badge, {
          className: &quot;block-editor-list-view-block-select-button__anchor&quot;,
          children: blockInformation.anchor
        })
      }), isSticky &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;span&quot;, {
        className: &quot;block-editor-list-view-block-select-button__sticky&quot;,
        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(build_module_icon, {
          icon: pin_small
        })
      }), images.length ? /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;span&quot;, {
        className: &quot;block-editor-list-view-block-select-button__images&quot;,
        &quot;aria-hidden&quot;: true,
        children: images.map((image, index) =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;span&quot;, {
          className: &quot;block-editor-list-view-block-select-button__image&quot;,
          style: {
            backgroundImage: `url(${image.url})`,
            zIndex: images.length - index // Ensure the first image is on top, and subsequent images are behind.
          }
        }, image.clientId))
      }) : null, shouldShowLockIcon &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;span&quot;, {
        className: &quot;block-editor-list-view-block-select-button__lock&quot;,
        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(build_module_icon, {
          icon: lock_small
        })
      })]
    })]
  });
}
/* harmony default export */ const block_select_button = ((0,external_wp_element_namespaceObject.forwardRef)(ListViewBlockSelectButton));

;// ./node_modules/@wordpress/block-editor/build-module/components/list-view/block-contents.js
/**
 * WordPress dependencies
 */


/**
 * Internal dependencies
 */




const ListViewBlockContents = (0,external_wp_element_namespaceObject.forwardRef)(({
  onClick,
  onToggleExpanded,
  block,
  isSelected,
  position,
  siblingBlockCount,
  level,
  isExpanded,
  selectedClientIds,
  ...props
}, ref) =&gt; {
  const {
    clientId
  } = block;
  const {
    AdditionalBlockContent,
    insertedBlock,
    setInsertedBlock
  } = useListViewContext();

  // Only include all selected blocks if the currently clicked on block
  // is one of the selected blocks. This ensures that if a user attempts
  // to drag a block that isn&#039;t part of the selection, they&#039;re still able
  // to drag it and rearrange its position.
  const draggableClientIds = selectedClientIds.includes(clientId) ? selectedClientIds : [clientId];
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
    children: [AdditionalBlockContent &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(AdditionalBlockContent, {
      block: block,
      insertedBlock: insertedBlock,
      setInsertedBlock: setInsertedBlock
    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_draggable, {
      appendToOwnerDocument: true,
      clientIds: draggableClientIds,
      cloneClassname: &quot;block-editor-list-view-draggable-chip&quot;,
      children: ({
        draggable,
        onDragStart,
        onDragEnd
      }) =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_select_button, {
        ref: ref,
        className: &quot;block-editor-list-view-block-contents&quot;,
        block: block,
        onClick: onClick,
        onToggleExpanded: onToggleExpanded,
        isSelected: isSelected,
        position: position,
        siblingBlockCount: siblingBlockCount,
        level: level,
        draggable: draggable,
        onDragStart: onDragStart,
        onDragEnd: onDragEnd,
        isExpanded: isExpanded,
        ...props
      })
    })]
  });
});
/* harmony default export */ const block_contents = (ListViewBlockContents);

;// ./node_modules/@wordpress/block-editor/build-module/components/list-view/utils.js
/**
 * WordPress dependencies
 */


const getBlockPositionDescription = (position, siblingCount, level) =&gt; (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. */
(0,external_wp_i18n_namespaceObject.__)(&#039;Block %1$d of %2$d, Level %3$d.&#039;), position, siblingCount, level);
const getBlockPropertiesDescription = (blockInformation, isLocked) =&gt; [blockInformation?.positionLabel ? `${(0,external_wp_i18n_namespaceObject.sprintf)(
// translators: %s: Position of selected block, e.g. &quot;Sticky&quot; or &quot;Fixed&quot;.
(0,external_wp_i18n_namespaceObject.__)(&#039;Position: %s&#039;), blockInformation.positionLabel)}.` : undefined, isLocked ? (0,external_wp_i18n_namespaceObject.__)(&#039;This block is locked.&#039;) : undefined].filter(Boolean).join(&#039; &#039;);

/**
 * Returns true if the client ID occurs within the block selection or multi-selection,
 * or false otherwise.
 *
 * @param {string}          clientId               Block client ID.
 * @param {string|string[]} selectedBlockClientIds Selected block client ID, or an array of multi-selected blocks client IDs.
 *
 * @return {boolean} Whether the block is in multi-selection set.
 */
const isClientIdSelected = (clientId, selectedBlockClientIds) =&gt; Array.isArray(selectedBlockClientIds) &amp;&amp; selectedBlockClientIds.length ? selectedBlockClientIds.indexOf(clientId) !== -1 : selectedBlockClientIds === clientId;

/**
 * From a start and end clientId of potentially different nesting levels,
 * return the nearest-depth ids that have a common level of depth in the
 * nesting hierarchy. For multiple block selection, this ensure that the
 * selection is always at the same nesting level, and not split across
 * separate levels.
 *
 * @param {string}   startId      The first id of a selection.
 * @param {string}   endId        The end id of a selection, usually one that has been clicked on.
 * @param {string[]} startParents An array of ancestor ids for the start id, in descending order.
 * @param {string[]} endParents   An array of ancestor ids for the end id, in descending order.
 * @return {Object} An object containing the start and end ids.
 */
function getCommonDepthClientIds(startId, endId, startParents, endParents) {
  const startPath = [...startParents, startId];
  const endPath = [...endParents, endId];
  const depth = Math.min(startPath.length, endPath.length) - 1;
  const start = startPath[depth];
  const end = endPath[depth];
  return {
    start,
    end
  };
}

/**
 * Shift focus to the list view item associated with a particular clientId.
 *
 * @typedef {import(&#039;@wordpress/element&#039;).RefObject} RefObject
 *
 * @param {string}       focusClientId   The client ID of the block to focus.
 * @param {?HTMLElement} treeGridElement The container element to search within.
 */
function focusListItem(focusClientId, treeGridElement) {
  const getFocusElement = () =&gt; {
    const row = treeGridElement?.querySelector(`[role=row][data-block=&quot;${focusClientId}&quot;]`);
    if (!row) {
      return null;
    }
    // Focus the first focusable in the row, which is the ListViewBlockSelectButton.
    return external_wp_dom_namespaceObject.focus.focusable.find(row)[0];
  };
  let focusElement = getFocusElement();
  if (focusElement) {
    focusElement.focus();
  } else {
    // The element hasn&#039;t been painted yet. Defer focusing on the next frame.
    // This could happen when all blocks have been deleted and the default block
    // hasn&#039;t been added to the editor yet.
    window.requestAnimationFrame(() =&gt; {
      focusElement = getFocusElement();

      // Ignore if the element still doesn&#039;t exist.
      if (focusElement) {
        focusElement.focus();
      }
    });
  }
}

/**
 * Get values for the block that flag whether the block should be displaced up or down,
 * whether the block is being nested, and whether the block appears after the dragged
 * blocks. These values are used to determine the class names to apply to the block.
 * The list view rows are displaced visually via CSS rules. Displacement rules:
 * - `normal`: no displacement — used to apply a translateY of `0` so that the block
 *  appears in its original position, and moves to that position smoothly when dragging
 *  outside of the list view area.
 * - `up`: the block should be displaced up, creating room beneath the block for the drop indicator.
 * - `down`: the block should be displaced down, creating room above the block for the drop indicator.
 *
 * @param {Object}                props
 * @param {Object}                props.blockIndexes           The indexes of all the blocks in the list view, keyed by clientId.
 * @param {number|null|undefined} props.blockDropTargetIndex   The index of the block that the user is dropping to.
 * @param {?string}               props.blockDropPosition      The position relative to the block that the user is dropping to.
 * @param {string}                props.clientId               The client id for the current block.
 * @param {?number}               props.firstDraggedBlockIndex The index of the first dragged block.
 * @param {?boolean}              props.isDragged              Whether the current block is being dragged. Dragged blocks skip displacement.
 * @return {Object} An object containing the `displacement`, `isAfterDraggedBlocks` and `isNesting` values.
 */
function getDragDisplacementValues({
  blockIndexes,
  blockDropTargetIndex,
  blockDropPosition,
  clientId,
  firstDraggedBlockIndex,
  isDragged
}) {
  let displacement;
  let isNesting;
  let isAfterDraggedBlocks;
  if (!isDragged) {
    isNesting = false;
    const thisBlockIndex = blockIndexes[clientId];
    isAfterDraggedBlocks = thisBlockIndex &gt; firstDraggedBlockIndex;

    // Determine where to displace the position of the current block, relative
    // to the blocks being dragged (in their original position) and the drop target
    // (the position where a user is currently dragging the blocks to).
    if (blockDropTargetIndex !== undefined &amp;&amp; blockDropTargetIndex !== null &amp;&amp; firstDraggedBlockIndex !== undefined) {
      // If the block is being dragged and there is a valid drop target,
      // determine if the block being rendered should be displaced up or down.

      if (thisBlockIndex !== undefined) {
        if (thisBlockIndex &gt;= firstDraggedBlockIndex &amp;&amp; thisBlockIndex &lt; blockDropTargetIndex) {
          // If the current block appears after the set of dragged blocks
          // (in their original position), but is before the drop target,
          // then the current block should be displaced up.
          displacement = &#039;up&#039;;
        } else if (thisBlockIndex &lt; firstDraggedBlockIndex &amp;&amp; thisBlockIndex &gt;= blockDropTargetIndex) {
          // If the current block appears before the set of dragged blocks
          // (in their original position), but is after the drop target,
          // then the current block should be displaced down.
          displacement = &#039;down&#039;;
        } else {
          displacement = &#039;normal&#039;;
        }
        isNesting = typeof blockDropTargetIndex === &#039;number&#039; &amp;&amp; blockDropTargetIndex - 1 === thisBlockIndex &amp;&amp; blockDropPosition === &#039;inside&#039;;
      }
    } else if (blockDropTargetIndex === null &amp;&amp; firstDraggedBlockIndex !== undefined) {
      // A `null` value for `blockDropTargetIndex` indicates that the
      // drop target is outside of the valid areas within the list view.
      // In this case, the drag is still active, but as there is no
      // valid drop target, we should remove the gap indicating where
      // the block would be inserted.
      if (thisBlockIndex !== undefined &amp;&amp; thisBlockIndex &gt;= firstDraggedBlockIndex) {
        displacement = &#039;up&#039;;
      } else {
        displacement = &#039;normal&#039;;
      }
    } else if (blockDropTargetIndex !== undefined &amp;&amp; blockDropTargetIndex !== null &amp;&amp; firstDraggedBlockIndex === undefined) {
      // If the blockdrop target is defined, but there are no dragged blocks,
      // then the block should be displaced relative to the drop target.
      if (thisBlockIndex !== undefined) {
        if (thisBlockIndex &lt; blockDropTargetIndex) {
          displacement = &#039;normal&#039;;
        } else {
          displacement = &#039;down&#039;;
        }
      }
    } else if (blockDropTargetIndex === null) {
      displacement = &#039;normal&#039;;
    }
  }
  return {
    displacement,
    isNesting,
    isAfterDraggedBlocks
  };
}

;// ./node_modules/@wordpress/block-editor/build-module/components/list-view/block.js
/**
 * External dependencies
 */


/**
 * WordPress dependencies
 */












/**
 * Internal dependencies
 */












function ListViewBlock({
  block: {
    clientId
  },
  displacement,
  isAfterDraggedBlocks,
  isDragged,
  isNesting,
  isSelected,
  isBranchSelected,
  selectBlock,
  position,
  level,
  rowCount,
  siblingBlockCount,
  showBlockMovers,
  path,
  isExpanded,
  selectedClientIds,
  isSyncedBranch
}) {
  const cellRef = (0,external_wp_element_namespaceObject.useRef)(null);
  const rowRef = (0,external_wp_element_namespaceObject.useRef)(null);
  const settingsRef = (0,external_wp_element_namespaceObject.useRef)(null);
  const [isHovered, setIsHovered] = (0,external_wp_element_namespaceObject.useState)(false);
  const [settingsAnchorRect, setSettingsAnchorRect] = (0,external_wp_element_namespaceObject.useState)();
  const {
    isLocked,
    canEdit,
    canMove
  } = useBlockLock(clientId);
  const isFirstSelectedBlock = isSelected &amp;&amp; selectedClientIds[0] === clientId;
  const isLastSelectedBlock = isSelected &amp;&amp; selectedClientIds[selectedClientIds.length - 1] === clientId;
  const {
    toggleBlockHighlight,
    duplicateBlocks,
    multiSelect,
    replaceBlocks,
    removeBlocks,
    insertAfterBlock,
    insertBeforeBlock,
    setOpenedBlockSettingsMenu
  } = unlock((0,external_wp_data_namespaceObject.useDispatch)(store));
  const {
    canInsertBlockType,
    getSelectedBlockClientIds,
    getPreviousBlockClientId,
    getBlockRootClientId,
    getBlockOrder,
    getBlockParents,
    getBlocksByClientId,
    canRemoveBlocks,
    isGroupable
  } = (0,external_wp_data_namespaceObject.useSelect)(store);
  const {
    getGroupingBlockName
  } = (0,external_wp_data_namespaceObject.useSelect)(external_wp_blocks_namespaceObject.store);
  const blockInformation = useBlockDisplayInformation(clientId);
  const {
    block,
    blockName,
    allowRightClickOverrides
  } = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      getBlock,
      getBlockName,
      getSettings
    } = select(store);
    return {
      block: getBlock(clientId),
      blockName: getBlockName(clientId),
      allowRightClickOverrides: getSettings().allowRightClickOverrides
    };
  }, [clientId]);
  const showBlockActions =
  // When a block hides its toolbar it also hides the block settings menu,
  // since that menu is part of the toolbar in the editor canvas.
  // List View respects this by also hiding the block settings menu.
  (0,external_wp_blocks_namespaceObject.hasBlockSupport)(blockName, &#039;__experimentalToolbar&#039;, true);
  const instanceId = (0,external_wp_compose_namespaceObject.useInstanceId)(ListViewBlock);
  const descriptionId = `list-view-block-select-button__description-${instanceId}`;
  const {
    expand,
    collapse,
    collapseAll,
    BlockSettingsMenu,
    listViewInstanceId,
    expandedState,
    setInsertedBlock,
    treeGridElementRef,
    rootClientId
  } = useListViewContext();
  const isMatch = (0,external_wp_keyboardShortcuts_namespaceObject.__unstableUseShortcutEventMatch)();

  // Determine which blocks to update:
  // If the current (focused) block is part of the block selection, use the whole selection.
  // If the focused block is not part of the block selection, only update the focused block.
  function getBlocksToUpdate() {
    const selectedBlockClientIds = getSelectedBlockClientIds();
    const isUpdatingSelectedBlocks = selectedBlockClientIds.includes(clientId);
    const firstBlockClientId = isUpdatingSelectedBlocks ? selectedBlockClientIds[0] : clientId;
    const firstBlockRootClientId = getBlockRootClientId(firstBlockClientId);
    const blocksToUpdate = isUpdatingSelectedBlocks ? selectedBlockClientIds : [clientId];
    return {
      blocksToUpdate,
      firstBlockClientId,
      firstBlockRootClientId,
      selectedBlockClientIds
    };
  }

  /**
   * @param {KeyboardEvent} event
   */
  async function onKeyDown(event) {
    if (event.defaultPrevented) {
      return;
    }

    // Do not handle events if it comes from modals;
    // retain the default behavior for these keys.
    if (event.target.closest(&#039;[role=dialog]&#039;)) {
      return;
    }
    const isDeleteKey = [external_wp_keycodes_namespaceObject.BACKSPACE, external_wp_keycodes_namespaceObject.DELETE].includes(event.keyCode);

    // If multiple blocks are selected, deselect all blocks when the user
    // presses the escape key.
    if (isMatch(&#039;core/block-editor/unselect&#039;, event) &amp;&amp; selectedClientIds.length &gt; 0) {
      event.stopPropagation();
      event.preventDefault();
      selectBlock(event, undefined);
    } else if (isDeleteKey || isMatch(&#039;core/block-editor/remove&#039;, event)) {
      var _getPreviousBlockClie;
      const {
        blocksToUpdate: blocksToDelete,
        firstBlockClientId,
        firstBlockRootClientId,
        selectedBlockClientIds
      } = getBlocksToUpdate();

      // Don&#039;t update the selection if the blocks cannot be deleted.
      if (!canRemoveBlocks(blocksToDelete)) {
        return;
      }
      let blockToFocus = (_getPreviousBlockClie = getPreviousBlockClientId(firstBlockClientId)) !== null &amp;&amp; _getPreviousBlockClie !== void 0 ? _getPreviousBlockClie :
      // If the previous block is not found (when the first block is deleted),
      // fallback to focus the parent block.
      firstBlockRootClientId;
      removeBlocks(blocksToDelete, false);

      // Update the selection if the original selection has been removed.
      const shouldUpdateSelection = selectedBlockClientIds.length &gt; 0 &amp;&amp; getSelectedBlockClientIds().length === 0;

      // If there&#039;s no previous block nor parent block, focus the first block.
      if (!blockToFocus) {
        blockToFocus = getBlockOrder()[0];
      }
      updateFocusAndSelection(blockToFocus, shouldUpdateSelection);
    } else if (isMatch(&#039;core/block-editor/duplicate&#039;, event)) {
      event.preventDefault();
      const {
        blocksToUpdate,
        firstBlockRootClientId
      } = getBlocksToUpdate();
      const canDuplicate = getBlocksByClientId(blocksToUpdate).every(blockToUpdate =&gt; {
        return !!blockToUpdate &amp;&amp; (0,external_wp_blocks_namespaceObject.hasBlockSupport)(blockToUpdate.name, &#039;multiple&#039;, true) &amp;&amp; canInsertBlockType(blockToUpdate.name, firstBlockRootClientId);
      });
      if (canDuplicate) {
        const updatedBlocks = await duplicateBlocks(blocksToUpdate, false);
        if (updatedBlocks?.length) {
          // If blocks have been duplicated, focus the first duplicated block.
          updateFocusAndSelection(updatedBlocks[0], false);
        }
      }
    } else if (isMatch(&#039;core/block-editor/insert-before&#039;, event)) {
      event.preventDefault();
      const {
        blocksToUpdate
      } = getBlocksToUpdate();
      await insertBeforeBlock(blocksToUpdate[0]);
      const newlySelectedBlocks = getSelectedBlockClientIds();

      // Focus the first block of the newly inserted blocks, to keep focus within the list view.
      setOpenedBlockSettingsMenu(undefined);
      updateFocusAndSelection(newlySelectedBlocks[0], false);
    } else if (isMatch(&#039;core/block-editor/insert-after&#039;, event)) {
      event.preventDefault();
      const {
        blocksToUpdate
      } = getBlocksToUpdate();
      await insertAfterBlock(blocksToUpdate.at(-1));
      const newlySelectedBlocks = getSelectedBlockClientIds();

      // Focus the first block of the newly inserted blocks, to keep focus within the list view.
      setOpenedBlockSettingsMenu(undefined);
      updateFocusAndSelection(newlySelectedBlocks[0], false);
    } else if (isMatch(&#039;core/block-editor/select-all&#039;, event)) {
      event.preventDefault();
      const {
        firstBlockRootClientId,
        selectedBlockClientIds
      } = getBlocksToUpdate();
      const blockClientIds = getBlockOrder(firstBlockRootClientId);
      if (!blockClientIds.length) {
        return;
      }

      // If we have selected all sibling nested blocks, try selecting up a level.
      // This is a similar implementation to that used by `useSelectAll`.
      // `isShallowEqual` is used for the list view instead of a length check,
      // as the array of siblings of the currently focused block may be a different
      // set of blocks from the current block selection if the user is focused
      // on a different part of the list view from the block selection.
      if (external_wp_isShallowEqual_default()(selectedBlockClientIds, blockClientIds)) {
        // Only select up a level if the first block is not the root block.
        // This ensures that the block selection can&#039;t break out of the root block
        // used by the list view, if the list view is only showing a partial hierarchy.
        if (firstBlockRootClientId &amp;&amp; firstBlockRootClientId !== rootClientId) {
          updateFocusAndSelection(firstBlockRootClientId, true);
          return;
        }
      }

      // Select all while passing `null` to skip focusing to the editor canvas,
      // and retain focus within the list view.
      multiSelect(blockClientIds[0], blockClientIds[blockClientIds.length - 1], null);
    } else if (isMatch(&#039;core/block-editor/collapse-list-view&#039;, event)) {
      event.preventDefault();
      const {
        firstBlockClientId
      } = getBlocksToUpdate();
      const blockParents = getBlockParents(firstBlockClientId, false);
      // Collapse all blocks.
      collapseAll();
      // Expand all parents of the current block.
      expand(blockParents);
    } else if (isMatch(&#039;core/block-editor/group&#039;, event)) {
      const {
        blocksToUpdate
      } = getBlocksToUpdate();
      if (blocksToUpdate.length &gt; 1 &amp;&amp; isGroupable(blocksToUpdate)) {
        event.preventDefault();
        const blocks = getBlocksByClientId(blocksToUpdate);
        const groupingBlockName = getGroupingBlockName();
        const newBlocks = (0,external_wp_blocks_namespaceObject.switchToBlockType)(blocks, groupingBlockName);
        replaceBlocks(blocksToUpdate, newBlocks);
        (0,external_wp_a11y_namespaceObject.speak)((0,external_wp_i18n_namespaceObject.__)(&#039;Selected blocks are grouped.&#039;));
        const newlySelectedBlocks = getSelectedBlockClientIds();
        // Focus the first block of the newly inserted blocks, to keep focus within the list view.
        setOpenedBlockSettingsMenu(undefined);
        updateFocusAndSelection(newlySelectedBlocks[0], false);
      }
    }
  }
  const onMouseEnter = (0,external_wp_element_namespaceObject.useCallback)(() =&gt; {
    setIsHovered(true);
    toggleBlockHighlight(clientId, true);
  }, [clientId, setIsHovered, toggleBlockHighlight]);
  const onMouseLeave = (0,external_wp_element_namespaceObject.useCallback)(() =&gt; {
    setIsHovered(false);
    toggleBlockHighlight(clientId, false);
  }, [clientId, setIsHovered, toggleBlockHighlight]);
  const selectEditorBlock = (0,external_wp_element_namespaceObject.useCallback)(event =&gt; {
    selectBlock(event, clientId);
    event.preventDefault();
  }, [clientId, selectBlock]);
  const updateFocusAndSelection = (0,external_wp_element_namespaceObject.useCallback)((focusClientId, shouldSelectBlock) =&gt; {
    if (shouldSelectBlock) {
      selectBlock(undefined, focusClientId, null, null);
    }
    focusListItem(focusClientId, treeGridElementRef?.current);
  }, [selectBlock, treeGridElementRef]);
  const toggleExpanded = (0,external_wp_element_namespaceObject.useCallback)(event =&gt; {
    // Prevent shift+click from opening link in a new window when toggling.
    event.preventDefault();
    event.stopPropagation();
    if (isExpanded === true) {
      collapse(clientId);
    } else if (isExpanded === false) {
      expand(clientId);
    }
  }, [clientId, expand, collapse, isExpanded]);

  // Allow right-clicking an item in the List View to open up the block settings dropdown.
  const onContextMenu = (0,external_wp_element_namespaceObject.useCallback)(event =&gt; {
    if (showBlockActions &amp;&amp; allowRightClickOverrides) {
      settingsRef.current?.click();
      // Ensure the position of the settings dropdown is at the cursor.
      setSettingsAnchorRect(new window.DOMRect(event.clientX, event.clientY, 0, 0));
      event.preventDefault();
    }
  }, [allowRightClickOverrides, settingsRef, showBlockActions]);
  const onMouseDown = (0,external_wp_element_namespaceObject.useCallback)(event =&gt; {
    // Prevent right-click from focusing the block,
    // because focus will be handled when opening the block settings dropdown.
    if (allowRightClickOverrides &amp;&amp; event.button === 2) {
      event.preventDefault();
    }
  }, [allowRightClickOverrides]);
  const settingsPopoverAnchor = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; {
    const {
      ownerDocument
    } = rowRef?.current || {};

    // If no custom position is set, the settings dropdown will be anchored to the
    // DropdownMenu toggle button.
    if (!settingsAnchorRect || !ownerDocument) {
      return undefined;
    }

    // Position the settings dropdown at the cursor when right-clicking a block.
    return {
      ownerDocument,
      getBoundingClientRect() {
        return settingsAnchorRect;
      }
    };
  }, [settingsAnchorRect]);
  const clearSettingsAnchorRect = (0,external_wp_element_namespaceObject.useCallback)(() =&gt; {
    // Clear the custom position for the settings dropdown so that it is restored back
    // to being anchored to the DropdownMenu toggle button.
    setSettingsAnchorRect(undefined);
  }, [setSettingsAnchorRect]);

  // Pass in a ref to the row, so that it can be scrolled
  // into view when selected. For long lists, the placeholder for the
  // selected block is also observed, within ListViewLeafPlaceholder.
  useListViewScrollIntoView({
    isSelected,
    rowItemRef: rowRef,
    selectedClientIds
  });

  // When switching between rendering modes (such as template preview and content only),
  // it is possible for a block to temporarily be unavailable. In this case, we should not
  // render the leaf, to avoid errors further down the tree.
  if (!block) {
    return null;
  }
  const blockPositionDescription = getBlockPositionDescription(position, siblingBlockCount, level);
  const blockPropertiesDescription = getBlockPropertiesDescription(blockInformation, isLocked);
  const hasSiblings = siblingBlockCount &gt; 0;
  const hasRenderedMovers = showBlockMovers &amp;&amp; hasSiblings;
  const moverCellClassName = dist_clsx(&#039;block-editor-list-view-block__mover-cell&#039;, {
    &#039;is-visible&#039;: isHovered || isSelected
  });
  const listViewBlockSettingsClassName = dist_clsx(&#039;block-editor-list-view-block__menu-cell&#039;, {
    &#039;is-visible&#039;: isHovered || isFirstSelectedBlock
  });
  let colSpan;
  if (hasRenderedMovers) {
    colSpan = 2;
  } else if (!showBlockActions) {
    colSpan = 3;
  }
  const classes = dist_clsx({
    &#039;is-selected&#039;: isSelected,
    &#039;is-first-selected&#039;: isFirstSelectedBlock,
    &#039;is-last-selected&#039;: isLastSelectedBlock,
    &#039;is-branch-selected&#039;: isBranchSelected,
    &#039;is-synced-branch&#039;: isSyncedBranch,
    &#039;is-dragging&#039;: isDragged,
    &#039;has-single-cell&#039;: !showBlockActions,
    &#039;is-synced&#039;: blockInformation?.isSynced,
    &#039;is-draggable&#039;: canMove,
    &#039;is-displacement-normal&#039;: displacement === &#039;normal&#039;,
    &#039;is-displacement-up&#039;: displacement === &#039;up&#039;,
    &#039;is-displacement-down&#039;: displacement === &#039;down&#039;,
    &#039;is-after-dragged-blocks&#039;: isAfterDraggedBlocks,
    &#039;is-nesting&#039;: isNesting
  });

  // Only include all selected blocks if the currently clicked on block
  // is one of the selected blocks. This ensures that if a user attempts
  // to alter a block that isn&#039;t part of the selection, they&#039;re still able
  // to do so.
  const dropdownClientIds = selectedClientIds.includes(clientId) ? selectedClientIds : [clientId];

  // Detect if there is a block in the canvas currently being edited and multi-selection is not happening.
  const currentlyEditingBlockInCanvas = isSelected &amp;&amp; selectedClientIds.length === 1;
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(leaf, {
    className: classes,
    isDragged: isDragged,
    onKeyDown: onKeyDown,
    onMouseEnter: onMouseEnter,
    onMouseLeave: onMouseLeave,
    onFocus: onMouseEnter,
    onBlur: onMouseLeave,
    level: level,
    position: position,
    rowCount: rowCount,
    path: path,
    id: `list-view-${listViewInstanceId}-block-${clientId}`,
    &quot;data-block&quot;: clientId,
    &quot;data-expanded&quot;: canEdit ? isExpanded : undefined,
    ref: rowRef,
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalTreeGridCell, {
      className: &quot;block-editor-list-view-block__contents-cell&quot;,
      colSpan: colSpan,
      ref: cellRef,
      &quot;aria-selected&quot;: !!isSelected,
      children: ({
        ref,
        tabIndex,
        onFocus
      }) =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;div&quot;, {
        className: &quot;block-editor-list-view-block__contents-container&quot;,
        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_contents, {
          block: block,
          onClick: selectEditorBlock,
          onContextMenu: onContextMenu,
          onMouseDown: onMouseDown,
          onToggleExpanded: toggleExpanded,
          isSelected: isSelected,
          position: position,
          siblingBlockCount: siblingBlockCount,
          level: level,
          ref: ref,
          tabIndex: currentlyEditingBlockInCanvas ? 0 : tabIndex,
          onFocus: onFocus,
          isExpanded: canEdit ? isExpanded : undefined,
          selectedClientIds: selectedClientIds,
          ariaDescribedBy: descriptionId
        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(AriaReferencedText, {
          id: descriptionId,
          children: [blockPositionDescription, blockPropertiesDescription].filter(Boolean).join(&#039; &#039;)
        })]
      })
    }), hasRenderedMovers &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_ReactJSXRuntime_namespaceObject.Fragment, {
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalTreeGridCell, {
        className: moverCellClassName,
        withoutGridItem: true,
        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalTreeGridItem, {
          children: ({
            ref,
            tabIndex,
            onFocus
          }) =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockMoverUpButton, {
            orientation: &quot;vertical&quot;,
            clientIds: [clientId],
            ref: ref,
            tabIndex: tabIndex,
            onFocus: onFocus
          })
        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalTreeGridItem, {
          children: ({
            ref,
            tabIndex,
            onFocus
          }) =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockMoverDownButton, {
            orientation: &quot;vertical&quot;,
            clientIds: [clientId],
            ref: ref,
            tabIndex: tabIndex,
            onFocus: onFocus
          })
        })]
      })
    }), showBlockActions &amp;&amp; BlockSettingsMenu &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalTreeGridCell, {
      className: listViewBlockSettingsClassName,
      &quot;aria-selected&quot;: !!isSelected,
      ref: settingsRef,
      children: ({
        ref,
        tabIndex,
        onFocus
      }) =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockSettingsMenu, {
        clientIds: dropdownClientIds,
        block: block,
        icon: more_vertical,
        label: (0,external_wp_i18n_namespaceObject.__)(&#039;Options&#039;),
        popoverProps: {
          anchor: settingsPopoverAnchor // Used to position the settings at the cursor on right-click.
        },
        toggleProps: {
          ref,
          className: &#039;block-editor-list-view-block__menu&#039;,
          tabIndex,
          onClick: clearSettingsAnchorRect,
          onFocus
        },
        disableOpenOnArrowDown: true,
        expand: expand,
        expandedState: expandedState,
        setInsertedBlock: setInsertedBlock,
        __experimentalSelectBlock: updateFocusAndSelection
      })
    })]
  });
}
/* harmony default export */ const list_view_block = ((0,external_wp_element_namespaceObject.memo)(ListViewBlock));

;// ./node_modules/@wordpress/block-editor/build-module/components/list-view/branch.js
/**
 * WordPress dependencies
 */




/**
 * Internal dependencies
 */







/**
 * Given a block, returns the total number of blocks in that subtree. This is used to help determine
 * the list position of a block.
 *
 * When a block is collapsed, we do not count their children as part of that total. In the current drag
 * implementation dragged blocks and their children are not counted.
 *
 * @param {Object}  block               block tree
 * @param {Object}  expandedState       state that notes which branches are collapsed
 * @param {Array}   draggedClientIds    a list of dragged client ids
 * @param {boolean} isExpandedByDefault flag to determine the default fallback expanded state.
 * @return {number} block count
 */

function countBlocks(block, expandedState, draggedClientIds, isExpandedByDefault) {
  var _expandedState$block$;
  const isDragged = draggedClientIds?.includes(block.clientId);
  if (isDragged) {
    return 0;
  }
  const isExpanded = (_expandedState$block$ = expandedState[block.clientId]) !== null &amp;&amp; _expandedState$block$ !== void 0 ? _expandedState$block$ : isExpandedByDefault;
  if (isExpanded) {
    return 1 + block.innerBlocks.reduce(countReducer(expandedState, draggedClientIds, isExpandedByDefault), 0);
  }
  return 1;
}
const countReducer = (expandedState, draggedClientIds, isExpandedByDefault) =&gt; (count, block) =&gt; {
  var _expandedState$block$2;
  const isDragged = draggedClientIds?.includes(block.clientId);
  if (isDragged) {
    return count;
  }
  const isExpanded = (_expandedState$block$2 = expandedState[block.clientId]) !== null &amp;&amp; _expandedState$block$2 !== void 0 ? _expandedState$block$2 : isExpandedByDefault;
  if (isExpanded &amp;&amp; block.innerBlocks.length &gt; 0) {
    return count + countBlocks(block, expandedState, draggedClientIds, isExpandedByDefault);
  }
  return count + 1;
};
const branch_noop = () =&gt; {};
function ListViewBranch(props) {
  const {
    blocks,
    selectBlock = branch_noop,
    showBlockMovers,
    selectedClientIds,
    level = 1,
    path = &#039;&#039;,
    isBranchSelected = false,
    listPosition = 0,
    fixedListWindow,
    isExpanded,
    parentId,
    shouldShowInnerBlocks = true,
    isSyncedBranch = false,
    showAppender: showAppenderProp = true
  } = props;
  const parentBlockInformation = useBlockDisplayInformation(parentId);
  const syncedBranch = isSyncedBranch || !!parentBlockInformation?.isSynced;
  const canParentExpand = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    if (!parentId) {
      return true;
    }
    return select(store).canEditBlock(parentId);
  }, [parentId]);
  const {
    blockDropPosition,
    blockDropTargetIndex,
    firstDraggedBlockIndex,
    blockIndexes,
    expandedState,
    draggedClientIds
  } = useListViewContext();
  const nextPositionRef = (0,external_wp_element_namespaceObject.useRef)();
  if (!canParentExpand) {
    return null;
  }

  // Only show the appender at the first level.
  const showAppender = showAppenderProp &amp;&amp; level === 1;
  const filteredBlocks = blocks.filter(Boolean);
  const blockCount = filteredBlocks.length;
  // The appender means an extra row in List View, so add 1 to the row count.
  const rowCount = showAppender ? blockCount + 1 : blockCount;
  nextPositionRef.current = listPosition;
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
    children: [filteredBlocks.map((block, index) =&gt; {
      var _expandedState$client;
      const {
        clientId,
        innerBlocks
      } = block;
      if (index &gt; 0) {
        nextPositionRef.current += countBlocks(filteredBlocks[index - 1], expandedState, draggedClientIds, isExpanded);
      }
      const isDragged = !!draggedClientIds?.includes(clientId);

      // Determine the displacement of the block while dragging. This
      // works out whether the current block should be displaced up or
      // down, relative to the dragged blocks and the drop target.
      const {
        displacement,
        isAfterDraggedBlocks,
        isNesting
      } = getDragDisplacementValues({
        blockIndexes,
        blockDropTargetIndex,
        blockDropPosition,
        clientId,
        firstDraggedBlockIndex,
        isDragged
      });
      const {
        itemInView
      } = fixedListWindow;
      const blockInView = itemInView(nextPositionRef.current);
      const position = index + 1;
      const updatedPath = path.length &gt; 0 ? `${path}_${position}` : `${position}`;
      const hasNestedBlocks = !!innerBlocks?.length;
      const shouldExpand = hasNestedBlocks &amp;&amp; shouldShowInnerBlocks ? (_expandedState$client = expandedState[clientId]) !== null &amp;&amp; _expandedState$client !== void 0 ? _expandedState$client : isExpanded : undefined;

      // Make updates to the selected or dragged blocks synchronous,
      // but asynchronous for any other block.
      const isSelected = isClientIdSelected(clientId, selectedClientIds);
      const isSelectedBranch = isBranchSelected || isSelected &amp;&amp; hasNestedBlocks;

      // To avoid performance issues, we only render blocks that are in view,
      // or blocks that are selected or dragged. If a block is selected,
      // it is only counted if it is the first of the block selection.
      // This prevents the entire tree from being rendered when a branch is
      // selected, or a user selects all blocks, while still enabling scroll
      // into view behavior when selecting a block or opening the list view.
      // The first and last blocks of the list are always rendered, to ensure
      // that Home and End keys work as expected.
      const showBlock = isDragged || blockInView || isSelected &amp;&amp; clientId === selectedClientIds[0] || index === 0 || index === blockCount - 1;
      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_data_namespaceObject.AsyncModeProvider, {
        value: !isSelected,
        children: [showBlock &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(list_view_block, {
          block: block,
          selectBlock: selectBlock,
          isSelected: isSelected,
          isBranchSelected: isSelectedBranch,
          isDragged: isDragged,
          level: level,
          position: position,
          rowCount: rowCount,
          siblingBlockCount: blockCount,
          showBlockMovers: showBlockMovers,
          path: updatedPath,
          isExpanded: isDragged ? false : shouldExpand,
          listPosition: nextPositionRef.current,
          selectedClientIds: selectedClientIds,
          isSyncedBranch: syncedBranch,
          displacement: displacement,
          isAfterDraggedBlocks: isAfterDraggedBlocks,
          isNesting: isNesting
        }), !showBlock &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;tr&quot;, {
          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;td&quot;, {
            className: &quot;block-editor-list-view-placeholder&quot;
          })
        }), hasNestedBlocks &amp;&amp; shouldExpand &amp;&amp; !isDragged &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ListViewBranch, {
          parentId: clientId,
          blocks: innerBlocks,
          selectBlock: selectBlock,
          showBlockMovers: showBlockMovers,
          level: level + 1,
          path: updatedPath,
          listPosition: nextPositionRef.current + 1,
          fixedListWindow: fixedListWindow,
          isBranchSelected: isSelectedBranch,
          selectedClientIds: selectedClientIds,
          isExpanded: isExpanded,
          isSyncedBranch: syncedBranch
        })]
      }, clientId);
    }), showAppender &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalTreeGridRow, {
      level: level,
      setSize: rowCount,
      positionInSet: rowCount,
      isExpanded: true,
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalTreeGridCell, {
        children: treeGridCellProps =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Appender, {
          clientId: parentId,
          nestingLevel: level,
          blockCount: blockCount,
          ...treeGridCellProps
        })
      })
    })]
  });
}
/* harmony default export */ const branch = ((0,external_wp_element_namespaceObject.memo)(ListViewBranch));

;// ./node_modules/@wordpress/block-editor/build-module/components/list-view/drop-indicator.js
/**
 * External dependencies
 */


/**
 * WordPress dependencies
 */





/**
 * Internal dependencies
 */





function ListViewDropIndicatorPreview({
  draggedBlockClientId,
  listViewRef,
  blockDropTarget
}) {
  const blockInformation = useBlockDisplayInformation(draggedBlockClientId);
  const blockTitle = useBlockDisplayTitle({
    clientId: draggedBlockClientId,
    context: &#039;list-view&#039;
  });
  const {
    rootClientId,
    clientId,
    dropPosition
  } = blockDropTarget || {};
  const [rootBlockElement, blockElement] = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; {
    if (!listViewRef.current) {
      return [];
    }

    // The rootClientId will be defined whenever dropping into inner
    // block lists, but is undefined when dropping at the root level.
    const _rootBlockElement = rootClientId ? listViewRef.current.querySelector(`[data-block=&quot;${rootClientId}&quot;]`) : undefined;

    // The clientId represents the sibling block, the dragged block will
    // usually be inserted adjacent to it. It will be undefined when
    // dropping a block into an empty block list.
    const _blockElement = clientId ? listViewRef.current.querySelector(`[data-block=&quot;${clientId}&quot;]`) : undefined;
    return [_rootBlockElement, _blockElement];
  }, [listViewRef, rootClientId, clientId]);

  // The targetElement is the element that the drop indicator will appear
  // before or after. When dropping into an empty block list, blockElement
  // is undefined, so the indicator will appear after the rootBlockElement.
  const targetElement = blockElement || rootBlockElement;
  const rtl = (0,external_wp_i18n_namespaceObject.isRTL)();
  const getDropIndicatorWidth = (0,external_wp_element_namespaceObject.useCallback)((targetElementRect, indent) =&gt; {
    if (!targetElement) {
      return 0;
    }

    // Default to assuming that the width of the drop indicator
    // should be the same as the target element.
    let width = targetElement.offsetWidth;

    // In deeply nested lists, where a scrollbar is present,
    // the width of the drop indicator should be the width of
    // the scroll container, minus the distance from the left
    // edge of the scroll container to the left edge of the
    // target element.
    const scrollContainer = (0,external_wp_dom_namespaceObject.getScrollContainer)(targetElement, &#039;horizontal&#039;);
    const ownerDocument = targetElement.ownerDocument;
    const windowScroll = scrollContainer === ownerDocument.body || scrollContainer === ownerDocument.documentElement;
    if (scrollContainer &amp;&amp; !windowScroll) {
      const scrollContainerRect = scrollContainer.getBoundingClientRect();
      const distanceBetweenContainerAndTarget = (0,external_wp_i18n_namespaceObject.isRTL)() ? scrollContainerRect.right - targetElementRect.right : targetElementRect.left - scrollContainerRect.left;
      const scrollContainerWidth = scrollContainer.clientWidth;
      if (scrollContainerWidth &lt; width + distanceBetweenContainerAndTarget) {
        width = scrollContainerWidth - distanceBetweenContainerAndTarget;
      }

      // LTR logic for ensuring the drop indicator does not extend
      // beyond the right edge of the scroll container.
      if (!rtl &amp;&amp; targetElementRect.left + indent &lt; scrollContainerRect.left) {
        width -= scrollContainerRect.left - targetElementRect.left;
        return width;
      }

      // RTL logic for ensuring the drop indicator does not extend
      // beyond the right edge of the scroll container.
      if (rtl &amp;&amp; targetElementRect.right - indent &gt; scrollContainerRect.right) {
        width -= targetElementRect.right - scrollContainerRect.right;
        return width;
      }
    }

    // Subtract the indent from the final width of the indicator.
    return width - indent;
  }, [rtl, targetElement]);
  const style = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; {
    if (!targetElement) {
      return {};
    }
    const targetElementRect = targetElement.getBoundingClientRect();
    return {
      width: getDropIndicatorWidth(targetElementRect, 0)
    };
  }, [getDropIndicatorWidth, targetElement]);
  const horizontalScrollOffsetStyle = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; {
    if (!targetElement) {
      return {};
    }
    const scrollContainer = (0,external_wp_dom_namespaceObject.getScrollContainer)(targetElement);
    const ownerDocument = targetElement.ownerDocument;
    const windowScroll = scrollContainer === ownerDocument.body || scrollContainer === ownerDocument.documentElement;
    if (scrollContainer &amp;&amp; !windowScroll) {
      const scrollContainerRect = scrollContainer.getBoundingClientRect();
      const targetElementRect = targetElement.getBoundingClientRect();
      const distanceBetweenContainerAndTarget = rtl ? scrollContainerRect.right - targetElementRect.right : targetElementRect.left - scrollContainerRect.left;
      if (!rtl &amp;&amp; scrollContainerRect.left &gt; targetElementRect.left) {
        return {
          transform: `translateX( ${distanceBetweenContainerAndTarget}px )`
        };
      }
      if (rtl &amp;&amp; scrollContainerRect.right &lt; targetElementRect.right) {
        return {
          transform: `translateX( ${distanceBetweenContainerAndTarget * -1}px )`
        };
      }
    }
    return {};
  }, [rtl, targetElement]);
  const ariaLevel = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; {
    if (!rootBlockElement) {
      return 1;
    }
    const _ariaLevel = parseInt(rootBlockElement.getAttribute(&#039;aria-level&#039;), 10);
    return _ariaLevel ? _ariaLevel + 1 : 1;
  }, [rootBlockElement]);
  const hasAdjacentSelectedBranch = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; {
    if (!targetElement) {
      return false;
    }
    return targetElement.classList.contains(&#039;is-branch-selected&#039;);
  }, [targetElement]);
  const popoverAnchor = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; {
    const isValidDropPosition = dropPosition === &#039;top&#039; || dropPosition === &#039;bottom&#039; || dropPosition === &#039;inside&#039;;
    if (!targetElement || !isValidDropPosition) {
      return undefined;
    }
    return {
      contextElement: targetElement,
      getBoundingClientRect() {
        const rect = targetElement.getBoundingClientRect();
        // In RTL languages, the drop indicator should be positioned
        // to the left of the target element, with the width of the
        // indicator determining the indent at the right edge of the
        // target element. In LTR languages, the drop indicator should
        // end at the right edge of the target element, with the indent
        // added to the position of the left edge of the target element.
        // let left = rtl ? rect.left : rect.left + indent;
        let left = rect.left;
        let top = 0;

        // In deeply nested lists, where a scrollbar is present,
        // the width of the drop indicator should be the width of
        // the visible area of the scroll container. Additionally,
        // the left edge of the drop indicator line needs to be
        // offset by the distance the left edge of the target element
        // and the left edge of the scroll container. The ensures
        // that the drop indicator position never breaks out of the
        // visible area of the scroll container.
        const scrollContainer = (0,external_wp_dom_namespaceObject.getScrollContainer)(targetElement, &#039;horizontal&#039;);
        const doc = targetElement.ownerDocument;
        const windowScroll = scrollContainer === doc.body || scrollContainer === doc.documentElement;

        // If the scroll container is not the window, offset the left position, if need be.
        if (scrollContainer &amp;&amp; !windowScroll) {
          const scrollContainerRect = scrollContainer.getBoundingClientRect();

          // In RTL languages, a vertical scrollbar is present on the
          // left edge of the scroll container. The width of the
          // scrollbar needs to be accounted for when positioning the
          // drop indicator.
          const scrollbarWidth = rtl ? scrollContainer.offsetWidth - scrollContainer.clientWidth : 0;
          if (left &lt; scrollContainerRect.left + scrollbarWidth) {
            left = scrollContainerRect.left + scrollbarWidth;
          }
        }
        if (dropPosition === &#039;top&#039;) {
          top = rect.top - rect.height * 2;
        } else {
          // `dropPosition` is either `bottom` or `inside`
          top = rect.top;
        }
        const width = getDropIndicatorWidth(rect, 0);
        const height = rect.height;
        return new window.DOMRect(left, top, width, height);
      }
    };
  }, [targetElement, dropPosition, getDropIndicatorWidth, rtl]);
  if (!targetElement) {
    return null;
  }
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Popover, {
    animate: false,
    anchor: popoverAnchor,
    focusOnMount: false,
    className: &quot;block-editor-list-view-drop-indicator--preview&quot;,
    variant: &quot;unstyled&quot;,
    flip: false,
    resize: true,
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
      style: style,
      className: dist_clsx(&#039;block-editor-list-view-drop-indicator__line&#039;, {
        &#039;block-editor-list-view-drop-indicator__line--darker&#039;: hasAdjacentSelectedBranch
      }),
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;div&quot;, {
        className: &quot;block-editor-list-view-leaf&quot;,
        &quot;aria-level&quot;: ariaLevel,
        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;div&quot;, {
          className: dist_clsx(&#039;block-editor-list-view-block-select-button&#039;, &#039;block-editor-list-view-block-contents&#039;),
          style: horizontalScrollOffsetStyle,
          children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ListViewExpander, {
            onClick: () =&gt; {}
          }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_icon, {
            icon: blockInformation?.icon,
            showColors: true,
            context: &quot;list-view&quot;
          }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalHStack, {
            alignment: &quot;center&quot;,
            className: &quot;block-editor-list-view-block-select-button__label-wrapper&quot;,
            justify: &quot;flex-start&quot;,
            spacing: 1,
            children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;span&quot;, {
              className: &quot;block-editor-list-view-block-select-button__title&quot;,
              children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalTruncate, {
                ellipsizeMode: &quot;auto&quot;,
                children: blockTitle
              })
            })
          })]
        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
          className: &quot;block-editor-list-view-block__menu-cell&quot;
        })]
      })
    })
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/list-view/use-block-selection.js
/**
 * WordPress dependencies
 */







/**
 * Internal dependencies
 */


function useBlockSelection() {
  const {
    clearSelectedBlock,
    multiSelect,
    selectBlock
  } = (0,external_wp_data_namespaceObject.useDispatch)(store);
  const {
    getBlockName,
    getBlockParents,
    getBlockSelectionStart,
    getSelectedBlockClientIds,
    hasMultiSelection,
    hasSelectedBlock
  } = (0,external_wp_data_namespaceObject.useSelect)(store);
  const {
    getBlockType
  } = (0,external_wp_data_namespaceObject.useSelect)(external_wp_blocks_namespaceObject.store);
  const updateBlockSelection = (0,external_wp_element_namespaceObject.useCallback)(async (event, clientId, destinationClientId, focusPosition) =&gt; {
    if (!event?.shiftKey &amp;&amp; event?.keyCode !== external_wp_keycodes_namespaceObject.ESCAPE) {
      selectBlock(clientId, focusPosition);
      return;
    }

    // To handle multiple block selection via the `SHIFT` key, prevent
    // the browser default behavior of opening the link in a new window.
    event.preventDefault();
    const isOnlyDeselection = event.type === &#039;keydown&#039; &amp;&amp; event.keyCode === external_wp_keycodes_namespaceObject.ESCAPE;
    const isKeyPress = event.type === &#039;keydown&#039; &amp;&amp; (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);

    // Handle clicking on a block when no blocks are selected, and return early.
    if (!isKeyPress &amp;&amp; !hasSelectedBlock() &amp;&amp; !hasMultiSelection()) {
      selectBlock(clientId, null);
      return;
    }
    const selectedBlocks = getSelectedBlockClientIds();
    const clientIdWithParents = [...getBlockParents(clientId), clientId];
    if (isOnlyDeselection || isKeyPress &amp;&amp; !selectedBlocks.some(blockId =&gt; clientIdWithParents.includes(blockId))) {
      // Ensure that shift-selecting blocks via the keyboard only
      // expands the current selection if focusing over already
      // selected blocks. Otherwise, clear the selection so that
      // a user can create a new selection entirely by keyboard.
      await clearSelectedBlock();
    }

    // Update selection, if not only clearing the selection.
    if (!isOnlyDeselection) {
      let startTarget = getBlockSelectionStart();
      let endTarget = clientId;

      // Handle keyboard behavior for selecting multiple blocks.
      if (isKeyPress) {
        if (!hasSelectedBlock() &amp;&amp; !hasMultiSelection()) {
          // Set the starting point of the selection to the currently
          // focused block, if there are no blocks currently selected.
          // This ensures that as the selection is expanded or contracted,
          // the starting point of the selection is anchored to that block.
          startTarget = clientId;
        }
        if (destinationClientId) {
          // If the user presses UP or DOWN, we want to ensure that the block they&#039;re
          // moving to is the target for selection, and not the currently focused one.
          endTarget = destinationClientId;
        }
      }
      const startParents = getBlockParents(startTarget);
      const endParents = getBlockParents(endTarget);
      const {
        start,
        end
      } = getCommonDepthClientIds(startTarget, endTarget, startParents, endParents);
      await multiSelect(start, end, null);
    }

    // Announce deselected block, or number of deselected blocks if
    // the total number of blocks deselected is greater than one.
    const updatedSelectedBlocks = getSelectedBlockClientIds();

    // If the selection is greater than 1 and the Home or End keys
    // were used to generate the selection, then skip announcing the
    // deselected blocks.
    if ((event.keyCode === external_wp_keycodes_namespaceObject.HOME || event.keyCode === external_wp_keycodes_namespaceObject.END) &amp;&amp; updatedSelectedBlocks.length &gt; 1) {
      return;
    }
    const selectionDiff = selectedBlocks.filter(blockId =&gt; !updatedSelectedBlocks.includes(blockId));
    let label;
    if (selectionDiff.length === 1) {
      const title = getBlockType(getBlockName(selectionDiff[0]))?.title;
      if (title) {
        label = (0,external_wp_i18n_namespaceObject.sprintf)(/* translators: %s: block name */
        (0,external_wp_i18n_namespaceObject.__)(&#039;%s deselected.&#039;), title);
      }
    } else if (selectionDiff.length &gt; 1) {
      label = (0,external_wp_i18n_namespaceObject.sprintf)(/* translators: %s: number of deselected blocks */
      (0,external_wp_i18n_namespaceObject.__)(&#039;%s blocks deselected.&#039;), selectionDiff.length);
    }
    if (label) {
      (0,external_wp_a11y_namespaceObject.speak)(label, &#039;assertive&#039;);
    }
  }, [clearSelectedBlock, getBlockName, getBlockType, getBlockParents, getBlockSelectionStart, getSelectedBlockClientIds, hasMultiSelection, hasSelectedBlock, multiSelect, selectBlock]);
  return {
    updateBlockSelection
  };
}

;// ./node_modules/@wordpress/block-editor/build-module/components/list-view/use-list-view-block-indexes.js
/**
 * WordPress dependencies
 */

function useListViewBlockIndexes(blocks) {
  const blockIndexes = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; {
    const indexes = {};
    let currentGlobalIndex = 0;
    const traverseBlocks = blockList =&gt; {
      blockList.forEach(block =&gt; {
        indexes[block.clientId] = currentGlobalIndex;
        currentGlobalIndex++;
        if (block.innerBlocks.length &gt; 0) {
          traverseBlocks(block.innerBlocks);
        }
      });
    };
    traverseBlocks(blocks);
    return indexes;
  }, [blocks]);
  return blockIndexes;
}

;// ./node_modules/@wordpress/block-editor/build-module/components/list-view/use-list-view-client-ids.js
/**
 * WordPress dependencies
 */



/**
 * Internal dependencies
 */


function useListViewClientIds({
  blocks,
  rootClientId
}) {
  return (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      getDraggedBlockClientIds,
      getSelectedBlockClientIds,
      getEnabledClientIdsTree
    } = unlock(select(store));
    return {
      selectedClientIds: getSelectedBlockClientIds(),
      draggedClientIds: getDraggedBlockClientIds(),
      clientIdsTree: blocks !== null &amp;&amp; blocks !== void 0 ? blocks : getEnabledClientIdsTree(rootClientId)
    };
  }, [blocks, rootClientId]);
}

;// ./node_modules/@wordpress/block-editor/build-module/components/list-view/use-list-view-collapse-items.js
/**
 * WordPress dependencies
 */



/**
 * Internal dependencies
 */


function useListViewCollapseItems({
  collapseAll,
  expand
}) {
  const {
    expandedBlock,
    getBlockParents
  } = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      getBlockParents: _getBlockParents,
      getExpandedBlock
    } = unlock(select(store));
    return {
      expandedBlock: getExpandedBlock(),
      getBlockParents: _getBlockParents
    };
  }, []);

  // Collapse all but the specified block when the expanded block client Id changes.
  (0,external_wp_element_namespaceObject.useEffect)(() =&gt; {
    if (expandedBlock) {
      const blockParents = getBlockParents(expandedBlock, false);
      // Collapse all blocks and expand the block&#039;s parents.
      collapseAll();
      expand(blockParents);
    }
  }, [collapseAll, expand, expandedBlock, getBlockParents]);
}

;// ./node_modules/@wordpress/block-editor/build-module/components/list-view/use-list-view-drop-zone.js
/**
 * WordPress dependencies
 */





/**
 * Internal dependencies
 */




/** @typedef {import(&#039;../../utils/math&#039;).WPPoint} WPPoint */

/**
 * The type of a drag event.
 *
 * @typedef {&#039;default&#039;|&#039;file&#039;|&#039;html&#039;} WPDragEventType
 */

/**
 * An object representing data for blocks in the DOM used by drag and drop.
 *
 * @typedef {Object} WPListViewDropZoneBlock
 * @property {string}  clientId                        The client id for the block.
 * @property {string}  rootClientId                    The root client id for the block.
 * @property {number}  blockIndex                      The block&#039;s index.
 * @property {Element} element                         The DOM element representing the block.
 * @property {number}  innerBlockCount                 The number of inner blocks the block has.
 * @property {boolean} isDraggedBlock                  Whether the block is currently being dragged.
 * @property {boolean} isExpanded                      Whether the block is expanded in the UI.
 * @property {boolean} canInsertDraggedBlocksAsSibling Whether the dragged block can be a sibling of this block.
 * @property {boolean} canInsertDraggedBlocksAsChild   Whether the dragged block can be a child of this block.
 */

/**
 * An array representing data for blocks in the DOM used by drag and drop.
 *
 * @typedef {WPListViewDropZoneBlock[]} WPListViewDropZoneBlocks
 */

/**
 * An object containing details of a drop target.
 *
 * @typedef {Object} WPListViewDropZoneTarget
 * @property {string}                  blockIndex   The insertion index.
 * @property {string}                  rootClientId The root client id for the block.
 * @property {string|undefined}        clientId     The client id for the block.
 * @property {&#039;top&#039;|&#039;bottom&#039;|&#039;inside&#039;} dropPosition The position relative to the block that the user is dropping to.
 *                                                  &#039;inside&#039; refers to nesting as an inner block.
 */

// When the indentation level, the corresponding left margin in `style.scss`
// must be updated as well to ensure the drop zone is aligned with the indentation.
const NESTING_LEVEL_INDENTATION = 24;

/**
 * Determines whether the user is positioning the dragged block to be
 * moved up to a parent level.
 *
 * Determined based on nesting level indentation of the current block.
 *
 * @param {WPPoint} point        The point representing the cursor position when dragging.
 * @param {DOMRect} rect         The rectangle.
 * @param {number}  nestingLevel The nesting level of the block.
 * @param {boolean} rtl          Whether the editor is in RTL mode.
 * @return {boolean} Whether the gesture is an upward gesture.
 */
function isUpGesture(point, rect, nestingLevel = 1, rtl = false) {
  // If the block is nested, and the user is dragging to the bottom
  // left of the block (or bottom right in RTL languages), then it is an upward gesture.
  const blockIndentPosition = rtl ? rect.right - nestingLevel * NESTING_LEVEL_INDENTATION : rect.left + nestingLevel * NESTING_LEVEL_INDENTATION;
  return rtl ? point.x &gt; blockIndentPosition : point.x &lt; blockIndentPosition;
}

/**
 * Returns how many nesting levels up the user is attempting to drag to.
 *
 * The relative parent level is calculated based on how far
 * the cursor is from the provided nesting level (e.g. of a candidate block
 * that the user is hovering over). The nesting level is considered &quot;desired&quot;
 * because it is not guaranteed that the user will be able to drag to the desired level.
 *
 * The returned integer can be used to access an ascending array
 * of parent blocks, where the first item is the block the user
 * is hovering over, and the last item is the root block.
 *
 * @param {WPPoint} point        The point representing the cursor position when dragging.
 * @param {DOMRect} rect         The rectangle.
 * @param {number}  nestingLevel The nesting level of the block.
 * @param {boolean} rtl          Whether the editor is in RTL mode.
 * @return {number} The desired relative parent level.
 */
function getDesiredRelativeParentLevel(point, rect, nestingLevel = 1, rtl = false) {
  // In RTL languages, the block indent position is from the right edge of the block.
  // In LTR languages, the block indent position is from the left edge of the block.
  const blockIndentPosition = rtl ? rect.right - nestingLevel * NESTING_LEVEL_INDENTATION : rect.left + nestingLevel * NESTING_LEVEL_INDENTATION;
  const distanceBetweenPointAndBlockIndentPosition = rtl ? blockIndentPosition - point.x : point.x - blockIndentPosition;
  const desiredParentLevel = Math.round(distanceBetweenPointAndBlockIndentPosition / NESTING_LEVEL_INDENTATION);
  return Math.abs(desiredParentLevel);
}

/**
 * Returns an array of the parent blocks of the block the user is dropping to.
 *
 * @param {WPListViewDropZoneBlock}  candidateBlockData The block the user is dropping to.
 * @param {WPListViewDropZoneBlocks} blocksData         Data about the blocks in list view.
 * @return {WPListViewDropZoneBlocks} An array of block parents, including the block the user is dropping to.
 */
function getCandidateBlockParents(candidateBlockData, blocksData) {
  const candidateBlockParents = [];
  let currentBlockData = candidateBlockData;
  while (currentBlockData) {
    candidateBlockParents.push({
      ...currentBlockData
    });
    currentBlockData = blocksData.find(blockData =&gt; blockData.clientId === currentBlockData.rootClientId);
  }
  return candidateBlockParents;
}

/**
 * Given a list of blocks data and a block index, return the next non-dragged
 * block. This is used to determine the block that the user is dropping to,
 * while ignoring the dragged block.
 *
 * @param {WPListViewDropZoneBlocks} blocksData Data about the blocks in list view.
 * @param {number}                   index      The index to begin searching from.
 * @return {WPListViewDropZoneBlock | undefined} The next non-dragged block.
 */
function getNextNonDraggedBlock(blocksData, index) {
  const nextBlockData = blocksData[index + 1];
  if (nextBlockData &amp;&amp; nextBlockData.isDraggedBlock) {
    return getNextNonDraggedBlock(blocksData, index + 1);
  }
  return nextBlockData;
}

/**
 * Determines whether the user positioning the dragged block to nest as an
 * inner block.
 *
 * Determined based on nesting level indentation of the current block, plus
 * the indentation of the next level of nesting. The vertical position of the
 * cursor must also be within the block.
 *
 * @param {WPPoint} point        The point representing the cursor position when dragging.
 * @param {DOMRect} rect         The rectangle.
 * @param {number}  nestingLevel The nesting level of the block.
 * @param {boolean} rtl          Whether the editor is in RTL mode.
 */
function isNestingGesture(point, rect, nestingLevel = 1, rtl = false) {
  const blockIndentPosition = rtl ? rect.right - nestingLevel * NESTING_LEVEL_INDENTATION : rect.left + nestingLevel * NESTING_LEVEL_INDENTATION;
  const isNestingHorizontalGesture = rtl ? point.x &lt; blockIndentPosition - NESTING_LEVEL_INDENTATION : point.x &gt; blockIndentPosition + NESTING_LEVEL_INDENTATION;
  return isNestingHorizontalGesture &amp;&amp; point.y &lt; rect.bottom;
}

// Block navigation is always a vertical list, so only allow dropping
// to the above or below a block.
const ALLOWED_DROP_EDGES = [&#039;top&#039;, &#039;bottom&#039;];

/**
 * Given blocks data and the cursor position, compute the drop target.
 *
 * @param {WPListViewDropZoneBlocks} blocksData Data about the blocks in list view.
 * @param {WPPoint}                  position   The point representing the cursor position when dragging.
 * @param {boolean}                  rtl        Whether the editor is in RTL mode.
 *
 * @return {WPListViewDropZoneTarget | undefined} An object containing data about the drop target.
 */
function getListViewDropTarget(blocksData, position, rtl = false) {
  let candidateEdge;
  let candidateBlockData;
  let candidateDistance;
  let candidateRect;
  let candidateBlockIndex;
  for (let i = 0; i &lt; blocksData.length; i++) {
    const blockData = blocksData[i];
    if (blockData.isDraggedBlock) {
      continue;
    }
    const rect = blockData.element.getBoundingClientRect();
    const [distance, edge] = getDistanceToNearestEdge(position, rect, ALLOWED_DROP_EDGES);
    const isCursorWithinBlock = isPointContainedByRect(position, rect);
    if (candidateDistance === undefined || distance &lt; candidateDistance || isCursorWithinBlock) {
      candidateDistance = distance;
      const index = blocksData.indexOf(blockData);
      const previousBlockData = blocksData[index - 1];

      // If dragging near the top of a block and the preceding block
      // is at the same level, use the preceding block as the candidate
      // instead, as later it makes determining a nesting drop easier.
      if (edge === &#039;top&#039; &amp;&amp; previousBlockData &amp;&amp; previousBlockData.rootClientId === blockData.rootClientId &amp;&amp; !previousBlockData.isDraggedBlock) {
        candidateBlockData = previousBlockData;
        candidateEdge = &#039;bottom&#039;;
        candidateRect = previousBlockData.element.getBoundingClientRect();
        candidateBlockIndex = index - 1;
      } else {
        candidateBlockData = blockData;
        candidateEdge = edge;
        candidateRect = rect;
        candidateBlockIndex = index;
      }

      // If the mouse position is within the block, break early
      // as the user would intend to drop either before or after
      // this block.
      //
      // This solves an issue where some rows in the list view
      // tree overlap slightly due to sub-pixel rendering.
      if (isCursorWithinBlock) {
        break;
      }
    }
  }
  if (!candidateBlockData) {
    return;
  }
  const candidateBlockParents = getCandidateBlockParents(candidateBlockData, blocksData);
  const isDraggingBelow = candidateEdge === &#039;bottom&#039;;

  // If the user is dragging towards the bottom of the block check whether
  // they might be trying to nest the block as a child.
  // If the block already has inner blocks, and is expanded, this should be treated
  // as nesting since the next block in the tree will be the first child.
  // However, if the block is collapsed, dragging beneath the block should
  // still be allowed, as the next visible block in the tree will be a sibling.
  if (isDraggingBelow &amp;&amp; candidateBlockData.canInsertDraggedBlocksAsChild &amp;&amp; (candidateBlockData.innerBlockCount &gt; 0 &amp;&amp; candidateBlockData.isExpanded || isNestingGesture(position, candidateRect, candidateBlockParents.length, rtl))) {
    // If the block is expanded, insert the block as the first child.
    // Otherwise, for collapsed blocks, insert the block as the last child.
    const newBlockIndex = candidateBlockData.isExpanded ? 0 : candidateBlockData.innerBlockCount || 0;
    return {
      rootClientId: candidateBlockData.clientId,
      clientId: candidateBlockData.clientId,
      blockIndex: newBlockIndex,
      dropPosition: &#039;inside&#039;
    };
  }

  // If the user is dragging towards the bottom of the block check whether
  // they might be trying to move the block to be at a parent level.
  if (isDraggingBelow &amp;&amp; candidateBlockData.rootClientId &amp;&amp; isUpGesture(position, candidateRect, candidateBlockParents.length, rtl)) {
    const nextBlock = getNextNonDraggedBlock(blocksData, candidateBlockIndex);
    const currentLevel = candidateBlockData.nestingLevel;
    const nextLevel = nextBlock ? nextBlock.nestingLevel : 1;
    if (currentLevel &amp;&amp; nextLevel) {
      // Determine the desired relative level of the block to be dropped.
      const desiredRelativeLevel = getDesiredRelativeParentLevel(position, candidateRect, candidateBlockParents.length, rtl);
      const targetParentIndex = Math.max(Math.min(desiredRelativeLevel, currentLevel - nextLevel), 0);
      if (candidateBlockParents[targetParentIndex]) {
        // Default to the block index of the candidate block.
        let newBlockIndex = candidateBlockData.blockIndex;

        // If the next block is at the same level, use that as the default
        // block index. This ensures that the block is dropped in the correct
        // position when dragging to the bottom of a block.
        if (candidateBlockParents[targetParentIndex].nestingLevel === nextBlock?.nestingLevel) {
          newBlockIndex = nextBlock?.blockIndex;
        } else {
          // Otherwise, search from the current block index back
          // to find the last block index within the same target parent.
          for (let i = candidateBlockIndex; i &gt;= 0; i--) {
            const blockData = blocksData[i];
            if (blockData.rootClientId === candidateBlockParents[targetParentIndex].rootClientId) {
              newBlockIndex = blockData.blockIndex + 1;
              break;
            }
          }
        }
        return {
          rootClientId: candidateBlockParents[targetParentIndex].rootClientId,
          clientId: candidateBlockData.clientId,
          blockIndex: newBlockIndex,
          dropPosition: candidateEdge
        };
      }
    }
  }

  // If dropping as a sibling, but block cannot be inserted in
  // this context, return early.
  if (!candidateBlockData.canInsertDraggedBlocksAsSibling) {
    return;
  }
  const offset = isDraggingBelow ? 1 : 0;
  return {
    rootClientId: candidateBlockData.rootClientId,
    clientId: candidateBlockData.clientId,
    blockIndex: candidateBlockData.blockIndex + offset,
    dropPosition: candidateEdge
  };
}

// Throttle options need to be defined outside of the hook to avoid
// re-creating the object on every render. This is due to a limitation
// of the `useThrottle` hook, where the options object is included
// in the dependency array for memoization.
const EXPAND_THROTTLE_OPTIONS = {
  leading: false,
  // Don&#039;t call the function immediately on the first call.
  trailing: true // Do call the function on the last call.
};

/**
 * A react hook for implementing a drop zone in list view.
 *
 * @param {Object}       props                    Named parameters.
 * @param {?HTMLElement} [props.dropZoneElement]  Optional element to be used as the drop zone.
 * @param {Object}       [props.expandedState]    The expanded state of the blocks in the list view.
 * @param {Function}     [props.setExpandedState] Function to set the expanded state of a list of block clientIds.
 *
 * @return {WPListViewDropZoneTarget} The drop target.
 */
function useListViewDropZone({
  dropZoneElement,
  expandedState,
  setExpandedState
}) {
  const {
    getBlockRootClientId,
    getBlockIndex,
    getBlockCount,
    getDraggedBlockClientIds,
    canInsertBlocks
  } = (0,external_wp_data_namespaceObject.useSelect)(store);
  const [target, setTarget] = (0,external_wp_element_namespaceObject.useState)();
  const {
    rootClientId: targetRootClientId,
    blockIndex: targetBlockIndex
  } = target || {};
  const onBlockDrop = useOnBlockDrop(targetRootClientId, targetBlockIndex);
  const rtl = (0,external_wp_i18n_namespaceObject.isRTL)();
  const previousRootClientId = (0,external_wp_compose_namespaceObject.usePrevious)(targetRootClientId);
  const maybeExpandBlock = (0,external_wp_element_namespaceObject.useCallback)((_expandedState, _target) =&gt; {
    // If the user is attempting to drop a block inside a collapsed block,
    // that is, using a nesting gesture flagged by &#039;inside&#039; dropPosition,
    // expand the block within the list view, if it isn&#039;t already.
    const {
      rootClientId
    } = _target || {};
    if (!rootClientId) {
      return;
    }
    if (_target?.dropPosition === &#039;inside&#039; &amp;&amp; !_expandedState[rootClientId]) {
      setExpandedState({
        type: &#039;expand&#039;,
        clientIds: [rootClientId]
      });
    }
  }, [setExpandedState]);

  // Throttle the maybeExpandBlock function to avoid expanding the block
  // too quickly when the user is dragging over the block. This is to
  // avoid expanding the block when the user is just passing over it.
  const throttledMaybeExpandBlock = (0,external_wp_compose_namespaceObject.useThrottle)(maybeExpandBlock, 500, EXPAND_THROTTLE_OPTIONS);
  (0,external_wp_element_namespaceObject.useEffect)(() =&gt; {
    if (target?.dropPosition !== &#039;inside&#039; || previousRootClientId !== target?.rootClientId) {
      throttledMaybeExpandBlock.cancel();
      return;
    }
    throttledMaybeExpandBlock(expandedState, target);
  }, [expandedState, previousRootClientId, target, throttledMaybeExpandBlock]);
  const draggedBlockClientIds = getDraggedBlockClientIds();
  const throttled = (0,external_wp_compose_namespaceObject.useThrottle)((0,external_wp_element_namespaceObject.useCallback)((event, currentTarget) =&gt; {
    const position = {
      x: event.clientX,
      y: event.clientY
    };
    const isBlockDrag = !!draggedBlockClientIds?.length;
    const blockElements = Array.from(currentTarget.querySelectorAll(&#039;[data-block]&#039;));
    const blocksData = blockElements.map(blockElement =&gt; {
      const clientId = blockElement.dataset.block;
      const isExpanded = blockElement.dataset.expanded === &#039;true&#039;;
      const isDraggedBlock = blockElement.classList.contains(&#039;is-dragging&#039;);

      // Get nesting level from `aria-level` attribute because Firefox does not support `element.ariaLevel`.
      const nestingLevel = parseInt(blockElement.getAttribute(&#039;aria-level&#039;), 10);
      const rootClientId = getBlockRootClientId(clientId);
      return {
        clientId,
        isExpanded,
        rootClientId,
        blockIndex: getBlockIndex(clientId),
        element: blockElement,
        nestingLevel: nestingLevel || undefined,
        isDraggedBlock: isBlockDrag ? isDraggedBlock : false,
        innerBlockCount: getBlockCount(clientId),
        canInsertDraggedBlocksAsSibling: isBlockDrag ? canInsertBlocks(draggedBlockClientIds, rootClientId) : true,
        canInsertDraggedBlocksAsChild: isBlockDrag ? canInsertBlocks(draggedBlockClientIds, clientId) : true
      };
    });
    const newTarget = getListViewDropTarget(blocksData, position, rtl);
    if (newTarget) {
      setTarget(newTarget);
    }
  }, [canInsertBlocks, draggedBlockClientIds, getBlockCount, getBlockIndex, getBlockRootClientId, rtl]), 50);
  const ref = (0,external_wp_compose_namespaceObject.__experimentalUseDropZone)({
    dropZoneElement,
    onDrop(event) {
      throttled.cancel();
      if (target) {
        onBlockDrop(event);
      }
      // Use `undefined` value to indicate that the drag has concluded.
      // This allows styling rules that are active only when a user is
      // dragging to be removed.
      setTarget(undefined);
    },
    onDragLeave() {
      throttled.cancel();
      // Use `null` value to indicate that the drop target is not valid,
      // but that the drag is still active. This allows for styling rules
      // that are active only when a user drags outside of the list view.
      setTarget(null);
    },
    onDragOver(event) {
      // `currentTarget` is only available while the event is being
      // handled, so get it now and pass it to the thottled function.
      // https://developer.mozilla.org/en-US/docs/Web/API/Event/currentTarget
      throttled(event, event.currentTarget);
    },
    onDragEnd() {
      throttled.cancel();
      // Use `undefined` value to indicate that the drag has concluded.
      // This allows styling rules that are active only when a user is
      // dragging to be removed.
      setTarget(undefined);
    }
  });
  return {
    ref,
    target
  };
}

;// ./node_modules/@wordpress/block-editor/build-module/components/list-view/use-list-view-expand-selected-item.js
/**
 * WordPress dependencies
 */



/**
 * Internal dependencies
 */

function useListViewExpandSelectedItem({
  firstSelectedBlockClientId,
  setExpandedState
}) {
  const [selectedTreeId, setSelectedTreeId] = (0,external_wp_element_namespaceObject.useState)(null);
  const {
    selectedBlockParentClientIds
  } = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      getBlockParents
    } = select(store);
    return {
      selectedBlockParentClientIds: getBlockParents(firstSelectedBlockClientId, false)
    };
  }, [firstSelectedBlockClientId]);

  // Expand tree when a block is selected.
  (0,external_wp_element_namespaceObject.useEffect)(() =&gt; {
    // If the selectedTreeId is the same as the selected block,
    // it means that the block was selected using the block list tree.
    if (selectedTreeId === firstSelectedBlockClientId) {
      return;
    }

    // If the selected block has parents, get the top-level parent.
    if (selectedBlockParentClientIds?.length) {
      // If the selected block has parents,
      // expand the tree branch.
      setExpandedState({
        type: &#039;expand&#039;,
        clientIds: selectedBlockParentClientIds
      });
    }
  }, [firstSelectedBlockClientId, selectedBlockParentClientIds, selectedTreeId, setExpandedState]);
  return {
    setSelectedTreeId
  };
}

;// ./node_modules/@wordpress/block-editor/build-module/components/list-view/use-clipboard-handler.js
/**
 * WordPress dependencies
 */



/**
 * Internal dependencies
 */





// This hook borrows from useClipboardHandler in ../writing-flow/use-clipboard-handler.js
// and adds behaviour for the list view, while skipping partial selection.
function use_clipboard_handler_useClipboardHandler({
  selectBlock
}) {
  const registry = (0,external_wp_data_namespaceObject.useRegistry)();
  const {
    getBlockOrder,
    getBlockRootClientId,
    getBlocksByClientId,
    getPreviousBlockClientId,
    getSelectedBlockClientIds,
    getSettings,
    canInsertBlockType,
    canRemoveBlocks
  } = (0,external_wp_data_namespaceObject.useSelect)(store);
  const {
    flashBlock,
    removeBlocks,
    replaceBlocks,
    insertBlocks
  } = (0,external_wp_data_namespaceObject.useDispatch)(store);
  const notifyCopy = useNotifyCopy();
  return (0,external_wp_compose_namespaceObject.useRefEffect)(node =&gt; {
    function updateFocusAndSelection(focusClientId, shouldSelectBlock) {
      if (shouldSelectBlock) {
        selectBlock(undefined, focusClientId, null, null);
      }
      focusListItem(focusClientId, node);
    }

    // Determine which blocks to update:
    // If the current (focused) block is part of the block selection, use the whole selection.
    // If the focused block is not part of the block selection, only update the focused block.
    function getBlocksToUpdate(clientId) {
      const selectedBlockClientIds = getSelectedBlockClientIds();
      const isUpdatingSelectedBlocks = selectedBlockClientIds.includes(clientId);
      const firstBlockClientId = isUpdatingSelectedBlocks ? selectedBlockClientIds[0] : clientId;
      const firstBlockRootClientId = getBlockRootClientId(firstBlockClientId);
      const blocksToUpdate = isUpdatingSelectedBlocks ? selectedBlockClientIds : [clientId];
      return {
        blocksToUpdate,
        firstBlockClientId,
        firstBlockRootClientId,
        originallySelectedBlockClientIds: selectedBlockClientIds
      };
    }
    function handler(event) {
      if (event.defaultPrevented) {
        // This was possibly already handled in rich-text/use-paste-handler.js.
        return;
      }

      // Only handle events that occur within the list view.
      if (!node.contains(event.target.ownerDocument.activeElement)) {
        return;
      }

      // Retrieve the block clientId associated with the focused list view row.
      // This enables applying copy / cut / paste behavior to the focused block,
      // rather than just the blocks that are currently selected.
      const listViewRow = event.target.ownerDocument.activeElement?.closest(&#039;[role=row]&#039;);
      const clientId = listViewRow?.dataset?.block;
      if (!clientId) {
        return;
      }
      const {
        blocksToUpdate: selectedBlockClientIds,
        firstBlockClientId,
        firstBlockRootClientId,
        originallySelectedBlockClientIds
      } = getBlocksToUpdate(clientId);
      if (selectedBlockClientIds.length === 0) {
        return;
      }
      event.preventDefault();
      if (event.type === &#039;copy&#039; || event.type === &#039;cut&#039;) {
        if (selectedBlockClientIds.length === 1) {
          flashBlock(selectedBlockClientIds[0]);
        }
        notifyCopy(event.type, selectedBlockClientIds);
        const blocks = getBlocksByClientId(selectedBlockClientIds);
        setClipboardBlocks(event, blocks, registry);
      }
      if (event.type === &#039;cut&#039;) {
        var _getPreviousBlockClie;
        // Don&#039;t update the selection if the blocks cannot be deleted.
        if (!canRemoveBlocks(selectedBlockClientIds)) {
          return;
        }
        let blockToFocus = (_getPreviousBlockClie = getPreviousBlockClientId(firstBlockClientId)) !== null &amp;&amp; _getPreviousBlockClie !== void 0 ? _getPreviousBlockClie :
        // If the previous block is not found (when the first block is deleted),
        // fallback to focus the parent block.
        firstBlockRootClientId;

        // Remove blocks, but don&#039;t update selection, and it will be handled below.
        removeBlocks(selectedBlockClientIds, false);

        // Update the selection if the original selection has been removed.
        const shouldUpdateSelection = originallySelectedBlockClientIds.length &gt; 0 &amp;&amp; getSelectedBlockClientIds().length === 0;

        // If there&#039;s no previous block nor parent block, focus the first block.
        if (!blockToFocus) {
          blockToFocus = getBlockOrder()[0];
        }
        updateFocusAndSelection(blockToFocus, shouldUpdateSelection);
      } else if (event.type === &#039;paste&#039;) {
        const {
          __experimentalCanUserUseUnfilteredHTML: canUserUseUnfilteredHTML
        } = getSettings();
        const blocks = getPasteBlocks(event, canUserUseUnfilteredHTML);
        if (selectedBlockClientIds.length === 1) {
          const [selectedBlockClientId] = selectedBlockClientIds;

          // If a single block is focused, and the blocks to be posted can
          // be inserted within the block, then append the pasted blocks
          // within the focused block. For example, if you have copied a paragraph
          // block and paste it within a single Group block, this will append
          // the paragraph block within the Group block.
          if (blocks.every(block =&gt; canInsertBlockType(block.name, selectedBlockClientId))) {
            insertBlocks(blocks, undefined, selectedBlockClientId);
            updateFocusAndSelection(blocks[0]?.clientId, false);
            return;
          }
        }
        replaceBlocks(selectedBlockClientIds, blocks, blocks.length - 1, -1);
        updateFocusAndSelection(blocks[0]?.clientId, false);
      }
    }
    node.ownerDocument.addEventListener(&#039;copy&#039;, handler);
    node.ownerDocument.addEventListener(&#039;cut&#039;, handler);
    node.ownerDocument.addEventListener(&#039;paste&#039;, handler);
    return () =&gt; {
      node.ownerDocument.removeEventListener(&#039;copy&#039;, handler);
      node.ownerDocument.removeEventListener(&#039;cut&#039;, handler);
      node.ownerDocument.removeEventListener(&#039;paste&#039;, handler);
    };
  }, []);
}

;// ./node_modules/@wordpress/block-editor/build-module/components/list-view/index.js
/**
 * External dependencies
 */


/**
 * WordPress dependencies
 */







/**
 * Internal dependencies
 */














const expanded = (state, action) =&gt; {
  if (action.type === &#039;clear&#039;) {
    return {};
  }
  if (Array.isArray(action.clientIds)) {
    return {
      ...state,
      ...action.clientIds.reduce((newState, id) =&gt; ({
        ...newState,
        [id]: action.type === &#039;expand&#039;
      }), {})
    };
  }
  return state;
};
const BLOCK_LIST_ITEM_HEIGHT = 32;

/** @typedef {import(&#039;react&#039;).ComponentType} ComponentType */
/** @typedef {import(&#039;react&#039;).Ref&lt;HTMLElement&gt;} Ref */

/**
 * Show a hierarchical list of blocks.
 *
 * @param {Object}         props                        Components props.
 * @param {string}         props.id                     An HTML element id for the root element of ListView.
 * @param {Array}          props.blocks                 _deprecated_ Custom subset of block client IDs to be used instead of the default hierarchy.
 * @param {?HTMLElement}   props.dropZoneElement        Optional element to be used as the drop zone.
 * @param {?boolean}       props.showBlockMovers        Flag to enable block movers. Defaults to `false`.
 * @param {?boolean}       props.isExpanded             Flag to determine whether nested levels are expanded by default. Defaults to `false`.
 * @param {?boolean}       props.showAppender           Flag to show or hide the block appender. Defaults to `false`.
 * @param {?ComponentType} props.blockSettingsMenu      Optional more menu substitution. Defaults to the standard `BlockSettingsDropdown` component.
 * @param {string}         props.rootClientId           The client id of the root block from which we determine the blocks to show in the list.
 * @param {string}         props.description            Optional accessible description for the tree grid component.
 * @param {?Function}      props.onSelect               Optional callback to be invoked when a block is selected. Receives the block object that was selected.
 * @param {?ComponentType} props.additionalBlockContent Component that renders additional block content UI.
 * @param {Ref}            ref                          Forwarded ref
 */
function ListViewComponent({
  id,
  blocks,
  dropZoneElement,
  showBlockMovers = false,
  isExpanded = false,
  showAppender = false,
  blockSettingsMenu: BlockSettingsMenu = BlockSettingsDropdown,
  rootClientId,
  description,
  onSelect,
  additionalBlockContent: AdditionalBlockContent
}, ref) {
  // This can be removed once we no longer need to support the blocks prop.
  if (blocks) {
    external_wp_deprecated_default()(&#039;`blocks` property in `wp.blockEditor.__experimentalListView`&#039;, {
      since: &#039;6.3&#039;,
      alternative: &#039;`rootClientId` property&#039;
    });
  }
  const instanceId = (0,external_wp_compose_namespaceObject.useInstanceId)(ListViewComponent);
  const {
    clientIdsTree,
    draggedClientIds,
    selectedClientIds
  } = useListViewClientIds({
    blocks,
    rootClientId
  });
  const blockIndexes = useListViewBlockIndexes(clientIdsTree);
  const {
    getBlock
  } = (0,external_wp_data_namespaceObject.useSelect)(store);
  const {
    visibleBlockCount
  } = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      getGlobalBlockCount,
      getClientIdsOfDescendants
    } = select(store);
    const draggedBlockCount = draggedClientIds?.length &gt; 0 ? getClientIdsOfDescendants(draggedClientIds).length + 1 : 0;
    return {
      visibleBlockCount: getGlobalBlockCount() - draggedBlockCount
    };
  }, [draggedClientIds]);
  const {
    updateBlockSelection
  } = useBlockSelection();
  const [expandedState, setExpandedState] = (0,external_wp_element_namespaceObject.useReducer)(expanded, {});
  const [insertedBlock, setInsertedBlock] = (0,external_wp_element_namespaceObject.useState)(null);
  const {
    setSelectedTreeId
  } = useListViewExpandSelectedItem({
    firstSelectedBlockClientId: selectedClientIds[0],
    setExpandedState
  });
  const selectEditorBlock = (0,external_wp_element_namespaceObject.useCallback)(
  /**
   * @param {MouseEvent | KeyboardEvent | undefined} event
   * @param {string}                                 blockClientId
   * @param {null | undefined | -1 | 1}              focusPosition
   */
  (event, blockClientId, focusPosition) =&gt; {
    updateBlockSelection(event, blockClientId, null, focusPosition);
    setSelectedTreeId(blockClientId);
    if (onSelect) {
      onSelect(getBlock(blockClientId));
    }
  }, [setSelectedTreeId, updateBlockSelection, onSelect, getBlock]);
  const {
    ref: dropZoneRef,
    target: blockDropTarget
  } = useListViewDropZone({
    dropZoneElement,
    expandedState,
    setExpandedState
  });
  const elementRef = (0,external_wp_element_namespaceObject.useRef)();

  // Allow handling of copy, cut, and paste events.
  const clipBoardRef = use_clipboard_handler_useClipboardHandler({
    selectBlock: selectEditorBlock
  });
  const treeGridRef = (0,external_wp_compose_namespaceObject.useMergeRefs)([clipBoardRef, elementRef, dropZoneRef, ref]);
  (0,external_wp_element_namespaceObject.useEffect)(() =&gt; {
    // If a blocks are already selected when the list view is initially
    // mounted, shift focus to the first selected block.
    if (selectedClientIds?.length) {
      focusListItem(selectedClientIds[0], elementRef?.current);
    }
    // Only focus on the selected item when the list view is mounted.
  }, []);
  const expand = (0,external_wp_element_namespaceObject.useCallback)(clientId =&gt; {
    if (!clientId) {
      return;
    }
    const clientIds = Array.isArray(clientId) ? clientId : [clientId];
    setExpandedState({
      type: &#039;expand&#039;,
      clientIds
    });
  }, [setExpandedState]);
  const collapse = (0,external_wp_element_namespaceObject.useCallback)(clientId =&gt; {
    if (!clientId) {
      return;
    }
    setExpandedState({
      type: &#039;collapse&#039;,
      clientIds: [clientId]
    });
  }, [setExpandedState]);
  const collapseAll = (0,external_wp_element_namespaceObject.useCallback)(() =&gt; {
    setExpandedState({
      type: &#039;clear&#039;
    });
  }, [setExpandedState]);
  const expandRow = (0,external_wp_element_namespaceObject.useCallback)(row =&gt; {
    expand(row?.dataset?.block);
  }, [expand]);
  const collapseRow = (0,external_wp_element_namespaceObject.useCallback)(row =&gt; {
    collapse(row?.dataset?.block);
  }, [collapse]);
  const focusRow = (0,external_wp_element_namespaceObject.useCallback)((event, startRow, endRow) =&gt; {
    if (event.shiftKey) {
      updateBlockSelection(event, startRow?.dataset?.block, endRow?.dataset?.block);
    }
  }, [updateBlockSelection]);
  useListViewCollapseItems({
    collapseAll,
    expand
  });
  const firstDraggedBlockClientId = draggedClientIds?.[0];

  // Convert a blockDropTarget into indexes relative to the blocks in the list view.
  // These values are used to determine which blocks should be displaced to make room
  // for the drop indicator. See `ListViewBranch` and `getDragDisplacementValues`.
  const {
    blockDropTargetIndex,
    blockDropPosition,
    firstDraggedBlockIndex
  } = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; {
    let _blockDropTargetIndex, _firstDraggedBlockIndex;
    if (blockDropTarget?.clientId) {
      const foundBlockIndex = blockIndexes[blockDropTarget.clientId];
      // If dragging below or inside the block, treat the drop target as the next block.
      _blockDropTargetIndex = foundBlockIndex === undefined || blockDropTarget?.dropPosition === &#039;top&#039; ? foundBlockIndex : foundBlockIndex + 1;
    } else if (blockDropTarget === null) {
      // A `null` value is used to indicate that the user is dragging outside of the list view.
      _blockDropTargetIndex = null;
    }
    if (firstDraggedBlockClientId) {
      const foundBlockIndex = blockIndexes[firstDraggedBlockClientId];
      _firstDraggedBlockIndex = foundBlockIndex === undefined || blockDropTarget?.dropPosition === &#039;top&#039; ? foundBlockIndex : foundBlockIndex + 1;
    }
    return {
      blockDropTargetIndex: _blockDropTargetIndex,
      blockDropPosition: blockDropTarget?.dropPosition,
      firstDraggedBlockIndex: _firstDraggedBlockIndex
    };
  }, [blockDropTarget, blockIndexes, firstDraggedBlockClientId]);
  const contextValue = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; ({
    blockDropPosition,
    blockDropTargetIndex,
    blockIndexes,
    draggedClientIds,
    expandedState,
    expand,
    firstDraggedBlockIndex,
    collapse,
    collapseAll,
    BlockSettingsMenu,
    listViewInstanceId: instanceId,
    AdditionalBlockContent,
    insertedBlock,
    setInsertedBlock,
    treeGridElementRef: elementRef,
    rootClientId
  }), [blockDropPosition, blockDropTargetIndex, blockIndexes, draggedClientIds, expandedState, expand, firstDraggedBlockIndex, collapse, collapseAll, BlockSettingsMenu, instanceId, AdditionalBlockContent, insertedBlock, setInsertedBlock, rootClientId]);

  // List View renders a fixed number of items and relies on each having a fixed item height of 36px.
  // If this value changes, we should also change the itemHeight value set in useFixedWindowList.
  // See: https://github.com/WordPress/gutenberg/pull/35230 for additional context.
  const [fixedListWindow] = (0,external_wp_compose_namespaceObject.__experimentalUseFixedWindowList)(elementRef, BLOCK_LIST_ITEM_HEIGHT, visibleBlockCount, {
    // Ensure that the windowing logic is recalculated when the expanded state changes.
    // This is necessary because expanding a collapsed block in a short list view can
    // switch the list view to a tall list view with a scrollbar, and vice versa.
    // When this happens, the windowing logic needs to be recalculated to ensure that
    // the correct number of blocks are rendered, by rechecking for a scroll container.
    expandedState,
    useWindowing: true,
    windowOverscan: 40
  });

  // If there are no blocks to show and we&#039;re not showing the appender, do not render the list view.
  if (!clientIdsTree.length &amp;&amp; !showAppender) {
    return null;
  }
  const describedById = description &amp;&amp; `block-editor-list-view-description-${instanceId}`;
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_data_namespaceObject.AsyncModeProvider, {
    value: true,
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ListViewDropIndicatorPreview, {
      draggedBlockClientId: firstDraggedBlockClientId,
      listViewRef: elementRef,
      blockDropTarget: blockDropTarget
    }), description &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.VisuallyHidden, {
      id: describedById,
      children: description
    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalTreeGrid, {
      id: id,
      className: dist_clsx(&#039;block-editor-list-view-tree&#039;, {
        &#039;is-dragging&#039;: draggedClientIds?.length &gt; 0 &amp;&amp; blockDropTargetIndex !== undefined
      }),
      &quot;aria-label&quot;: (0,external_wp_i18n_namespaceObject.__)(&#039;Block navigation structure&#039;),
      ref: treeGridRef,
      onCollapseRow: collapseRow,
      onExpandRow: expandRow,
      onFocusRow: focusRow,
      applicationAriaLabel: (0,external_wp_i18n_namespaceObject.__)(&#039;Block navigation structure&#039;),
      &quot;aria-describedby&quot;: describedById,
      style: {
        &#039;--wp-admin--list-view-dragged-items-height&#039;: draggedClientIds?.length ? `${BLOCK_LIST_ITEM_HEIGHT * (draggedClientIds.length - 1)}px` : null
      },
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ListViewContext.Provider, {
        value: contextValue,
        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(branch, {
          blocks: clientIdsTree,
          parentId: rootClientId,
          selectBlock: selectEditorBlock,
          showBlockMovers: showBlockMovers,
          fixedListWindow: fixedListWindow,
          selectedClientIds: selectedClientIds,
          isExpanded: isExpanded,
          showAppender: showAppender
        })
      })
    })]
  });
}

// This is the private API for the ListView component.
// It allows access to all props, not just the public ones.
const PrivateListView = (0,external_wp_element_namespaceObject.forwardRef)(ListViewComponent);

// This is the public API for the ListView component.
// We wrap the PrivateListView component to hide some props from the public API.
/* harmony default export */ const components_list_view = ((0,external_wp_element_namespaceObject.forwardRef)((props, ref) =&gt; {
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PrivateListView, {
    ref: ref,
    ...props,
    showAppender: false,
    rootClientId: null,
    onSelect: null,
    additionalBlockContent: null,
    blockSettingsMenu: undefined
  });
}));

;// ./node_modules/@wordpress/block-editor/build-module/components/block-navigation/dropdown.js
/**
 * WordPress dependencies
 */


/**
 * WordPress dependencies
 */






/**
 * Internal dependencies
 */



function BlockNavigationDropdownToggle({
  isEnabled,
  onToggle,
  isOpen,
  innerRef,
  ...props
}) {
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
    __next40pxDefaultSize: true,
    ...props,
    ref: innerRef,
    icon: list_view,
    &quot;aria-expanded&quot;: isOpen,
    &quot;aria-haspopup&quot;: &quot;true&quot;,
    onClick: isEnabled ? onToggle : undefined
    /* translators: button label text should, if possible, be under 16 characters. */,
    label: (0,external_wp_i18n_namespaceObject.__)(&#039;List view&#039;),
    className: &quot;block-editor-block-navigation&quot;,
    &quot;aria-disabled&quot;: !isEnabled
  });
}
function BlockNavigationDropdown({
  isDisabled,
  ...props
}, ref) {
  external_wp_deprecated_default()(&#039;wp.blockEditor.BlockNavigationDropdown&#039;, {
    since: &#039;6.1&#039;,
    alternative: &#039;wp.components.Dropdown and wp.blockEditor.ListView&#039;
  });
  const hasBlocks = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; !!select(store).getBlockCount(), []);
  const isEnabled = hasBlocks &amp;&amp; !isDisabled;
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Dropdown, {
    contentClassName: &quot;block-editor-block-navigation__popover&quot;,
    popoverProps: {
      placement: &#039;bottom-start&#039;
    },
    renderToggle: ({
      isOpen,
      onToggle
    }) =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockNavigationDropdownToggle, {
      ...props,
      innerRef: ref,
      isOpen: isOpen,
      onToggle: onToggle,
      isEnabled: isEnabled
    }),
    renderContent: () =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;div&quot;, {
      className: &quot;block-editor-block-navigation__container&quot;,
      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;p&quot;, {
        className: &quot;block-editor-block-navigation__label&quot;,
        children: (0,external_wp_i18n_namespaceObject.__)(&#039;List view&#039;)
      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(components_list_view, {})]
    })
  });
}
/* harmony default export */ const dropdown = ((0,external_wp_element_namespaceObject.forwardRef)(BlockNavigationDropdown));

;// ./node_modules/@wordpress/block-editor/build-module/components/block-styles/preview-panel.js
/**
 * WordPress dependencies
 */



/**
 * Internal dependencies
 */



function BlockStylesPreviewPanel({
  genericPreviewBlock,
  style,
  className,
  activeStyle
}) {
  const example = (0,external_wp_blocks_namespaceObject.getBlockType)(genericPreviewBlock.name)?.example;
  const styleClassName = replaceActiveStyle(className, activeStyle, style);
  const previewBlocks = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; {
    return {
      ...genericPreviewBlock,
      title: style.label || style.name,
      description: style.description,
      initialAttributes: {
        ...genericPreviewBlock.attributes,
        className: styleClassName + &#039; block-editor-block-styles__block-preview-container&#039;
      },
      example
    };
  }, [genericPreviewBlock, styleClassName]);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(preview_panel, {
    item: previewBlocks
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/block-styles/index.js
/**
 * External dependencies
 */


/**
 * WordPress dependencies
 */




/**
 * Internal dependencies
 */



const block_styles_noop = () =&gt; {};

// Block Styles component for the Settings Sidebar.
function BlockStyles({
  clientId,
  onSwitch = block_styles_noop,
  onHoverClassName = block_styles_noop
}) {
  const {
    onSelect,
    stylesToRender,
    activeStyle,
    genericPreviewBlock,
    className: previewClassName
  } = useStylesForBlocks({
    clientId,
    onSwitch
  });
  const [hoveredStyle, setHoveredStyle] = (0,external_wp_element_namespaceObject.useState)(null);
  const isMobileViewport = (0,external_wp_compose_namespaceObject.useViewportMatch)(&#039;medium&#039;, &#039;&lt;&#039;);
  if (!stylesToRender || stylesToRender.length === 0) {
    return null;
  }
  const debouncedSetHoveredStyle = (0,external_wp_compose_namespaceObject.debounce)(setHoveredStyle, 250);
  const onSelectStylePreview = style =&gt; {
    onSelect(style);
    onHoverClassName(null);
    setHoveredStyle(null);
    debouncedSetHoveredStyle.cancel();
  };
  const styleItemHandler = item =&gt; {
    var _item$name;
    if (hoveredStyle === item) {
      debouncedSetHoveredStyle.cancel();
      return;
    }
    debouncedSetHoveredStyle(item);
    onHoverClassName((_item$name = item?.name) !== null &amp;&amp; _item$name !== void 0 ? _item$name : null);
  };
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;div&quot;, {
    className: &quot;block-editor-block-styles&quot;,
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
      className: &quot;block-editor-block-styles__variants&quot;,
      children: stylesToRender.map(style =&gt; {
        const buttonText = style.label || style.name;
        return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
          __next40pxDefaultSize: true,
          className: dist_clsx(&#039;block-editor-block-styles__item&#039;, {
            &#039;is-active&#039;: activeStyle.name === style.name
          }),
          variant: &quot;secondary&quot;,
          label: buttonText,
          onMouseEnter: () =&gt; styleItemHandler(style),
          onFocus: () =&gt; styleItemHandler(style),
          onMouseLeave: () =&gt; styleItemHandler(null),
          onBlur: () =&gt; styleItemHandler(null),
          onClick: () =&gt; onSelectStylePreview(style),
          &quot;aria-current&quot;: activeStyle.name === style.name,
          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalTruncate, {
            numberOfLines: 1,
            className: &quot;block-editor-block-styles__item-text&quot;,
            children: buttonText
          })
        }, style.name);
      })
    }), hoveredStyle &amp;&amp; !isMobileViewport &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Popover, {
      placement: &quot;left-start&quot;,
      offset: 34,
      focusOnMount: false,
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
        className: &quot;block-editor-block-styles__preview-panel&quot;,
        onMouseLeave: () =&gt; styleItemHandler(null),
        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockStylesPreviewPanel, {
          activeStyle: activeStyle,
          className: previewClassName,
          genericPreviewBlock: genericPreviewBlock,
          style: hoveredStyle
        })
      })
    })]
  });
}
/* harmony default export */ const block_styles = (BlockStyles);

;// ./node_modules/@wordpress/icons/build-module/library/paragraph.js
/**
 * WordPress dependencies
 */


const paragraph = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;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&quot;
  })
});
/* harmony default export */ const library_paragraph = (paragraph);

;// ./node_modules/@wordpress/icons/build-module/library/heading-level-1.js
/**
 * WordPress dependencies
 */


const headingLevel1 = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;M17.6 7c-.6.9-1.5 1.7-2.6 2v1h2v7h2V7h-1.4zM11 11H7V7H5v10h2v-4h4v4h2V7h-2v4z&quot;
  })
});
/* harmony default export */ const heading_level_1 = (headingLevel1);

;// ./node_modules/@wordpress/icons/build-module/library/heading-level-2.js
/**
 * WordPress dependencies
 */


const headingLevel2 = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;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&quot;
  })
});
/* harmony default export */ const heading_level_2 = (headingLevel2);

;// ./node_modules/@wordpress/icons/build-module/library/heading-level-3.js
/**
 * WordPress dependencies
 */


const headingLevel3 = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;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&quot;
  })
});
/* harmony default export */ const heading_level_3 = (headingLevel3);

;// ./node_modules/@wordpress/icons/build-module/library/heading-level-4.js
/**
 * WordPress dependencies
 */


const headingLevel4 = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;M20 13V7h-3l-4 6v2h5v2h2v-2h1v-2h-1zm-2 0h-2.8L18 9v4zm-9-2H5V7H3v10h2v-4h4v4h2V7H9v4z&quot;
  })
});
/* harmony default export */ const heading_level_4 = (headingLevel4);

;// ./node_modules/@wordpress/icons/build-module/library/heading-level-5.js
/**
 * WordPress dependencies
 */


const headingLevel5 = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;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&quot;
  })
});
/* harmony default export */ const heading_level_5 = (headingLevel5);

;// ./node_modules/@wordpress/icons/build-module/library/heading-level-6.js
/**
 * WordPress dependencies
 */


const headingLevel6 = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;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&quot;
  })
});
/* harmony default export */ const heading_level_6 = (headingLevel6);

;// ./node_modules/@wordpress/block-editor/build-module/components/block-heading-level-dropdown/heading-level-icon.js
/**
 * WordPress dependencies
 */



/** @typedef {import(&#039;react&#039;).ComponentType} ComponentType */

/**
 * HeadingLevelIcon props.
 *
 * @typedef WPHeadingLevelIconProps
 *
 * @property {number} level The heading level to show an icon for.
 */

const LEVEL_TO_PATH = {
  0: library_paragraph,
  1: heading_level_1,
  2: heading_level_2,
  3: heading_level_3,
  4: heading_level_4,
  5: heading_level_5,
  6: heading_level_6
};

/**
 * Heading level icon.
 *
 * @param {WPHeadingLevelIconProps} props Component props.
 *
 * @return {?ComponentType} The icon.
 */
function HeadingLevelIcon({
  level
}) {
  if (LEVEL_TO_PATH[level]) {
    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Icon, {
      icon: LEVEL_TO_PATH[level]
    });
  }
  return null;
}

;// ./node_modules/@wordpress/block-editor/build-module/components/block-heading-level-dropdown/index.js
/**
 * WordPress dependencies
 */



/**
 * Internal dependencies
 */


const HEADING_LEVELS = [1, 2, 3, 4, 5, 6];
const block_heading_level_dropdown_POPOVER_PROPS = {
  className: &#039;block-library-heading-level-dropdown&#039;
};

/** @typedef {import(&#039;react&#039;).ComponentType} ComponentType */

/**
 * HeadingLevelDropdown props.
 *
 * @typedef WPHeadingLevelDropdownProps
 *
 * @property {number}     value    The chosen heading level.
 * @property {number[]}   options  An array of supported heading levels.
 * @property {()=&gt;number} onChange Function called with
 *                                 the selected value changes.
 */

/**
 * Dropdown for selecting a heading level (1 through 6) or paragraph (0).
 *
 * @param {WPHeadingLevelDropdownProps} props Component props.
 *
 * @return {ComponentType} The toolbar.
 */
function HeadingLevelDropdown({
  options = HEADING_LEVELS,
  value,
  onChange
}) {
  const validOptions = options.filter(option =&gt; option === 0 || HEADING_LEVELS.includes(option)).sort((a, b) =&gt; a - b); // Sorts numerically in ascending order;

  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarDropdownMenu, {
    popoverProps: block_heading_level_dropdown_POPOVER_PROPS,
    icon: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(HeadingLevelIcon, {
      level: value
    }),
    label: (0,external_wp_i18n_namespaceObject.__)(&#039;Change level&#039;),
    controls: validOptions.map(targetLevel =&gt; {
      const isActive = targetLevel === value;
      return {
        icon: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(HeadingLevelIcon, {
          level: targetLevel
        }),
        title: targetLevel === 0 ? (0,external_wp_i18n_namespaceObject.__)(&#039;Paragraph&#039;) : (0,external_wp_i18n_namespaceObject.sprintf)(
        // translators: %d: heading level e.g: &quot;1&quot;, &quot;2&quot;, &quot;3&quot;
        (0,external_wp_i18n_namespaceObject.__)(&#039;Heading %d&#039;), targetLevel),
        isActive,
        onClick() {
          onChange(targetLevel);
        },
        role: &#039;menuitemradio&#039;
      };
    })
  });
}

;// ./node_modules/@wordpress/icons/build-module/library/layout.js
/**
 * WordPress dependencies
 */


const layout_layout = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;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&quot;
  })
});
/* harmony default export */ const library_layout = (layout_layout);

;// ./node_modules/@wordpress/block-editor/build-module/components/block-variation-picker/index.js
/**
 * External dependencies
 */


/**
 * WordPress dependencies
 */




function BlockVariationPicker({
  icon = library_layout,
  label = (0,external_wp_i18n_namespaceObject.__)(&#039;Choose variation&#039;),
  instructions = (0,external_wp_i18n_namespaceObject.__)(&#039;Select a variation to start with:&#039;),
  variations,
  onSelect,
  allowSkip
}) {
  const classes = dist_clsx(&#039;block-editor-block-variation-picker&#039;, {
    &#039;has-many-variations&#039;: variations.length &gt; 4
  });
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.Placeholder, {
    icon: icon,
    label: label,
    instructions: instructions,
    className: classes,
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;ul&quot;, {
      className: &quot;block-editor-block-variation-picker__variations&quot;,
      role: &quot;list&quot;,
      &quot;aria-label&quot;: (0,external_wp_i18n_namespaceObject.__)(&#039;Block variations&#039;),
      children: variations.map(variation =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;li&quot;, {
        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
          __next40pxDefaultSize: true,
          variant: &quot;tertiary&quot;,
          icon: variation.icon &amp;&amp; variation.icon.src ? variation.icon.src : variation.icon,
          iconSize: 48,
          onClick: () =&gt; onSelect(variation),
          className: &quot;block-editor-block-variation-picker__variation&quot;,
          label: variation.description || variation.title
        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;span&quot;, {
          className: &quot;block-editor-block-variation-picker__variation-label&quot;,
          children: variation.title
        })]
      }, variation.name))
    }), allowSkip &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
      className: &quot;block-editor-block-variation-picker__skip&quot;,
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
        __next40pxDefaultSize: true,
        variant: &quot;link&quot;,
        onClick: () =&gt; onSelect(),
        children: (0,external_wp_i18n_namespaceObject.__)(&#039;Skip&#039;)
      })
    })]
  });
}
/* harmony default export */ const block_variation_picker = (BlockVariationPicker);

;// ./node_modules/@wordpress/block-editor/build-module/components/block-pattern-setup/constants.js
const VIEWMODES = {
  carousel: &#039;carousel&#039;,
  grid: &#039;grid&#039;
};

;// ./node_modules/@wordpress/block-editor/build-module/components/block-pattern-setup/setup-toolbar.js
/**
 * WordPress dependencies
 */




/**
 * Internal dependencies
 */


const Actions = ({
  onBlockPatternSelect
}) =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
  className: &quot;block-editor-block-pattern-setup__actions&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
    __next40pxDefaultSize: true,
    variant: &quot;primary&quot;,
    onClick: onBlockPatternSelect,
    children: (0,external_wp_i18n_namespaceObject.__)(&#039;Choose&#039;)
  })
});
const CarouselNavigation = ({
  handlePrevious,
  handleNext,
  activeSlide,
  totalSlides
}) =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;div&quot;, {
  className: &quot;block-editor-block-pattern-setup__navigation&quot;,
  children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
    size: &quot;compact&quot;,
    icon: (0,external_wp_i18n_namespaceObject.isRTL)() ? chevron_right : chevron_left,
    label: (0,external_wp_i18n_namespaceObject.__)(&#039;Previous pattern&#039;),
    onClick: handlePrevious,
    disabled: activeSlide === 0,
    accessibleWhenDisabled: true
  }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
    size: &quot;compact&quot;,
    icon: (0,external_wp_i18n_namespaceObject.isRTL)() ? chevron_left : chevron_right,
    label: (0,external_wp_i18n_namespaceObject.__)(&#039;Next pattern&#039;),
    onClick: handleNext,
    disabled: activeSlide === totalSlides - 1,
    accessibleWhenDisabled: true
  })]
});
const SetupToolbar = ({
  viewMode,
  setViewMode,
  handlePrevious,
  handleNext,
  activeSlide,
  totalSlides,
  onBlockPatternSelect
}) =&gt; {
  const isCarouselView = viewMode === VIEWMODES.carousel;
  const displayControls = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;div&quot;, {
    className: &quot;block-editor-block-pattern-setup__display-controls&quot;,
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
      size: &quot;compact&quot;,
      icon: stretch_full_width,
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Carousel view&#039;),
      onClick: () =&gt; setViewMode(VIEWMODES.carousel),
      isPressed: isCarouselView
    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
      size: &quot;compact&quot;,
      icon: library_grid,
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Grid view&#039;),
      onClick: () =&gt; setViewMode(VIEWMODES.grid),
      isPressed: viewMode === VIEWMODES.grid
    })]
  });
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;div&quot;, {
    className: &quot;block-editor-block-pattern-setup__toolbar&quot;,
    children: [isCarouselView &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(CarouselNavigation, {
      handlePrevious: handlePrevious,
      handleNext: handleNext,
      activeSlide: activeSlide,
      totalSlides: totalSlides
    }), displayControls, isCarouselView &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Actions, {
      onBlockPatternSelect: onBlockPatternSelect
    })]
  });
};
/* harmony default export */ const setup_toolbar = (SetupToolbar);

;// ./node_modules/@wordpress/block-editor/build-module/components/block-pattern-setup/use-patterns-setup.js
/**
 * WordPress dependencies
 */


/**
 * Internal dependencies
 */

function usePatternsSetup(clientId, blockName, filterPatternsFn) {
  return (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      getBlockRootClientId,
      getPatternsByBlockTypes,
      __experimentalGetAllowedPatterns
    } = select(store);
    const rootClientId = getBlockRootClientId(clientId);
    if (filterPatternsFn) {
      return __experimentalGetAllowedPatterns(rootClientId).filter(filterPatternsFn);
    }
    return getPatternsByBlockTypes(blockName, rootClientId);
  }, [clientId, blockName, filterPatternsFn]);
}
/* harmony default export */ const use_patterns_setup = (usePatternsSetup);

;// ./node_modules/@wordpress/block-editor/build-module/components/block-pattern-setup/index.js
/**
 * WordPress dependencies
 */







/**
 * Internal dependencies
 */






const SetupContent = ({
  viewMode,
  activeSlide,
  patterns,
  onBlockPatternSelect,
  showTitles
}) =&gt; {
  const containerClass = &#039;block-editor-block-pattern-setup__container&#039;;
  if (viewMode === VIEWMODES.carousel) {
    const slideClass = new Map([[activeSlide, &#039;active-slide&#039;], [activeSlide - 1, &#039;previous-slide&#039;], [activeSlide + 1, &#039;next-slide&#039;]]);
    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
      className: &quot;block-editor-block-pattern-setup__carousel&quot;,
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
        className: containerClass,
        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
          className: &quot;carousel-container&quot;,
          children: patterns.map((pattern, index) =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockPatternSlide, {
            active: index === activeSlide,
            className: slideClass.get(index) || &#039;&#039;,
            pattern: pattern
          }, pattern.name))
        })
      })
    });
  }
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
    className: &quot;block-editor-block-pattern-setup__grid&quot;,
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Composite, {
      role: &quot;listbox&quot;,
      className: containerClass,
      &quot;aria-label&quot;: (0,external_wp_i18n_namespaceObject.__)(&#039;Patterns list&#039;),
      children: patterns.map(pattern =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_pattern_setup_BlockPattern, {
        pattern: pattern,
        onSelect: onBlockPatternSelect,
        showTitles: showTitles
      }, pattern.name))
    })
  });
};
function block_pattern_setup_BlockPattern({
  pattern,
  onSelect,
  showTitles
}) {
  const baseClassName = &#039;block-editor-block-pattern-setup-list&#039;;
  const {
    blocks,
    description,
    viewportWidth = 700
  } = pattern;
  const descriptionId = (0,external_wp_compose_namespaceObject.useInstanceId)(block_pattern_setup_BlockPattern, `${baseClassName}__item-description`);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
    className: `${baseClassName}__list-item`,
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.Composite.Item, {
      render: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
        &quot;aria-describedby&quot;: description ? descriptionId : undefined,
        &quot;aria-label&quot;: pattern.title,
        className: `${baseClassName}__item`
      }),
      id: `${baseClassName}__pattern__${pattern.name}`,
      role: &quot;option&quot;,
      onClick: () =&gt; onSelect(blocks),
      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_preview, {
        blocks: blocks,
        viewportWidth: viewportWidth
      }), showTitles &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
        className: `${baseClassName}__item-title`,
        children: pattern.title
      }), !!description &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.VisuallyHidden, {
        id: descriptionId,
        children: description
      })]
    })
  });
}
function BlockPatternSlide({
  active,
  className,
  pattern,
  minHeight
}) {
  const {
    blocks,
    title,
    description
  } = pattern;
  const descriptionId = (0,external_wp_compose_namespaceObject.useInstanceId)(BlockPatternSlide, &#039;block-editor-block-pattern-setup-list__item-description&#039;);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;div&quot;, {
    &quot;aria-hidden&quot;: !active,
    role: &quot;img&quot;,
    className: `pattern-slide ${className}`,
    &quot;aria-label&quot;: title,
    &quot;aria-describedby&quot;: description ? descriptionId : undefined,
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_preview, {
      blocks: blocks,
      minHeight: minHeight
    }), !!description &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.VisuallyHidden, {
      id: descriptionId,
      children: description
    })]
  });
}
const BlockPatternSetup = ({
  clientId,
  blockName,
  filterPatternsFn,
  onBlockPatternSelect,
  initialViewMode = VIEWMODES.carousel,
  showTitles = false
}) =&gt; {
  const [viewMode, setViewMode] = (0,external_wp_element_namespaceObject.useState)(initialViewMode);
  const [activeSlide, setActiveSlide] = (0,external_wp_element_namespaceObject.useState)(0);
  const {
    replaceBlock
  } = (0,external_wp_data_namespaceObject.useDispatch)(store);
  const patterns = use_patterns_setup(clientId, blockName, filterPatternsFn);
  if (!patterns?.length) {
    return null;
  }
  const onBlockPatternSelectDefault = blocks =&gt; {
    const clonedBlocks = blocks.map(block =&gt; (0,external_wp_blocks_namespaceObject.cloneBlock)(block));
    replaceBlock(clientId, clonedBlocks);
  };
  const onPatternSelectCallback = onBlockPatternSelect || onBlockPatternSelectDefault;
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_ReactJSXRuntime_namespaceObject.Fragment, {
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;div&quot;, {
      className: `block-editor-block-pattern-setup view-mode-${viewMode}`,
      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(SetupContent, {
        viewMode: viewMode,
        activeSlide: activeSlide,
        patterns: patterns,
        onBlockPatternSelect: onPatternSelectCallback,
        showTitles: showTitles
      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(setup_toolbar, {
        viewMode: viewMode,
        setViewMode: setViewMode,
        activeSlide: activeSlide,
        totalSlides: patterns.length,
        handleNext: () =&gt; {
          setActiveSlide(active =&gt; Math.min(active + 1, patterns.length - 1));
        },
        handlePrevious: () =&gt; {
          setActiveSlide(active =&gt; Math.max(active - 1, 0));
        },
        onBlockPatternSelect: () =&gt; {
          onPatternSelectCallback(patterns[activeSlide].blocks);
        }
      })]
    })
  });
};
/* harmony default export */ const block_pattern_setup = (BlockPatternSetup);

;// ./node_modules/@wordpress/block-editor/build-module/components/block-variation-transforms/index.js
/**
 * WordPress dependencies
 */







/**
 * Internal dependencies
 */




function VariationsButtons({
  className,
  onSelectVariation,
  selectedValue,
  variations
}) {
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;fieldset&quot;, {
    className: className,
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.VisuallyHidden, {
      as: &quot;legend&quot;,
      children: (0,external_wp_i18n_namespaceObject.__)(&#039;Transform to variation&#039;)
    }), variations.map(variation =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
      __next40pxDefaultSize: true,
      size: &quot;compact&quot;,
      icon: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_icon, {
        icon: variation.icon,
        showColors: true
      }),
      isPressed: selectedValue === variation.name,
      label: selectedValue === variation.name ? variation.title : (0,external_wp_i18n_namespaceObject.sprintf)(/* translators: %s: Block or block variation name. */
      (0,external_wp_i18n_namespaceObject.__)(&#039;Transform to %s&#039;), variation.title),
      onClick: () =&gt; onSelectVariation(variation.name),
      &quot;aria-label&quot;: variation.title,
      showTooltip: true
    }, variation.name))]
  });
}
function VariationsDropdown({
  className,
  onSelectVariation,
  selectedValue,
  variations
}) {
  const selectOptions = variations.map(({
    name,
    title,
    description
  }) =&gt; ({
    value: name,
    label: title,
    info: description
  }));
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.DropdownMenu, {
    className: className,
    label: (0,external_wp_i18n_namespaceObject.__)(&#039;Transform to variation&#039;),
    text: (0,external_wp_i18n_namespaceObject.__)(&#039;Transform to variation&#039;),
    popoverProps: {
      position: &#039;bottom center&#039;,
      className: `${className}__popover`
    },
    icon: chevron_down,
    toggleProps: {
      iconPosition: &#039;right&#039;
    },
    children: () =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
      className: `${className}__container`,
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuGroup, {
        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItemsChoice, {
          choices: selectOptions,
          value: selectedValue,
          onSelect: onSelectVariation
        })
      })
    })
  });
}
function VariationsToggleGroupControl({
  className,
  onSelectVariation,
  selectedValue,
  variations
}) {
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
    className: className,
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControl, {
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Transform to variation&#039;),
      value: selectedValue,
      hideLabelFromVision: true,
      onChange: onSelectVariation,
      __next40pxDefaultSize: true,
      __nextHasNoMarginBottom: true,
      children: variations.map(variation =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControlOptionIcon, {
        icon: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_icon, {
          icon: variation.icon,
          showColors: true
        }),
        value: variation.name,
        label: selectedValue === variation.name ? variation.title : (0,external_wp_i18n_namespaceObject.sprintf)(/* translators: %s: Block or block variation name. */
        (0,external_wp_i18n_namespaceObject.__)(&#039;Transform to %s&#039;), variation.title)
      }, variation.name))
    })
  });
}
function __experimentalBlockVariationTransforms({
  blockClientId
}) {
  const {
    updateBlockAttributes
  } = (0,external_wp_data_namespaceObject.useDispatch)(store);
  const {
    activeBlockVariation,
    variations,
    isContentOnly
  } = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      getActiveBlockVariation,
      getBlockVariations
    } = select(external_wp_blocks_namespaceObject.store);
    const {
      getBlockName,
      getBlockAttributes,
      getBlockEditingMode
    } = select(store);
    const name = blockClientId &amp;&amp; getBlockName(blockClientId);
    const {
      hasContentRoleAttribute
    } = unlock(select(external_wp_blocks_namespaceObject.store));
    const isContentBlock = hasContentRoleAttribute(name);
    return {
      activeBlockVariation: getActiveBlockVariation(name, getBlockAttributes(blockClientId)),
      variations: name &amp;&amp; getBlockVariations(name, &#039;transform&#039;),
      isContentOnly: getBlockEditingMode(blockClientId) === &#039;contentOnly&#039; &amp;&amp; !isContentBlock
    };
  }, [blockClientId]);
  const selectedValue = activeBlockVariation?.name;

  // Check if each variation has a unique icon.
  const hasUniqueIcons = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; {
    const variationIcons = new Set();
    if (!variations) {
      return false;
    }
    variations.forEach(variation =&gt; {
      if (variation.icon) {
        variationIcons.add(variation.icon?.src || variation.icon);
      }
    });
    return variationIcons.size === variations.length;
  }, [variations]);
  const onSelectVariation = variationName =&gt; {
    updateBlockAttributes(blockClientId, {
      ...variations.find(({
        name
      }) =&gt; name === variationName).attributes
    });
  };
  if (!variations?.length || isContentOnly) {
    return null;
  }
  const baseClass = &#039;block-editor-block-variation-transforms&#039;;

  // Show buttons if there are more than 5 variations because the ToggleGroupControl does not wrap
  const showButtons = variations.length &gt; 5;
  const ButtonComponent = showButtons ? VariationsButtons : VariationsToggleGroupControl;
  const Component = hasUniqueIcons ? ButtonComponent : VariationsDropdown;
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Component, {
    className: baseClass,
    onSelectVariation: onSelectVariation,
    selectedValue: selectedValue,
    variations: variations
  });
}
/* harmony default export */ const block_variation_transforms = (__experimentalBlockVariationTransforms);

;// ./node_modules/@wordpress/block-editor/build-module/components/color-palette/with-color-context.js
/**
 * WordPress dependencies
 */


/**
 * Internal dependencies
 */


/* harmony default export */ const with_color_context = ((0,external_wp_compose_namespaceObject.createHigherOrderComponent)(WrappedComponent =&gt; {
  return props =&gt; {
    // Get the default colors, theme colors, and custom colors
    const [defaultColors, themeColors, customColors, enableCustomColors, enableDefaultColors] = use_settings_useSettings(&#039;color.palette.default&#039;, &#039;color.palette.theme&#039;, &#039;color.palette.custom&#039;, &#039;color.custom&#039;, &#039;color.defaultPalette&#039;);
    const _colors = enableDefaultColors ? [...(themeColors || []), ...(defaultColors || []), ...(customColors || [])] : [...(themeColors || []), ...(customColors || [])];
    const {
      colors = _colors,
      disableCustomColors = !enableCustomColors
    } = props;
    const hasColorsToChoose = colors &amp;&amp; colors.length &gt; 0 || !disableCustomColors;
    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(WrappedComponent, {
      ...props,
      colors,
      disableCustomColors,
      hasColorsToChoose
    });
  };
}, &#039;withColorContext&#039;));

;// ./node_modules/@wordpress/block-editor/build-module/components/color-palette/index.js
/**
 * WordPress dependencies
 */


/**
 * Internal dependencies
 */

/* harmony default export */ const color_palette = (with_color_context(external_wp_components_namespaceObject.ColorPalette));

;// ./node_modules/@wordpress/block-editor/build-module/components/color-palette/control.js
/**
 * Internal dependencies
 */


function ColorPaletteControl({
  onChange,
  value,
  ...otherProps
}) {
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(control, {
    ...otherProps,
    onColorChange: onChange,
    colorValue: value,
    gradients: [],
    disableCustomGradients: true
  });
}

;// external [&quot;wp&quot;,&quot;date&quot;]
const external_wp_date_namespaceObject = window[&quot;wp&quot;][&quot;date&quot;];
;// ./node_modules/@wordpress/block-editor/build-module/components/date-format-picker/index.js
/**
 * WordPress dependencies
 */





// So that we illustrate the different formats in the dropdown properly, show a date that is
// somewhat recent, has a day greater than 12, and a month with more than three letters.

const exampleDate = new Date();
exampleDate.setDate(20);
exampleDate.setMonth(exampleDate.getMonth() - 3);
if (exampleDate.getMonth() === 4) {
  // May has three letters, so use March.
  exampleDate.setMonth(3);
}

/**
 * The `DateFormatPicker` component renders controls that let the user choose a
 * _date format_. That is, how they want their dates to be formatted.
 *
 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/date-format-picker/README.md
 *
 * @param {Object}      props
 * @param {string|null} props.format        The selected date format. If `null`, _Default_ is selected.
 * @param {string}      props.defaultFormat The date format that will be used if the user selects &#039;Default&#039;.
 * @param {Function}    props.onChange      Called when a selection is made. If `null`, _Default_ is selected.
 */
function DateFormatPicker({
  format,
  defaultFormat,
  onChange
}) {
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalVStack, {
    as: &quot;fieldset&quot;,
    spacing: 4,
    className: &quot;block-editor-date-format-picker&quot;,
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.VisuallyHidden, {
      as: &quot;legend&quot;,
      children: (0,external_wp_i18n_namespaceObject.__)(&#039;Date format&#039;)
    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToggleControl, {
      __nextHasNoMarginBottom: true,
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Default format&#039;),
      help: `${(0,external_wp_i18n_namespaceObject.__)(&#039;Example:&#039;)}  ${(0,external_wp_date_namespaceObject.dateI18n)(defaultFormat, exampleDate)}`,
      checked: !format,
      onChange: checked =&gt; onChange(checked ? null : defaultFormat)
    }), format &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(NonDefaultControls, {
      format: format,
      onChange: onChange
    })]
  });
}
function NonDefaultControls({
  format,
  onChange
}) {
  var _suggestedOptions$fin;
  // Suggest a short format, medium format, long format, and a standardised
  // (YYYY-MM-DD) format. The short, medium, and long formats are localised as
  // different languages have different ways of writing these. For example, &#039;F
  // j, Y&#039; (April 20, 2022) in American English (en_US) is &#039;j. F Y&#039; (20. April
  // 2022) in German (de). The resultant array is de-duplicated as some
  // languages will use the same format string for short, medium, and long
  // formats.
  const suggestedFormats = [...new Set([/* translators: See https://www.php.net/manual/datetime.format.php */
  &#039;Y-m-d&#039;, /* translators: See https://www.php.net/manual/datetime.format.php */
  (0,external_wp_i18n_namespaceObject._x)(&#039;n/j/Y&#039;, &#039;short date format&#039;), /* translators: See https://www.php.net/manual/datetime.format.php */
  (0,external_wp_i18n_namespaceObject._x)(&#039;n/j/Y g:i A&#039;, &#039;short date format with time&#039;), /* translators: See https://www.php.net/manual/datetime.format.php */
  (0,external_wp_i18n_namespaceObject._x)(&#039;M j, Y&#039;, &#039;medium date format&#039;), /* translators: See https://www.php.net/manual/datetime.format.php */
  (0,external_wp_i18n_namespaceObject._x)(&#039;M j, Y g:i A&#039;, &#039;medium date format with time&#039;), /* translators: See https://www.php.net/manual/datetime.format.php */
  (0,external_wp_i18n_namespaceObject._x)(&#039;F j, Y&#039;, &#039;long date format&#039;), /* translators: See https://www.php.net/manual/datetime.format.php */
  (0,external_wp_i18n_namespaceObject._x)(&#039;M j&#039;, &#039;short date format without the year&#039;)])];
  const suggestedOptions = [...suggestedFormats.map((suggestedFormat, index) =&gt; ({
    key: `suggested-${index}`,
    name: (0,external_wp_date_namespaceObject.dateI18n)(suggestedFormat, exampleDate),
    format: suggestedFormat
  })), {
    key: &#039;human-diff&#039;,
    name: (0,external_wp_date_namespaceObject.humanTimeDiff)(exampleDate),
    format: &#039;human-diff&#039;
  }];
  const customOption = {
    key: &#039;custom&#039;,
    name: (0,external_wp_i18n_namespaceObject.__)(&#039;Custom&#039;),
    className: &#039;block-editor-date-format-picker__custom-format-select-control__custom-option&#039;,
    hint: (0,external_wp_i18n_namespaceObject.__)(&#039;Enter your own date format&#039;)
  };
  const [isCustom, setIsCustom] = (0,external_wp_element_namespaceObject.useState)(() =&gt; !!format &amp;&amp; !suggestedOptions.some(option =&gt; option.format === format));
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalVStack, {
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.CustomSelectControl, {
      __next40pxDefaultSize: true,
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Choose a format&#039;),
      options: [...suggestedOptions, customOption],
      value: isCustom ? customOption : (_suggestedOptions$fin = suggestedOptions.find(option =&gt; option.format === format)) !== null &amp;&amp; _suggestedOptions$fin !== void 0 ? _suggestedOptions$fin : customOption,
      onChange: ({
        selectedItem
      }) =&gt; {
        if (selectedItem === customOption) {
          setIsCustom(true);
        } else {
          setIsCustom(false);
          onChange(selectedItem.format);
        }
      }
    }), isCustom &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.TextControl, {
      __next40pxDefaultSize: true,
      __nextHasNoMarginBottom: true,
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Custom format&#039;),
      hideLabelFromVision: true,
      help: (0,external_wp_element_namespaceObject.createInterpolateElement)((0,external_wp_i18n_namespaceObject.__)(&#039;Enter a date or time &lt;Link&gt;format string&lt;/Link&gt;.&#039;), {
        Link: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ExternalLink, {
          href: (0,external_wp_i18n_namespaceObject.__)(&#039;https://wordpress.org/documentation/article/customize-date-and-time-format/&#039;)
        })
      }),
      value: format,
      onChange: value =&gt; onChange(value)
    })]
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/colors-gradients/dropdown.js
/**
 * External dependencies
 */


/**
 * WordPress dependencies
 */




/**
 * Internal dependencies
 */


/**
 * Internal dependencies
 */


// When the `ColorGradientSettingsDropdown` controls are being rendered to a
// `ToolsPanel` they must be wrapped in a `ToolsPanelItem`.

const WithToolsPanelItem = ({
  setting,
  children,
  panelId,
  ...props
}) =&gt; {
  const clearValue = () =&gt; {
    if (setting.colorValue) {
      setting.onColorChange();
    } else if (setting.gradientValue) {
      setting.onGradientChange();
    }
  };
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanelItem, {
    hasValue: () =&gt; {
      return !!setting.colorValue || !!setting.gradientValue;
    },
    label: setting.label,
    onDeselect: clearValue,
    isShownByDefault: setting.isShownByDefault !== undefined ? setting.isShownByDefault : true,
    ...props,
    className: &quot;block-editor-tools-panel-color-gradient-settings__item&quot;,
    panelId: panelId
    // Pass resetAllFilter if supplied due to rendering via SlotFill
    // into parent ToolsPanel.
    ,
    resetAllFilter: setting.resetAllFilter,
    children: children
  });
};
const dropdown_LabeledColorIndicator = ({
  colorValue,
  label
}) =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalHStack, {
  justify: &quot;flex-start&quot;,
  children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ColorIndicator, {
    className: &quot;block-editor-panel-color-gradient-settings__color-indicator&quot;,
    colorValue: colorValue
  }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FlexItem, {
    className: &quot;block-editor-panel-color-gradient-settings__color-name&quot;,
    title: label,
    children: label
  })]
});

// Renders a color dropdown&#039;s toggle as an `Item` if it is within an `ItemGroup`
// or as a `Button` if it isn&#039;t e.g. the controls are being rendered in
// a `ToolsPanel`.
const dropdown_renderToggle = settings =&gt; ({
  onToggle,
  isOpen
}) =&gt; {
  const {
    clearable,
    colorValue,
    gradientValue,
    onColorChange,
    onGradientChange,
    label
  } = settings;
  const colorButtonRef = (0,external_wp_element_namespaceObject.useRef)(undefined);
  const toggleProps = {
    onClick: onToggle,
    className: dist_clsx(&#039;block-editor-panel-color-gradient-settings__dropdown&#039;, {
      &#039;is-open&#039;: isOpen
    }),
    &#039;aria-expanded&#039;: isOpen,
    ref: colorButtonRef
  };
  const clearValue = () =&gt; {
    if (colorValue) {
      onColorChange();
    } else if (gradientValue) {
      onGradientChange();
    }
  };
  const value = colorValue !== null &amp;&amp; colorValue !== void 0 ? colorValue : gradientValue;
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
      __next40pxDefaultSize: true,
      ...toggleProps,
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(dropdown_LabeledColorIndicator, {
        colorValue: value,
        label: label
      })
    }), clearable &amp;&amp; value &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
      __next40pxDefaultSize: true,
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Reset&#039;),
      className: &quot;block-editor-panel-color-gradient-settings__reset&quot;,
      size: &quot;small&quot;,
      icon: library_reset,
      onClick: () =&gt; {
        clearValue();
        if (isOpen) {
          onToggle();
        }
        // Return focus to parent button
        colorButtonRef.current?.focus();
      }
    })]
  });
};

// Renders a collection of color controls as dropdowns. Depending upon the
// context in which these dropdowns are being rendered, they may be wrapped
// in an `ItemGroup` with each dropdown&#039;s toggle as an `Item`, or alternatively,
// the may be individually wrapped in a `ToolsPanelItem` with the toggle as
// a regular `Button`.
//
// For more context see: https://github.com/WordPress/gutenberg/pull/40084
function ColorGradientSettingsDropdown({
  colors,
  disableCustomColors,
  disableCustomGradients,
  enableAlpha,
  gradients,
  settings,
  __experimentalIsRenderedInSidebar,
  ...props
}) {
  let popoverProps;
  if (__experimentalIsRenderedInSidebar) {
    popoverProps = {
      placement: &#039;left-start&#039;,
      offset: 36,
      shift: true
    };
  }
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_ReactJSXRuntime_namespaceObject.Fragment, {
    children: settings.map((setting, index) =&gt; {
      const controlProps = {
        clearable: false,
        colorValue: setting.colorValue,
        colors,
        disableCustomColors,
        disableCustomGradients,
        enableAlpha,
        gradientValue: setting.gradientValue,
        gradients,
        label: setting.label,
        onColorChange: setting.onColorChange,
        onGradientChange: setting.onGradientChange,
        showTitle: false,
        __experimentalIsRenderedInSidebar,
        ...setting
      };
      const toggleSettings = {
        clearable: setting.clearable,
        label: setting.label,
        colorValue: setting.colorValue,
        gradientValue: setting.gradientValue,
        onColorChange: setting.onColorChange,
        onGradientChange: setting.onGradientChange
      };
      return setting &amp;&amp;
      /*#__PURE__*/
      // If not in an `ItemGroup` wrap the dropdown in a
      // `ToolsPanelItem`
      (0,external_ReactJSXRuntime_namespaceObject.jsx)(WithToolsPanelItem, {
        setting: setting,
        ...props,
        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Dropdown, {
          popoverProps: popoverProps,
          className: &quot;block-editor-tools-panel-color-gradient-settings__dropdown&quot;,
          renderToggle: dropdown_renderToggle(toggleSettings),
          renderContent: () =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalDropdownContentWrapper, {
            paddingSize: &quot;none&quot;,
            children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
              className: &quot;block-editor-panel-color-gradient-settings__dropdown-content&quot;,
              children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(control, {
                ...controlProps
              })
            })
          })
        })
      }, index);
    })
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/colors-gradients/panel-color-gradient-settings.js
/**
 * External dependencies
 */


/**
 * WordPress dependencies
 */




/**
 * Internal dependencies
 */



const panel_color_gradient_settings_colorsAndGradientKeys = [&#039;colors&#039;, &#039;disableCustomColors&#039;, &#039;gradients&#039;, &#039;disableCustomGradients&#039;];
const PanelColorGradientSettingsInner = ({
  className,
  colors,
  gradients,
  disableCustomColors,
  disableCustomGradients,
  children,
  settings,
  title,
  showTitle = true,
  __experimentalIsRenderedInSidebar,
  enableAlpha
}) =&gt; {
  const panelId = (0,external_wp_compose_namespaceObject.useInstanceId)(PanelColorGradientSettingsInner);
  const {
    batch
  } = (0,external_wp_data_namespaceObject.useRegistry)();
  if ((!colors || colors.length === 0) &amp;&amp; (!gradients || gradients.length === 0) &amp;&amp; disableCustomColors &amp;&amp; disableCustomGradients &amp;&amp; settings?.every(setting =&gt; (!setting.colors || setting.colors.length === 0) &amp;&amp; (!setting.gradients || setting.gradients.length === 0) &amp;&amp; (setting.disableCustomColors === undefined || setting.disableCustomColors) &amp;&amp; (setting.disableCustomGradients === undefined || setting.disableCustomGradients))) {
    return null;
  }
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalToolsPanel, {
    className: dist_clsx(&#039;block-editor-panel-color-gradient-settings&#039;, className),
    label: showTitle ? title : undefined,
    resetAll: () =&gt; {
      batch(() =&gt; {
        settings.forEach(({
          colorValue,
          gradientValue,
          onColorChange,
          onGradientChange
        }) =&gt; {
          if (colorValue) {
            onColorChange();
          } else if (gradientValue) {
            onGradientChange();
          }
        });
      });
    },
    panelId: panelId,
    __experimentalFirstVisibleItemClass: &quot;first&quot;,
    __experimentalLastVisibleItemClass: &quot;last&quot;,
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ColorGradientSettingsDropdown, {
      settings: settings,
      panelId: panelId,
      colors,
      gradients,
      disableCustomColors,
      disableCustomGradients,
      __experimentalIsRenderedInSidebar,
      enableAlpha
    }), !!children &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalSpacer, {
        marginY: 4
      }), &quot; &quot;, children]
    })]
  });
};
const PanelColorGradientSettingsSelect = props =&gt; {
  const colorGradientSettings = useMultipleOriginColorsAndGradients();
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PanelColorGradientSettingsInner, {
    ...colorGradientSettings,
    ...props
  });
};
const PanelColorGradientSettings = props =&gt; {
  if (panel_color_gradient_settings_colorsAndGradientKeys.every(key =&gt; props.hasOwnProperty(key))) {
    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PanelColorGradientSettingsInner, {
      ...props
    });
  }
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PanelColorGradientSettingsSelect, {
    ...props
  });
};
/* harmony default export */ const panel_color_gradient_settings = (PanelColorGradientSettings);

;// ./node_modules/@wordpress/icons/build-module/library/aspect-ratio.js
/**
 * WordPress dependencies
 */


const aspectRatio = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;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&quot;
  })
});
/* harmony default export */ const aspect_ratio = (aspectRatio);

;// ./node_modules/@wordpress/block-editor/build-module/components/image-editor/constants.js
const MIN_ZOOM = 100;
const MAX_ZOOM = 300;
const constants_POPOVER_PROPS = {
  placement: &#039;bottom-start&#039;
};

;// ./node_modules/@wordpress/block-editor/build-module/components/image-editor/use-save-image.js
/**
 * WordPress dependencies
 */
// Disable Reason: Needs to be refactored.
// eslint-disable-next-line no-restricted-imports






const messages = {
  crop: (0,external_wp_i18n_namespaceObject.__)(&#039;Image cropped.&#039;),
  rotate: (0,external_wp_i18n_namespaceObject.__)(&#039;Image rotated.&#039;),
  cropAndRotate: (0,external_wp_i18n_namespaceObject.__)(&#039;Image cropped and rotated.&#039;)
};
function useSaveImage({
  crop,
  rotation,
  url,
  id,
  onSaveImage,
  onFinishEditing
}) {
  const {
    createErrorNotice,
    createSuccessNotice
  } = (0,external_wp_data_namespaceObject.useDispatch)(external_wp_notices_namespaceObject.store);
  const [isInProgress, setIsInProgress] = (0,external_wp_element_namespaceObject.useState)(false);
  const cancel = (0,external_wp_element_namespaceObject.useCallback)(() =&gt; {
    setIsInProgress(false);
    onFinishEditing();
  }, [onFinishEditing]);
  const apply = (0,external_wp_element_namespaceObject.useCallback)(() =&gt; {
    setIsInProgress(true);
    const modifiers = [];
    if (rotation &gt; 0) {
      modifiers.push({
        type: &#039;rotate&#039;,
        args: {
          angle: rotation
        }
      });
    }

    // The crop script may return some very small, sub-pixel values when the image was not cropped.
    // Crop only when the new size has changed by more than 0.1%.
    if (crop.width &lt; 99.9 || crop.height &lt; 99.9) {
      modifiers.push({
        type: &#039;crop&#039;,
        args: {
          left: crop.x,
          top: crop.y,
          width: crop.width,
          height: crop.height
        }
      });
    }
    if (modifiers.length === 0) {
      // No changes to apply.
      setIsInProgress(false);
      onFinishEditing();
      return;
    }
    const modifierType = modifiers.length === 1 ? modifiers[0].type : &#039;cropAndRotate&#039;;
    external_wp_apiFetch_default()({
      path: `/wp/v2/media/${id}/edit`,
      method: &#039;POST&#039;,
      data: {
        src: url,
        modifiers
      }
    }).then(response =&gt; {
      onSaveImage({
        id: response.id,
        url: response.source_url
      });
      createSuccessNotice(messages[modifierType], {
        type: &#039;snackbar&#039;,
        actions: [{
          label: (0,external_wp_i18n_namespaceObject.__)(&#039;Undo&#039;),
          onClick: () =&gt; {
            onSaveImage({
              id,
              url
            });
          }
        }]
      });
    }).catch(error =&gt; {
      createErrorNotice((0,external_wp_i18n_namespaceObject.sprintf)(/* translators: %s: Error message. */
      (0,external_wp_i18n_namespaceObject.__)(&#039;Could not edit image. %s&#039;), (0,external_wp_dom_namespaceObject.__unstableStripHTML)(error.message)), {
        id: &#039;image-editing-error&#039;,
        type: &#039;snackbar&#039;
      });
    }).finally(() =&gt; {
      setIsInProgress(false);
      onFinishEditing();
    });
  }, [crop, rotation, id, url, onSaveImage, createErrorNotice, createSuccessNotice, onFinishEditing]);
  return (0,external_wp_element_namespaceObject.useMemo)(() =&gt; ({
    isInProgress,
    apply,
    cancel
  }), [isInProgress, apply, cancel]);
}

;// ./node_modules/@wordpress/block-editor/build-module/components/image-editor/use-transform-image.js
/* wp:polyfill */
/**
 * WordPress dependencies
 */


function useTransformImage({
  url,
  naturalWidth,
  naturalHeight
}) {
  const [editedUrl, setEditedUrl] = (0,external_wp_element_namespaceObject.useState)();
  const [crop, setCrop] = (0,external_wp_element_namespaceObject.useState)();
  const [position, setPosition] = (0,external_wp_element_namespaceObject.useState)({
    x: 0,
    y: 0
  });
  const [zoom, setZoom] = (0,external_wp_element_namespaceObject.useState)(100);
  const [rotation, setRotation] = (0,external_wp_element_namespaceObject.useState)(0);
  const defaultAspect = naturalWidth / naturalHeight;
  const [aspect, setAspect] = (0,external_wp_element_namespaceObject.useState)(defaultAspect);
  const rotateClockwise = (0,external_wp_element_namespaceObject.useCallback)(() =&gt; {
    const angle = (rotation + 90) % 360;
    let naturalAspectRatio = defaultAspect;
    if (rotation % 180 === 90) {
      naturalAspectRatio = 1 / defaultAspect;
    }
    if (angle === 0) {
      setEditedUrl();
      setRotation(angle);
      setAspect(defaultAspect);
      setPosition(prevPosition =&gt; ({
        x: -(prevPosition.y * naturalAspectRatio),
        y: prevPosition.x * naturalAspectRatio
      }));
      return;
    }
    function editImage(event) {
      const canvas = document.createElement(&#039;canvas&#039;);
      let translateX = 0;
      let translateY = 0;
      if (angle % 180) {
        canvas.width = event.target.height;
        canvas.height = event.target.width;
      } else {
        canvas.width = event.target.width;
        canvas.height = event.target.height;
      }
      if (angle === 90 || angle === 180) {
        translateX = canvas.width;
      }
      if (angle === 270 || angle === 180) {
        translateY = canvas.height;
      }
      const context = canvas.getContext(&#039;2d&#039;);
      context.translate(translateX, translateY);
      context.rotate(angle * Math.PI / 180);
      context.drawImage(event.target, 0, 0);
      canvas.toBlob(blob =&gt; {
        setEditedUrl(URL.createObjectURL(blob));
        setRotation(angle);
        setAspect(canvas.width / canvas.height);
        setPosition(prevPosition =&gt; ({
          x: -(prevPosition.y * naturalAspectRatio),
          y: prevPosition.x * naturalAspectRatio
        }));
      });
    }
    const el = new window.Image();
    el.src = url;
    el.onload = editImage;
    const imgCrossOrigin = (0,external_wp_hooks_namespaceObject.applyFilters)(&#039;media.crossOrigin&#039;, undefined, url);
    if (typeof imgCrossOrigin === &#039;string&#039;) {
      el.crossOrigin = imgCrossOrigin;
    }
  }, [rotation, defaultAspect, url]);
  return (0,external_wp_element_namespaceObject.useMemo)(() =&gt; ({
    editedUrl,
    setEditedUrl,
    crop,
    setCrop,
    position,
    setPosition,
    zoom,
    setZoom,
    rotation,
    setRotation,
    rotateClockwise,
    aspect,
    setAspect,
    defaultAspect
  }), [editedUrl, crop, position, zoom, rotation, rotateClockwise, aspect, defaultAspect]);
}

;// ./node_modules/@wordpress/block-editor/build-module/components/image-editor/context.js
/**
 * WordPress dependencies
 */


/**
 * Internal dependencies
 */



const ImageEditingContext = (0,external_wp_element_namespaceObject.createContext)({});
const useImageEditingContext = () =&gt; (0,external_wp_element_namespaceObject.useContext)(ImageEditingContext);
function ImageEditingProvider({
  id,
  url,
  naturalWidth,
  naturalHeight,
  onFinishEditing,
  onSaveImage,
  children
}) {
  const transformImage = useTransformImage({
    url,
    naturalWidth,
    naturalHeight
  });
  const saveImage = useSaveImage({
    id,
    url,
    onSaveImage,
    onFinishEditing,
    ...transformImage
  });
  const providerValue = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; ({
    ...transformImage,
    ...saveImage
  }), [transformImage, saveImage]);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ImageEditingContext.Provider, {
    value: providerValue,
    children: children
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/image-editor/aspect-ratio-dropdown.js
/**
 * WordPress dependencies
 */




/**
 * Internal dependencies
 */




function AspectRatioGroup({
  aspectRatios,
  isDisabled,
  label,
  onClick,
  value
}) {
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuGroup, {
    label: label,
    children: aspectRatios.map(({
      name,
      slug,
      ratio
    }) =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, {
      disabled: isDisabled,
      onClick: () =&gt; {
        onClick(ratio);
      },
      role: &quot;menuitemradio&quot;,
      isSelected: ratio === value,
      icon: ratio === value ? library_check : undefined,
      children: name
    }, slug))
  });
}
function ratioToNumber(str) {
  // TODO: support two-value aspect ratio?
  // https://css-tricks.com/almanac/properties/a/aspect-ratio/#aa-it-can-take-two-values
  const [a, b, ...rest] = str.split(&#039;/&#039;).map(Number);
  if (a &lt;= 0 || b &lt;= 0 || Number.isNaN(a) || Number.isNaN(b) || rest.length) {
    return NaN;
  }
  return b ? a / b : a;
}
function presetRatioAsNumber({
  ratio,
  ...rest
}) {
  return {
    ratio: ratioToNumber(ratio),
    ...rest
  };
}
function AspectRatioDropdown({
  toggleProps
}) {
  const {
    isInProgress,
    aspect,
    setAspect,
    defaultAspect
  } = useImageEditingContext();
  const [defaultRatios, themeRatios, showDefaultRatios] = use_settings_useSettings(&#039;dimensions.aspectRatios.default&#039;, &#039;dimensions.aspectRatios.theme&#039;, &#039;dimensions.defaultAspectRatios&#039;);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.DropdownMenu, {
    icon: aspect_ratio,
    label: (0,external_wp_i18n_namespaceObject.__)(&#039;Aspect Ratio&#039;),
    popoverProps: constants_POPOVER_PROPS,
    toggleProps: toggleProps,
    children: ({
      onClose
    }) =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(AspectRatioGroup, {
        isDisabled: isInProgress,
        onClick: newAspect =&gt; {
          setAspect(newAspect);
          onClose();
        },
        value: aspect,
        aspectRatios: [
        // All ratios should be mirrored in AspectRatioTool in @wordpress/block-editor.
        {
          slug: &#039;original&#039;,
          name: (0,external_wp_i18n_namespaceObject.__)(&#039;Original&#039;),
          ratio: defaultAspect
        }, ...(showDefaultRatios ? defaultRatios.map(presetRatioAsNumber).filter(({
          ratio
        }) =&gt; ratio === 1) : [])]
      }), themeRatios?.length &gt; 0 &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(AspectRatioGroup, {
        label: (0,external_wp_i18n_namespaceObject.__)(&#039;Theme&#039;),
        isDisabled: isInProgress,
        onClick: newAspect =&gt; {
          setAspect(newAspect);
          onClose();
        },
        value: aspect,
        aspectRatios: themeRatios
      }), showDefaultRatios &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(AspectRatioGroup, {
        label: (0,external_wp_i18n_namespaceObject.__)(&#039;Landscape&#039;),
        isDisabled: isInProgress,
        onClick: newAspect =&gt; {
          setAspect(newAspect);
          onClose();
        },
        value: aspect,
        aspectRatios: defaultRatios.map(presetRatioAsNumber).filter(({
          ratio
        }) =&gt; ratio &gt; 1)
      }), showDefaultRatios &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(AspectRatioGroup, {
        label: (0,external_wp_i18n_namespaceObject.__)(&#039;Portrait&#039;),
        isDisabled: isInProgress,
        onClick: newAspect =&gt; {
          setAspect(newAspect);
          onClose();
        },
        value: aspect,
        aspectRatios: defaultRatios.map(presetRatioAsNumber).filter(({
          ratio
        }) =&gt; ratio &lt; 1)
      })]
    })
  });
}

;// ./node_modules/tslib/tslib.es6.mjs
/******************************************************************************
Copyright (c) Microsoft Corporation.

Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted.

THE SOFTWARE IS PROVIDED &quot;AS IS&quot; AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
PERFORMANCE OF THIS SOFTWARE.
***************************************************************************** */
/* global Reflect, Promise, SuppressedError, Symbol, Iterator */

var extendStatics = function(d, b) {
  extendStatics = Object.setPrototypeOf ||
      ({ __proto__: [] } instanceof Array &amp;&amp; function (d, b) { d.__proto__ = b; }) ||
      function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
  return extendStatics(d, b);
};

function __extends(d, b) {
  if (typeof b !== &quot;function&quot; &amp;&amp; b !== null)
      throw new TypeError(&quot;Class extends value &quot; + String(b) + &quot; is not a constructor or null&quot;);
  extendStatics(d, b);
  function __() { this.constructor = d; }
  d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
}

var __assign = function() {
  __assign = Object.assign || function __assign(t) {
      for (var s, i = 1, n = arguments.length; i &lt; n; i++) {
          s = arguments[i];
          for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
      }
      return t;
  }
  return __assign.apply(this, arguments);
}

function __rest(s, e) {
  var t = {};
  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) &amp;&amp; e.indexOf(p) &lt; 0)
      t[p] = s[p];
  if (s != null &amp;&amp; typeof Object.getOwnPropertySymbols === &quot;function&quot;)
      for (var i = 0, p = Object.getOwnPropertySymbols(s); i &lt; p.length; i++) {
          if (e.indexOf(p[i]) &lt; 0 &amp;&amp; Object.prototype.propertyIsEnumerable.call(s, p[i]))
              t[p[i]] = s[p[i]];
      }
  return t;
}

function __decorate(decorators, target, key, desc) {
  var c = arguments.length, r = c &lt; 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
  if (typeof Reflect === &quot;object&quot; &amp;&amp; typeof Reflect.decorate === &quot;function&quot;) r = Reflect.decorate(decorators, target, key, desc);
  else for (var i = decorators.length - 1; i &gt;= 0; i--) if (d = decorators[i]) r = (c &lt; 3 ? d(r) : c &gt; 3 ? d(target, key, r) : d(target, key)) || r;
  return c &gt; 3 &amp;&amp; r &amp;&amp; Object.defineProperty(target, key, r), r;
}

function __param(paramIndex, decorator) {
  return function (target, key) { decorator(target, key, paramIndex); }
}

function __esDecorate(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
  function accept(f) { if (f !== void 0 &amp;&amp; typeof f !== &quot;function&quot;) throw new TypeError(&quot;Function expected&quot;); return f; }
  var kind = contextIn.kind, key = kind === &quot;getter&quot; ? &quot;get&quot; : kind === &quot;setter&quot; ? &quot;set&quot; : &quot;value&quot;;
  var target = !descriptorIn &amp;&amp; ctor ? contextIn[&quot;static&quot;] ? ctor : ctor.prototype : null;
  var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
  var _, done = false;
  for (var i = decorators.length - 1; i &gt;= 0; i--) {
      var context = {};
      for (var p in contextIn) context[p] = p === &quot;access&quot; ? {} : contextIn[p];
      for (var p in contextIn.access) context.access[p] = contextIn.access[p];
      context.addInitializer = function (f) { if (done) throw new TypeError(&quot;Cannot add initializers after decoration has completed&quot;); extraInitializers.push(accept(f || null)); };
      var result = (0, decorators[i])(kind === &quot;accessor&quot; ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
      if (kind === &quot;accessor&quot;) {
          if (result === void 0) continue;
          if (result === null || typeof result !== &quot;object&quot;) throw new TypeError(&quot;Object expected&quot;);
          if (_ = accept(result.get)) descriptor.get = _;
          if (_ = accept(result.set)) descriptor.set = _;
          if (_ = accept(result.init)) initializers.unshift(_);
      }
      else if (_ = accept(result)) {
          if (kind === &quot;field&quot;) initializers.unshift(_);
          else descriptor[key] = _;
      }
  }
  if (target) Object.defineProperty(target, contextIn.name, descriptor);
  done = true;
};

function __runInitializers(thisArg, initializers, value) {
  var useValue = arguments.length &gt; 2;
  for (var i = 0; i &lt; initializers.length; i++) {
      value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
  }
  return useValue ? value : void 0;
};

function __propKey(x) {
  return typeof x === &quot;symbol&quot; ? x : &quot;&quot;.concat(x);
};

function __setFunctionName(f, name, prefix) {
  if (typeof name === &quot;symbol&quot;) name = name.description ? &quot;[&quot;.concat(name.description, &quot;]&quot;) : &quot;&quot;;
  return Object.defineProperty(f, &quot;name&quot;, { configurable: true, value: prefix ? &quot;&quot;.concat(prefix, &quot; &quot;, name) : name });
};

function __metadata(metadataKey, metadataValue) {
  if (typeof Reflect === &quot;object&quot; &amp;&amp; typeof Reflect.metadata === &quot;function&quot;) return Reflect.metadata(metadataKey, metadataValue);
}

function __awaiter(thisArg, _arguments, P, generator) {
  function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
  return new (P || (P = Promise))(function (resolve, reject) {
      function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
      function rejected(value) { try { step(generator[&quot;throw&quot;](value)); } catch (e) { reject(e); } }
      function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
      step((generator = generator.apply(thisArg, _arguments || [])).next());
  });
}

function __generator(thisArg, body) {
  var _ = { label: 0, sent: function() { if (t[0] &amp; 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === &quot;function&quot; ? Iterator : Object).prototype);
  return g.next = verb(0), g[&quot;throw&quot;] = verb(1), g[&quot;return&quot;] = verb(2), typeof Symbol === &quot;function&quot; &amp;&amp; (g[Symbol.iterator] = function() { return this; }), g;
  function verb(n) { return function (v) { return step([n, v]); }; }
  function step(op) {
      if (f) throw new TypeError(&quot;Generator is already executing.&quot;);
      while (g &amp;&amp; (g = 0, op[0] &amp;&amp; (_ = 0)), _) try {
          if (f = 1, y &amp;&amp; (t = op[0] &amp; 2 ? y[&quot;return&quot;] : op[0] ? y[&quot;throw&quot;] || ((t = y[&quot;return&quot;]) &amp;&amp; t.call(y), 0) : y.next) &amp;&amp; !(t = t.call(y, op[1])).done) return t;
          if (y = 0, t) op = [op[0] &amp; 2, t.value];
          switch (op[0]) {
              case 0: case 1: t = op; break;
              case 4: _.label++; return { value: op[1], done: false };
              case 5: _.label++; y = op[1]; op = [0]; continue;
              case 7: op = _.ops.pop(); _.trys.pop(); continue;
              default:
                  if (!(t = _.trys, t = t.length &gt; 0 &amp;&amp; t[t.length - 1]) &amp;&amp; (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
                  if (op[0] === 3 &amp;&amp; (!t || (op[1] &gt; t[0] &amp;&amp; op[1] &lt; t[3]))) { _.label = op[1]; break; }
                  if (op[0] === 6 &amp;&amp; _.label &lt; t[1]) { _.label = t[1]; t = op; break; }
                  if (t &amp;&amp; _.label &lt; t[2]) { _.label = t[2]; _.ops.push(op); break; }
                  if (t[2]) _.ops.pop();
                  _.trys.pop(); continue;
          }
          op = body.call(thisArg, _);
      } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
      if (op[0] &amp; 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
  }
}

var __createBinding = Object.create ? (function(o, m, k, k2) {
  if (k2 === undefined) k2 = k;
  var desc = Object.getOwnPropertyDescriptor(m, k);
  if (!desc || (&quot;get&quot; in desc ? !m.__esModule : desc.writable || desc.configurable)) {
      desc = { enumerable: true, get: function() { return m[k]; } };
  }
  Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
  if (k2 === undefined) k2 = k;
  o[k2] = m[k];
});

function __exportStar(m, o) {
  for (var p in m) if (p !== &quot;default&quot; &amp;&amp; !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);
}

function __values(o) {
  var s = typeof Symbol === &quot;function&quot; &amp;&amp; Symbol.iterator, m = s &amp;&amp; o[s], i = 0;
  if (m) return m.call(o);
  if (o &amp;&amp; typeof o.length === &quot;number&quot;) return {
      next: function () {
          if (o &amp;&amp; i &gt;= o.length) o = void 0;
          return { value: o &amp;&amp; o[i++], done: !o };
      }
  };
  throw new TypeError(s ? &quot;Object is not iterable.&quot; : &quot;Symbol.iterator is not defined.&quot;);
}

function __read(o, n) {
  var m = typeof Symbol === &quot;function&quot; &amp;&amp; o[Symbol.iterator];
  if (!m) return o;
  var i = m.call(o), r, ar = [], e;
  try {
      while ((n === void 0 || n-- &gt; 0) &amp;&amp; !(r = i.next()).done) ar.push(r.value);
  }
  catch (error) { e = { error: error }; }
  finally {
      try {
          if (r &amp;&amp; !r.done &amp;&amp; (m = i[&quot;return&quot;])) m.call(i);
      }
      finally { if (e) throw e.error; }
  }
  return ar;
}

/** @deprecated */
function __spread() {
  for (var ar = [], i = 0; i &lt; arguments.length; i++)
      ar = ar.concat(__read(arguments[i]));
  return ar;
}

/** @deprecated */
function __spreadArrays() {
  for (var s = 0, i = 0, il = arguments.length; i &lt; il; i++) s += arguments[i].length;
  for (var r = Array(s), k = 0, i = 0; i &lt; il; i++)
      for (var a = arguments[i], j = 0, jl = a.length; j &lt; jl; j++, k++)
          r[k] = a[j];
  return r;
}

function __spreadArray(to, from, pack) {
  if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i &lt; l; i++) {
      if (ar || !(i in from)) {
          if (!ar) ar = Array.prototype.slice.call(from, 0, i);
          ar[i] = from[i];
      }
  }
  return to.concat(ar || Array.prototype.slice.call(from));
}

function __await(v) {
  return this instanceof __await ? (this.v = v, this) : new __await(v);
}

function __asyncGenerator(thisArg, _arguments, generator) {
  if (!Symbol.asyncIterator) throw new TypeError(&quot;Symbol.asyncIterator is not defined.&quot;);
  var g = generator.apply(thisArg, _arguments || []), i, q = [];
  return i = Object.create((typeof AsyncIterator === &quot;function&quot; ? AsyncIterator : Object).prototype), verb(&quot;next&quot;), verb(&quot;throw&quot;), verb(&quot;return&quot;, awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
  function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
  function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) &gt; 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
  function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
  function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
  function fulfill(value) { resume(&quot;next&quot;, value); }
  function reject(value) { resume(&quot;throw&quot;, value); }
  function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
}

function __asyncDelegator(o) {
  var i, p;
  return i = {}, verb(&quot;next&quot;), verb(&quot;throw&quot;, function (e) { throw e; }), verb(&quot;return&quot;), i[Symbol.iterator] = function () { return this; }, i;
  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; }
}

function __asyncValues(o) {
  if (!Symbol.asyncIterator) throw new TypeError(&quot;Symbol.asyncIterator is not defined.&quot;);
  var m = o[Symbol.asyncIterator], i;
  return m ? m.call(o) : (o = typeof __values === &quot;function&quot; ? __values(o) : o[Symbol.iterator](), i = {}, verb(&quot;next&quot;), verb(&quot;throw&quot;), verb(&quot;return&quot;), i[Symbol.asyncIterator] = function () { return this; }, i);
  function verb(n) { i[n] = o[n] &amp;&amp; function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
  function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
}

function __makeTemplateObject(cooked, raw) {
  if (Object.defineProperty) { Object.defineProperty(cooked, &quot;raw&quot;, { value: raw }); } else { cooked.raw = raw; }
  return cooked;
};

var __setModuleDefault = Object.create ? (function(o, v) {
  Object.defineProperty(o, &quot;default&quot;, { enumerable: true, value: v });
}) : function(o, v) {
  o[&quot;default&quot;] = v;
};

var ownKeys = function(o) {
  ownKeys = Object.getOwnPropertyNames || function (o) {
    var ar = [];
    for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
    return ar;
  };
  return ownKeys(o);
};

function __importStar(mod) {
  if (mod &amp;&amp; mod.__esModule) return mod;
  var result = {};
  if (mod != null) for (var k = ownKeys(mod), i = 0; i &lt; k.length; i++) if (k[i] !== &quot;default&quot;) __createBinding(result, mod, k[i]);
  __setModuleDefault(result, mod);
  return result;
}

function __importDefault(mod) {
  return (mod &amp;&amp; mod.__esModule) ? mod : { default: mod };
}

function __classPrivateFieldGet(receiver, state, kind, f) {
  if (kind === &quot;a&quot; &amp;&amp; !f) throw new TypeError(&quot;Private accessor was defined without a getter&quot;);
  if (typeof state === &quot;function&quot; ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(&quot;Cannot read private member from an object whose class did not declare it&quot;);
  return kind === &quot;m&quot; ? f : kind === &quot;a&quot; ? f.call(receiver) : f ? f.value : state.get(receiver);
}

function __classPrivateFieldSet(receiver, state, value, kind, f) {
  if (kind === &quot;m&quot;) throw new TypeError(&quot;Private method is not writable&quot;);
  if (kind === &quot;a&quot; &amp;&amp; !f) throw new TypeError(&quot;Private accessor was defined without a setter&quot;);
  if (typeof state === &quot;function&quot; ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(&quot;Cannot write private member to an object whose class did not declare it&quot;);
  return (kind === &quot;a&quot; ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
}

function __classPrivateFieldIn(state, receiver) {
  if (receiver === null || (typeof receiver !== &quot;object&quot; &amp;&amp; typeof receiver !== &quot;function&quot;)) throw new TypeError(&quot;Cannot use &#039;in&#039; operator on non-object&quot;);
  return typeof state === &quot;function&quot; ? receiver === state : state.has(receiver);
}

function __addDisposableResource(env, value, async) {
  if (value !== null &amp;&amp; value !== void 0) {
    if (typeof value !== &quot;object&quot; &amp;&amp; typeof value !== &quot;function&quot;) throw new TypeError(&quot;Object expected.&quot;);
    var dispose, inner;
    if (async) {
      if (!Symbol.asyncDispose) throw new TypeError(&quot;Symbol.asyncDispose is not defined.&quot;);
      dispose = value[Symbol.asyncDispose];
    }
    if (dispose === void 0) {
      if (!Symbol.dispose) throw new TypeError(&quot;Symbol.dispose is not defined.&quot;);
      dispose = value[Symbol.dispose];
      if (async) inner = dispose;
    }
    if (typeof dispose !== &quot;function&quot;) throw new TypeError(&quot;Object not disposable.&quot;);
    if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
    env.stack.push({ value: value, dispose: dispose, async: async });
  }
  else if (async) {
    env.stack.push({ async: true });
  }
  return value;
}

var _SuppressedError = typeof SuppressedError === &quot;function&quot; ? SuppressedError : function (error, suppressed, message) {
  var e = new Error(message);
  return e.name = &quot;SuppressedError&quot;, e.error = error, e.suppressed = suppressed, e;
};

function __disposeResources(env) {
  function fail(e) {
    env.error = env.hasError ? new _SuppressedError(e, env.error, &quot;An error was suppressed during disposal.&quot;) : e;
    env.hasError = true;
  }
  var r, s = 0;
  function next() {
    while (r = env.stack.pop()) {
      try {
        if (!r.async &amp;&amp; s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
        if (r.dispose) {
          var result = r.dispose.call(r.value);
          if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
        }
        else s |= 1;
      }
      catch (e) {
        fail(e);
      }
    }
    if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
    if (env.hasError) throw env.error;
  }
  return next();
}

function __rewriteRelativeImportExtension(path, preserveJsx) {
  if (typeof path === &quot;string&quot; &amp;&amp; /^\.\.?\//.test(path)) {
      return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
          return tsx ? preserveJsx ? &quot;.jsx&quot; : &quot;.js&quot; : d &amp;&amp; (!ext || !cm) ? m : (d + ext + &quot;.&quot; + cm.toLowerCase() + &quot;js&quot;);
      });
  }
  return path;
}

/* harmony default export */ const tslib_es6 = ({
  __extends,
  __assign,
  __rest,
  __decorate,
  __param,
  __esDecorate,
  __runInitializers,
  __propKey,
  __setFunctionName,
  __metadata,
  __awaiter,
  __generator,
  __createBinding,
  __exportStar,
  __values,
  __read,
  __spread,
  __spreadArrays,
  __spreadArray,
  __await,
  __asyncGenerator,
  __asyncDelegator,
  __asyncValues,
  __makeTemplateObject,
  __importStar,
  __importDefault,
  __classPrivateFieldGet,
  __classPrivateFieldSet,
  __classPrivateFieldIn,
  __addDisposableResource,
  __disposeResources,
  __rewriteRelativeImportExtension,
});

// EXTERNAL MODULE: ./node_modules/normalize-wheel/index.js
var normalize_wheel = __webpack_require__(7520);
var normalize_wheel_default = /*#__PURE__*/__webpack_require__.n(normalize_wheel);
;// ./node_modules/react-easy-crop/index.module.js




/**
 * Compute the dimension of the crop area based on media size,
 * aspect ratio and optionally rotation
 */
function getCropSize(mediaWidth, mediaHeight, containerWidth, containerHeight, aspect, rotation) {
  if (rotation === void 0) {
    rotation = 0;
  }
  var _a = rotateSize(mediaWidth, mediaHeight, rotation),
    width = _a.width,
    height = _a.height;
  var fittingWidth = Math.min(width, containerWidth);
  var fittingHeight = Math.min(height, containerHeight);
  if (fittingWidth &gt; fittingHeight * aspect) {
    return {
      width: fittingHeight * aspect,
      height: fittingHeight
    };
  }
  return {
    width: fittingWidth,
    height: fittingWidth / aspect
  };
}
/**
 * Compute media zoom.
 * We fit the media into the container with &quot;max-width: 100%; max-height: 100%;&quot;
 */
function getMediaZoom(mediaSize) {
  // Take the axis with more pixels to improve accuracy
  return mediaSize.width &gt; mediaSize.height ? mediaSize.width / mediaSize.naturalWidth : mediaSize.height / mediaSize.naturalHeight;
}
/**
 * Ensure a new media position stays in the crop area.
 */
function restrictPosition(position, mediaSize, cropSize, zoom, rotation) {
  if (rotation === void 0) {
    rotation = 0;
  }
  var _a = rotateSize(mediaSize.width, mediaSize.height, rotation),
    width = _a.width,
    height = _a.height;
  return {
    x: restrictPositionCoord(position.x, width, cropSize.width, zoom),
    y: restrictPositionCoord(position.y, height, cropSize.height, zoom)
  };
}
function restrictPositionCoord(position, mediaSize, cropSize, zoom) {
  var maxPosition = mediaSize * zoom / 2 - cropSize / 2;
  return clamp(position, -maxPosition, maxPosition);
}
function getDistanceBetweenPoints(pointA, pointB) {
  return Math.sqrt(Math.pow(pointA.y - pointB.y, 2) + Math.pow(pointA.x - pointB.x, 2));
}
function getRotationBetweenPoints(pointA, pointB) {
  return Math.atan2(pointB.y - pointA.y, pointB.x - pointA.x) * 180 / Math.PI;
}
/**
 * Compute the output cropped area of the media in percentages and pixels.
 * x/y are the top-left coordinates on the src media
 */
function computeCroppedArea(crop, mediaSize, cropSize, aspect, zoom, rotation, restrictPosition) {
  if (rotation === void 0) {
    rotation = 0;
  }
  if (restrictPosition === void 0) {
    restrictPosition = true;
  }
  // if the media is rotated by the user, we cannot limit the position anymore
  // as it might need to be negative.
  var limitAreaFn = restrictPosition ? limitArea : noOp;
  var mediaBBoxSize = rotateSize(mediaSize.width, mediaSize.height, rotation);
  var mediaNaturalBBoxSize = rotateSize(mediaSize.naturalWidth, mediaSize.naturalHeight, rotation);
  // calculate the crop area in percentages
  // in the rotated space
  var croppedAreaPercentages = {
    x: limitAreaFn(100, ((mediaBBoxSize.width - cropSize.width / zoom) / 2 - crop.x / zoom) / mediaBBoxSize.width * 100),
    y: limitAreaFn(100, ((mediaBBoxSize.height - cropSize.height / zoom) / 2 - crop.y / zoom) / mediaBBoxSize.height * 100),
    width: limitAreaFn(100, cropSize.width / mediaBBoxSize.width * 100 / zoom),
    height: limitAreaFn(100, cropSize.height / mediaBBoxSize.height * 100 / zoom)
  };
  // we compute the pixels size naively
  var widthInPixels = Math.round(limitAreaFn(mediaNaturalBBoxSize.width, croppedAreaPercentages.width * mediaNaturalBBoxSize.width / 100));
  var heightInPixels = Math.round(limitAreaFn(mediaNaturalBBoxSize.height, croppedAreaPercentages.height * mediaNaturalBBoxSize.height / 100));
  var isImgWiderThanHigh = mediaNaturalBBoxSize.width &gt;= mediaNaturalBBoxSize.height * aspect;
  // then we ensure the width and height exactly match the aspect (to avoid rounding approximations)
  // if the media is wider than high, when zoom is 0, the crop height will be equals to image height
  // thus we want to compute the width from the height and aspect for accuracy.
  // Otherwise, we compute the height from width and aspect.
  var sizePixels = isImgWiderThanHigh ? {
    width: Math.round(heightInPixels * aspect),
    height: heightInPixels
  } : {
    width: widthInPixels,
    height: Math.round(widthInPixels / aspect)
  };
  var croppedAreaPixels = __assign(__assign({}, sizePixels), {
    x: Math.round(limitAreaFn(mediaNaturalBBoxSize.width - sizePixels.width, croppedAreaPercentages.x * mediaNaturalBBoxSize.width / 100)),
    y: Math.round(limitAreaFn(mediaNaturalBBoxSize.height - sizePixels.height, croppedAreaPercentages.y * mediaNaturalBBoxSize.height / 100))
  });
  return {
    croppedAreaPercentages: croppedAreaPercentages,
    croppedAreaPixels: croppedAreaPixels
  };
}
/**
 * Ensure the returned value is between 0 and max
 */
function limitArea(max, value) {
  return Math.min(max, Math.max(0, value));
}
function noOp(_max, value) {
  return value;
}
/**
 * Compute crop and zoom from the croppedAreaPercentages.
 */
function getInitialCropFromCroppedAreaPercentages(croppedAreaPercentages, mediaSize, rotation, cropSize, minZoom, maxZoom) {
  var mediaBBoxSize = rotateSize(mediaSize.width, mediaSize.height, rotation);
  // This is the inverse process of computeCroppedArea
  var zoom = clamp(cropSize.width / mediaBBoxSize.width * (100 / croppedAreaPercentages.width), minZoom, maxZoom);
  var crop = {
    x: zoom * mediaBBoxSize.width / 2 - cropSize.width / 2 - mediaBBoxSize.width * zoom * (croppedAreaPercentages.x / 100),
    y: zoom * mediaBBoxSize.height / 2 - cropSize.height / 2 - mediaBBoxSize.height * zoom * (croppedAreaPercentages.y / 100)
  };
  return {
    crop: crop,
    zoom: zoom
  };
}
/**
 * Compute zoom from the croppedAreaPixels
 */
function getZoomFromCroppedAreaPixels(croppedAreaPixels, mediaSize, cropSize) {
  var mediaZoom = getMediaZoom(mediaSize);
  return cropSize.height &gt; cropSize.width ? cropSize.height / (croppedAreaPixels.height * mediaZoom) : cropSize.width / (croppedAreaPixels.width * mediaZoom);
}
/**
 * Compute crop and zoom from the croppedAreaPixels
 */
function getInitialCropFromCroppedAreaPixels(croppedAreaPixels, mediaSize, rotation, cropSize, minZoom, maxZoom) {
  if (rotation === void 0) {
    rotation = 0;
  }
  var mediaNaturalBBoxSize = rotateSize(mediaSize.naturalWidth, mediaSize.naturalHeight, rotation);
  var zoom = clamp(getZoomFromCroppedAreaPixels(croppedAreaPixels, mediaSize, cropSize), minZoom, maxZoom);
  var cropZoom = cropSize.height &gt; cropSize.width ? cropSize.height / croppedAreaPixels.height : cropSize.width / croppedAreaPixels.width;
  var crop = {
    x: ((mediaNaturalBBoxSize.width - croppedAreaPixels.width) / 2 - croppedAreaPixels.x) * cropZoom,
    y: ((mediaNaturalBBoxSize.height - croppedAreaPixels.height) / 2 - croppedAreaPixels.y) * cropZoom
  };
  return {
    crop: crop,
    zoom: zoom
  };
}
/**
 * Return the point that is the center of point a and b
 */
function getCenter(a, b) {
  return {
    x: (b.x + a.x) / 2,
    y: (b.y + a.y) / 2
  };
}
function getRadianAngle(degreeValue) {
  return degreeValue * Math.PI / 180;
}
/**
 * Returns the new bounding area of a rotated rectangle.
 */
function rotateSize(width, height, rotation) {
  var rotRad = getRadianAngle(rotation);
  return {
    width: Math.abs(Math.cos(rotRad) * width) + Math.abs(Math.sin(rotRad) * height),
    height: Math.abs(Math.sin(rotRad) * width) + Math.abs(Math.cos(rotRad) * height)
  };
}
/**
 * Clamp value between min and max
 */
function clamp(value, min, max) {
  return Math.min(Math.max(value, min), max);
}
/**
 * Combine multiple class names into a single string.
 */
function classNames() {
  var args = [];
  for (var _i = 0; _i &lt; arguments.length; _i++) {
    args[_i] = arguments[_i];
  }
  return args.filter(function (value) {
    if (typeof value === &#039;string&#039; &amp;&amp; value.length &gt; 0) {
      return true;
    }
    return false;
  }).join(&#039; &#039;).trim();
}

var css_248z = &quot;.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: &#039; &#039;;\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: &#039; &#039;;\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&quot;;

var index_module_MIN_ZOOM = 1;
var index_module_MAX_ZOOM = 3;
var Cropper = /** @class */function (_super) {
  __extends(Cropper, _super);
  function Cropper() {
    var _this = _super !== null &amp;&amp; _super.apply(this, arguments) || this;
    _this.imageRef = external_React_.createRef();
    _this.videoRef = external_React_.createRef();
    _this.containerPosition = {
      x: 0,
      y: 0
    };
    _this.containerRef = null;
    _this.styleRef = null;
    _this.containerRect = null;
    _this.mediaSize = {
      width: 0,
      height: 0,
      naturalWidth: 0,
      naturalHeight: 0
    };
    _this.dragStartPosition = {
      x: 0,
      y: 0
    };
    _this.dragStartCrop = {
      x: 0,
      y: 0
    };
    _this.gestureZoomStart = 0;
    _this.gestureRotationStart = 0;
    _this.isTouching = false;
    _this.lastPinchDistance = 0;
    _this.lastPinchRotation = 0;
    _this.rafDragTimeout = null;
    _this.rafPinchTimeout = null;
    _this.wheelTimer = null;
    _this.currentDoc = typeof document !== &#039;undefined&#039; ? document : null;
    _this.currentWindow = typeof window !== &#039;undefined&#039; ? window : null;
    _this.resizeObserver = null;
    _this.state = {
      cropSize: null,
      hasWheelJustStarted: false,
      mediaObjectFit: undefined
    };
    _this.initResizeObserver = function () {
      if (typeof window.ResizeObserver === &#039;undefined&#039; || !_this.containerRef) {
        return;
      }
      var isFirstResize = true;
      _this.resizeObserver = new window.ResizeObserver(function (entries) {
        if (isFirstResize) {
          isFirstResize = false; // observe() is called on mount, we don&#039;t want to trigger a recompute on mount
          return;
        }
        _this.computeSizes();
      });
      _this.resizeObserver.observe(_this.containerRef);
    };
    // this is to prevent Safari on iOS &gt;= 10 to zoom the page
    _this.preventZoomSafari = function (e) {
      return e.preventDefault();
    };
    _this.cleanEvents = function () {
      if (!_this.currentDoc) return;
      _this.currentDoc.removeEventListener(&#039;mousemove&#039;, _this.onMouseMove);
      _this.currentDoc.removeEventListener(&#039;mouseup&#039;, _this.onDragStopped);
      _this.currentDoc.removeEventListener(&#039;touchmove&#039;, _this.onTouchMove);
      _this.currentDoc.removeEventListener(&#039;touchend&#039;, _this.onDragStopped);
      _this.currentDoc.removeEventListener(&#039;gesturemove&#039;, _this.onGestureMove);
      _this.currentDoc.removeEventListener(&#039;gestureend&#039;, _this.onGestureEnd);
      _this.currentDoc.removeEventListener(&#039;scroll&#039;, _this.onScroll);
    };
    _this.clearScrollEvent = function () {
      if (_this.containerRef) _this.containerRef.removeEventListener(&#039;wheel&#039;, _this.onWheel);
      if (_this.wheelTimer) {
        clearTimeout(_this.wheelTimer);
      }
    };
    _this.onMediaLoad = function () {
      var cropSize = _this.computeSizes();
      if (cropSize) {
        _this.emitCropData();
        _this.setInitialCrop(cropSize);
      }
      if (_this.props.onMediaLoaded) {
        _this.props.onMediaLoaded(_this.mediaSize);
      }
    };
    _this.setInitialCrop = function (cropSize) {
      if (_this.props.initialCroppedAreaPercentages) {
        var _a = getInitialCropFromCroppedAreaPercentages(_this.props.initialCroppedAreaPercentages, _this.mediaSize, _this.props.rotation, cropSize, _this.props.minZoom, _this.props.maxZoom),
          crop = _a.crop,
          zoom = _a.zoom;
        _this.props.onCropChange(crop);
        _this.props.onZoomChange &amp;&amp; _this.props.onZoomChange(zoom);
      } else if (_this.props.initialCroppedAreaPixels) {
        var _b = getInitialCropFromCroppedAreaPixels(_this.props.initialCroppedAreaPixels, _this.mediaSize, _this.props.rotation, cropSize, _this.props.minZoom, _this.props.maxZoom),
          crop = _b.crop,
          zoom = _b.zoom;
        _this.props.onCropChange(crop);
        _this.props.onZoomChange &amp;&amp; _this.props.onZoomChange(zoom);
      }
    };
    _this.computeSizes = function () {
      var _a, _b, _c, _d, _e, _f;
      var mediaRef = _this.imageRef.current || _this.videoRef.current;
      if (mediaRef &amp;&amp; _this.containerRef) {
        _this.containerRect = _this.containerRef.getBoundingClientRect();
        _this.saveContainerPosition();
        var containerAspect = _this.containerRect.width / _this.containerRect.height;
        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;
        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;
        var isMediaScaledDown = mediaRef.offsetWidth &lt; naturalWidth || mediaRef.offsetHeight &lt; naturalHeight;
        var mediaAspect = naturalWidth / naturalHeight;
        // We do not rely on the offsetWidth/offsetHeight if the media is scaled down
        // as the values they report are rounded. That will result in precision losses
        // when calculating zoom. We use the fact that the media is positionned relative
        // to the container. That allows us to use the container&#039;s dimensions
        // and natural aspect ratio of the media to calculate accurate media size.
        // However, for this to work, the container should not be rotated
        var renderedMediaSize = void 0;
        if (isMediaScaledDown) {
          switch (_this.state.mediaObjectFit) {
            default:
            case &#039;contain&#039;:
              renderedMediaSize = containerAspect &gt; mediaAspect ? {
                width: _this.containerRect.height * mediaAspect,
                height: _this.containerRect.height
              } : {
                width: _this.containerRect.width,
                height: _this.containerRect.width / mediaAspect
              };
              break;
            case &#039;horizontal-cover&#039;:
              renderedMediaSize = {
                width: _this.containerRect.width,
                height: _this.containerRect.width / mediaAspect
              };
              break;
            case &#039;vertical-cover&#039;:
              renderedMediaSize = {
                width: _this.containerRect.height * mediaAspect,
                height: _this.containerRect.height
              };
              break;
          }
        } else {
          renderedMediaSize = {
            width: mediaRef.offsetWidth,
            height: mediaRef.offsetHeight
          };
        }
        _this.mediaSize = __assign(__assign({}, renderedMediaSize), {
          naturalWidth: naturalWidth,
          naturalHeight: naturalHeight
        });
        // set media size in the parent
        if (_this.props.setMediaSize) {
          _this.props.setMediaSize(_this.mediaSize);
        }
        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);
        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) {
          _this.props.onCropSizeChange &amp;&amp; _this.props.onCropSizeChange(cropSize);
        }
        _this.setState({
          cropSize: cropSize
        }, _this.recomputeCropPosition);
        // pass crop size to parent
        if (_this.props.setCropSize) {
          _this.props.setCropSize(cropSize);
        }
        return cropSize;
      }
    };
    _this.saveContainerPosition = function () {
      if (_this.containerRef) {
        var bounds = _this.containerRef.getBoundingClientRect();
        _this.containerPosition = {
          x: bounds.left,
          y: bounds.top
        };
      }
    };
    _this.onMouseDown = function (e) {
      if (!_this.currentDoc) return;
      e.preventDefault();
      _this.currentDoc.addEventListener(&#039;mousemove&#039;, _this.onMouseMove);
      _this.currentDoc.addEventListener(&#039;mouseup&#039;, _this.onDragStopped);
      _this.saveContainerPosition();
      _this.onDragStart(Cropper.getMousePoint(e));
    };
    _this.onMouseMove = function (e) {
      return _this.onDrag(Cropper.getMousePoint(e));
    };
    _this.onScroll = function (e) {
      if (!_this.currentDoc) return;
      e.preventDefault();
      _this.saveContainerPosition();
    };
    _this.onTouchStart = function (e) {
      if (!_this.currentDoc) return;
      _this.isTouching = true;
      if (_this.props.onTouchRequest &amp;&amp; !_this.props.onTouchRequest(e)) {
        return;
      }
      _this.currentDoc.addEventListener(&#039;touchmove&#039;, _this.onTouchMove, {
        passive: false
      }); // iOS 11 now defaults to passive: true
      _this.currentDoc.addEventListener(&#039;touchend&#039;, _this.onDragStopped);
      _this.saveContainerPosition();
      if (e.touches.length === 2) {
        _this.onPinchStart(e);
      } else if (e.touches.length === 1) {
        _this.onDragStart(Cropper.getTouchPoint(e.touches[0]));
      }
    };
    _this.onTouchMove = function (e) {
      // Prevent whole page from scrolling on iOS.
      e.preventDefault();
      if (e.touches.length === 2) {
        _this.onPinchMove(e);
      } else if (e.touches.length === 1) {
        _this.onDrag(Cropper.getTouchPoint(e.touches[0]));
      }
    };
    _this.onGestureStart = function (e) {
      if (!_this.currentDoc) return;
      e.preventDefault();
      _this.currentDoc.addEventListener(&#039;gesturechange&#039;, _this.onGestureMove);
      _this.currentDoc.addEventListener(&#039;gestureend&#039;, _this.onGestureEnd);
      _this.gestureZoomStart = _this.props.zoom;
      _this.gestureRotationStart = _this.props.rotation;
    };
    _this.onGestureMove = function (e) {
      e.preventDefault();
      if (_this.isTouching) {
        // this is to avoid conflict between gesture and touch events
        return;
      }
      var point = Cropper.getMousePoint(e);
      var newZoom = _this.gestureZoomStart - 1 + e.scale;
      _this.setNewZoom(newZoom, point, {
        shouldUpdatePosition: true
      });
      if (_this.props.onRotationChange) {
        var newRotation = _this.gestureRotationStart + e.rotation;
        _this.props.onRotationChange(newRotation);
      }
    };
    _this.onGestureEnd = function (e) {
      _this.cleanEvents();
    };
    _this.onDragStart = function (_a) {
      var _b, _c;
      var x = _a.x,
        y = _a.y;
      _this.dragStartPosition = {
        x: x,
        y: y
      };
      _this.dragStartCrop = __assign({}, _this.props.crop);
      (_c = (_b = _this.props).onInteractionStart) === null || _c === void 0 ? void 0 : _c.call(_b);
    };
    _this.onDrag = function (_a) {
      var x = _a.x,
        y = _a.y;
      if (!_this.currentWindow) return;
      if (_this.rafDragTimeout) _this.currentWindow.cancelAnimationFrame(_this.rafDragTimeout);
      _this.rafDragTimeout = _this.currentWindow.requestAnimationFrame(function () {
        if (!_this.state.cropSize) return;
        if (x === undefined || y === undefined) return;
        var offsetX = x - _this.dragStartPosition.x;
        var offsetY = y - _this.dragStartPosition.y;
        var requestedPosition = {
          x: _this.dragStartCrop.x + offsetX,
          y: _this.dragStartCrop.y + offsetY
        };
        var newPosition = _this.props.restrictPosition ? restrictPosition(requestedPosition, _this.mediaSize, _this.state.cropSize, _this.props.zoom, _this.props.rotation) : requestedPosition;
        _this.props.onCropChange(newPosition);
      });
    };
    _this.onDragStopped = function () {
      var _a, _b;
      _this.isTouching = false;
      _this.cleanEvents();
      _this.emitCropData();
      (_b = (_a = _this.props).onInteractionEnd) === null || _b === void 0 ? void 0 : _b.call(_a);
    };
    _this.onWheel = function (e) {
      if (!_this.currentWindow) return;
      if (_this.props.onWheelRequest &amp;&amp; !_this.props.onWheelRequest(e)) {
        return;
      }
      e.preventDefault();
      var point = Cropper.getMousePoint(e);
      var pixelY = normalize_wheel_default()(e).pixelY;
      var newZoom = _this.props.zoom - pixelY * _this.props.zoomSpeed / 200;
      _this.setNewZoom(newZoom, point, {
        shouldUpdatePosition: true
      });
      if (!_this.state.hasWheelJustStarted) {
        _this.setState({
          hasWheelJustStarted: true
        }, function () {
          var _a, _b;
          return (_b = (_a = _this.props).onInteractionStart) === null || _b === void 0 ? void 0 : _b.call(_a);
        });
      }
      if (_this.wheelTimer) {
        clearTimeout(_this.wheelTimer);
      }
      _this.wheelTimer = _this.currentWindow.setTimeout(function () {
        return _this.setState({
          hasWheelJustStarted: false
        }, function () {
          var _a, _b;
          return (_b = (_a = _this.props).onInteractionEnd) === null || _b === void 0 ? void 0 : _b.call(_a);
        });
      }, 250);
    };
    _this.getPointOnContainer = function (_a, containerTopLeft) {
      var x = _a.x,
        y = _a.y;
      if (!_this.containerRect) {
        throw new Error(&#039;The Cropper is not mounted&#039;);
      }
      return {
        x: _this.containerRect.width / 2 - (x - containerTopLeft.x),
        y: _this.containerRect.height / 2 - (y - containerTopLeft.y)
      };
    };
    _this.getPointOnMedia = function (_a) {
      var x = _a.x,
        y = _a.y;
      var _b = _this.props,
        crop = _b.crop,
        zoom = _b.zoom;
      return {
        x: (x + crop.x) / zoom,
        y: (y + crop.y) / zoom
      };
    };
    _this.setNewZoom = function (zoom, point, _a) {
      var _b = _a === void 0 ? {} : _a,
        _c = _b.shouldUpdatePosition,
        shouldUpdatePosition = _c === void 0 ? true : _c;
      if (!_this.state.cropSize || !_this.props.onZoomChange) return;
      var newZoom = clamp(zoom, _this.props.minZoom, _this.props.maxZoom);
      if (shouldUpdatePosition) {
        var zoomPoint = _this.getPointOnContainer(point, _this.containerPosition);
        var zoomTarget = _this.getPointOnMedia(zoomPoint);
        var requestedPosition = {
          x: zoomTarget.x * newZoom - zoomPoint.x,
          y: zoomTarget.y * newZoom - zoomPoint.y
        };
        var newPosition = _this.props.restrictPosition ? restrictPosition(requestedPosition, _this.mediaSize, _this.state.cropSize, newZoom, _this.props.rotation) : requestedPosition;
        _this.props.onCropChange(newPosition);
      }
      _this.props.onZoomChange(newZoom);
    };
    _this.getCropData = function () {
      if (!_this.state.cropSize) {
        return null;
      }
      // this is to ensure the crop is correctly restricted after a zoom back (https://github.com/ValentinH/react-easy-crop/issues/6)
      var restrictedPosition = _this.props.restrictPosition ? restrictPosition(_this.props.crop, _this.mediaSize, _this.state.cropSize, _this.props.zoom, _this.props.rotation) : _this.props.crop;
      return computeCroppedArea(restrictedPosition, _this.mediaSize, _this.state.cropSize, _this.getAspect(), _this.props.zoom, _this.props.rotation, _this.props.restrictPosition);
    };
    _this.emitCropData = function () {
      var cropData = _this.getCropData();
      if (!cropData) return;
      var croppedAreaPercentages = cropData.croppedAreaPercentages,
        croppedAreaPixels = cropData.croppedAreaPixels;
      if (_this.props.onCropComplete) {
        _this.props.onCropComplete(croppedAreaPercentages, croppedAreaPixels);
      }
      if (_this.props.onCropAreaChange) {
        _this.props.onCropAreaChange(croppedAreaPercentages, croppedAreaPixels);
      }
    };
    _this.emitCropAreaChange = function () {
      var cropData = _this.getCropData();
      if (!cropData) return;
      var croppedAreaPercentages = cropData.croppedAreaPercentages,
        croppedAreaPixels = cropData.croppedAreaPixels;
      if (_this.props.onCropAreaChange) {
        _this.props.onCropAreaChange(croppedAreaPercentages, croppedAreaPixels);
      }
    };
    _this.recomputeCropPosition = function () {
      if (!_this.state.cropSize) return;
      var newPosition = _this.props.restrictPosition ? restrictPosition(_this.props.crop, _this.mediaSize, _this.state.cropSize, _this.props.zoom, _this.props.rotation) : _this.props.crop;
      _this.props.onCropChange(newPosition);
      _this.emitCropData();
    };
    return _this;
  }
  Cropper.prototype.componentDidMount = function () {
    if (!this.currentDoc || !this.currentWindow) return;
    if (this.containerRef) {
      if (this.containerRef.ownerDocument) {
        this.currentDoc = this.containerRef.ownerDocument;
      }
      if (this.currentDoc.defaultView) {
        this.currentWindow = this.currentDoc.defaultView;
      }
      this.initResizeObserver();
      // only add window resize listener if ResizeObserver is not supported. Otherwise, it would be redundant
      if (typeof window.ResizeObserver === &#039;undefined&#039;) {
        this.currentWindow.addEventListener(&#039;resize&#039;, this.computeSizes);
      }
      this.props.zoomWithScroll &amp;&amp; this.containerRef.addEventListener(&#039;wheel&#039;, this.onWheel, {
        passive: false
      });
      this.containerRef.addEventListener(&#039;gesturestart&#039;, this.onGestureStart);
    }
    this.currentDoc.addEventListener(&#039;scroll&#039;, this.onScroll);
    if (!this.props.disableAutomaticStylesInjection) {
      this.styleRef = this.currentDoc.createElement(&#039;style&#039;);
      this.styleRef.setAttribute(&#039;type&#039;, &#039;text/css&#039;);
      if (this.props.nonce) {
        this.styleRef.setAttribute(&#039;nonce&#039;, this.props.nonce);
      }
      this.styleRef.innerHTML = css_248z;
      this.currentDoc.head.appendChild(this.styleRef);
    }
    // when rendered via SSR, the image can already be loaded and its onLoad callback will never be called
    if (this.imageRef.current &amp;&amp; this.imageRef.current.complete) {
      this.onMediaLoad();
    }
    // set image and video refs in the parent if the callbacks exist
    if (this.props.setImageRef) {
      this.props.setImageRef(this.imageRef);
    }
    if (this.props.setVideoRef) {
      this.props.setVideoRef(this.videoRef);
    }
  };
  Cropper.prototype.componentWillUnmount = function () {
    var _a, _b;
    if (!this.currentDoc || !this.currentWindow) return;
    if (typeof window.ResizeObserver === &#039;undefined&#039;) {
      this.currentWindow.removeEventListener(&#039;resize&#039;, this.computeSizes);
    }
    (_a = this.resizeObserver) === null || _a === void 0 ? void 0 : _a.disconnect();
    if (this.containerRef) {
      this.containerRef.removeEventListener(&#039;gesturestart&#039;, this.preventZoomSafari);
    }
    if (this.styleRef) {
      (_b = this.styleRef.parentNode) === null || _b === void 0 ? void 0 : _b.removeChild(this.styleRef);
    }
    this.cleanEvents();
    this.props.zoomWithScroll &amp;&amp; this.clearScrollEvent();
  };
  Cropper.prototype.componentDidUpdate = function (prevProps) {
    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
    if (prevProps.rotation !== this.props.rotation) {
      this.computeSizes();
      this.recomputeCropPosition();
    } else if (prevProps.aspect !== this.props.aspect) {
      this.computeSizes();
    } else if (prevProps.objectFit !== this.props.objectFit) {
      this.computeSizes();
    } else if (prevProps.zoom !== this.props.zoom) {
      this.recomputeCropPosition();
    } 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)) {
      this.computeSizes();
    } 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)) {
      this.emitCropAreaChange();
    }
    if (prevProps.zoomWithScroll !== this.props.zoomWithScroll &amp;&amp; this.containerRef) {
      this.props.zoomWithScroll ? this.containerRef.addEventListener(&#039;wheel&#039;, this.onWheel, {
        passive: false
      }) : this.clearScrollEvent();
    }
    if (prevProps.video !== this.props.video) {
      (_j = this.videoRef.current) === null || _j === void 0 ? void 0 : _j.load();
    }
    var objectFit = this.getObjectFit();
    if (objectFit !== this.state.mediaObjectFit) {
      this.setState({
        mediaObjectFit: objectFit
      }, this.computeSizes);
    }
  };
  Cropper.prototype.getAspect = function () {
    var _a = this.props,
      cropSize = _a.cropSize,
      aspect = _a.aspect;
    if (cropSize) {
      return cropSize.width / cropSize.height;
    }
    return aspect;
  };
  Cropper.prototype.getObjectFit = function () {
    var _a, _b, _c, _d;
    if (this.props.objectFit === &#039;cover&#039;) {
      var mediaRef = this.imageRef.current || this.videoRef.current;
      if (mediaRef &amp;&amp; this.containerRef) {
        this.containerRect = this.containerRef.getBoundingClientRect();
        var containerAspect = this.containerRect.width / this.containerRect.height;
        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;
        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;
        var mediaAspect = naturalWidth / naturalHeight;
        return mediaAspect &lt; containerAspect ? &#039;horizontal-cover&#039; : &#039;vertical-cover&#039;;
      }
      return &#039;horizontal-cover&#039;;
    }
    return this.props.objectFit;
  };
  Cropper.prototype.onPinchStart = function (e) {
    var pointA = Cropper.getTouchPoint(e.touches[0]);
    var pointB = Cropper.getTouchPoint(e.touches[1]);
    this.lastPinchDistance = getDistanceBetweenPoints(pointA, pointB);
    this.lastPinchRotation = getRotationBetweenPoints(pointA, pointB);
    this.onDragStart(getCenter(pointA, pointB));
  };
  Cropper.prototype.onPinchMove = function (e) {
    var _this = this;
    if (!this.currentDoc || !this.currentWindow) return;
    var pointA = Cropper.getTouchPoint(e.touches[0]);
    var pointB = Cropper.getTouchPoint(e.touches[1]);
    var center = getCenter(pointA, pointB);
    this.onDrag(center);
    if (this.rafPinchTimeout) this.currentWindow.cancelAnimationFrame(this.rafPinchTimeout);
    this.rafPinchTimeout = this.currentWindow.requestAnimationFrame(function () {
      var distance = getDistanceBetweenPoints(pointA, pointB);
      var newZoom = _this.props.zoom * (distance / _this.lastPinchDistance);
      _this.setNewZoom(newZoom, center, {
        shouldUpdatePosition: false
      });
      _this.lastPinchDistance = distance;
      var rotation = getRotationBetweenPoints(pointA, pointB);
      var newRotation = _this.props.rotation + (rotation - _this.lastPinchRotation);
      _this.props.onRotationChange &amp;&amp; _this.props.onRotationChange(newRotation);
      _this.lastPinchRotation = rotation;
    });
  };
  Cropper.prototype.render = function () {
    var _this = this;
    var _a = this.props,
      image = _a.image,
      video = _a.video,
      mediaProps = _a.mediaProps,
      transform = _a.transform,
      _b = _a.crop,
      x = _b.x,
      y = _b.y,
      rotation = _a.rotation,
      zoom = _a.zoom,
      cropShape = _a.cropShape,
      showGrid = _a.showGrid,
      _c = _a.style,
      containerStyle = _c.containerStyle,
      cropAreaStyle = _c.cropAreaStyle,
      mediaStyle = _c.mediaStyle,
      _d = _a.classes,
      containerClassName = _d.containerClassName,
      cropAreaClassName = _d.cropAreaClassName,
      mediaClassName = _d.mediaClassName;
    var objectFit = this.state.mediaObjectFit;
    return external_React_.createElement(&quot;div&quot;, {
      onMouseDown: this.onMouseDown,
      onTouchStart: this.onTouchStart,
      ref: function ref(el) {
        return _this.containerRef = el;
      },
      &quot;data-testid&quot;: &quot;container&quot;,
      style: containerStyle,
      className: classNames(&#039;reactEasyCrop_Container&#039;, containerClassName)
    }, image ? external_React_.createElement(&quot;img&quot;, __assign({
      alt: &quot;&quot;,
      className: classNames(&#039;reactEasyCrop_Image&#039;, objectFit === &#039;contain&#039; &amp;&amp; &#039;reactEasyCrop_Contain&#039;, objectFit === &#039;horizontal-cover&#039; &amp;&amp; &#039;reactEasyCrop_Cover_Horizontal&#039;, objectFit === &#039;vertical-cover&#039; &amp;&amp; &#039;reactEasyCrop_Cover_Vertical&#039;, mediaClassName)
    }, mediaProps, {
      src: image,
      ref: this.imageRef,
      style: __assign(__assign({}, mediaStyle), {
        transform: transform || &quot;translate(&quot;.concat(x, &quot;px, &quot;).concat(y, &quot;px) rotate(&quot;).concat(rotation, &quot;deg) scale(&quot;).concat(zoom, &quot;)&quot;)
      }),
      onLoad: this.onMediaLoad
    })) : video &amp;&amp; external_React_.createElement(&quot;video&quot;, __assign({
      autoPlay: true,
      loop: true,
      muted: true,
      className: classNames(&#039;reactEasyCrop_Video&#039;, objectFit === &#039;contain&#039; &amp;&amp; &#039;reactEasyCrop_Contain&#039;, objectFit === &#039;horizontal-cover&#039; &amp;&amp; &#039;reactEasyCrop_Cover_Horizontal&#039;, objectFit === &#039;vertical-cover&#039; &amp;&amp; &#039;reactEasyCrop_Cover_Vertical&#039;, mediaClassName)
    }, mediaProps, {
      ref: this.videoRef,
      onLoadedMetadata: this.onMediaLoad,
      style: __assign(__assign({}, mediaStyle), {
        transform: transform || &quot;translate(&quot;.concat(x, &quot;px, &quot;).concat(y, &quot;px) rotate(&quot;).concat(rotation, &quot;deg) scale(&quot;).concat(zoom, &quot;)&quot;)
      }),
      controls: false
    }), (Array.isArray(video) ? video : [{
      src: video
    }]).map(function (item) {
      return external_React_.createElement(&quot;source&quot;, __assign({
        key: item.src
      }, item));
    })), this.state.cropSize &amp;&amp; external_React_.createElement(&quot;div&quot;, {
      style: __assign(__assign({}, cropAreaStyle), {
        width: this.state.cropSize.width,
        height: this.state.cropSize.height
      }),
      &quot;data-testid&quot;: &quot;cropper&quot;,
      className: classNames(&#039;reactEasyCrop_CropArea&#039;, cropShape === &#039;round&#039; &amp;&amp; &#039;reactEasyCrop_CropAreaRound&#039;, showGrid &amp;&amp; &#039;reactEasyCrop_CropAreaGrid&#039;, cropAreaClassName)
    }));
  };
  Cropper.defaultProps = {
    zoom: 1,
    rotation: 0,
    aspect: 4 / 3,
    maxZoom: index_module_MAX_ZOOM,
    minZoom: index_module_MIN_ZOOM,
    cropShape: &#039;rect&#039;,
    objectFit: &#039;contain&#039;,
    showGrid: true,
    style: {},
    classes: {},
    mediaProps: {},
    zoomSpeed: 1,
    restrictPosition: true,
    zoomWithScroll: true
  };
  Cropper.getMousePoint = function (e) {
    return {
      x: Number(e.clientX),
      y: Number(e.clientY)
    };
  };
  Cropper.getTouchPoint = function (touch) {
    return {
      x: Number(touch.clientX),
      y: Number(touch.clientY)
    };
  };
  return Cropper;
}(external_React_.Component);



;// ./node_modules/@wordpress/block-editor/build-module/components/image-editor/cropper.js
/**
 * External dependencies
 */



/**
 * WordPress dependencies
 */



/**
 * Internal dependencies
 */



function ImageCropper({
  url,
  width,
  height,
  naturalHeight,
  naturalWidth,
  borderProps
}) {
  const {
    isInProgress,
    editedUrl,
    position,
    zoom,
    aspect,
    setPosition,
    setCrop,
    setZoom,
    rotation
  } = useImageEditingContext();
  const [contentResizeListener, {
    width: clientWidth
  }] = (0,external_wp_compose_namespaceObject.useResizeObserver)();
  let editedHeight = height || clientWidth * naturalHeight / naturalWidth;
  if (rotation % 180 === 90) {
    editedHeight = clientWidth * naturalWidth / naturalHeight;
  }
  const area = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;div&quot;, {
    className: dist_clsx(&#039;wp-block-image__crop-area&#039;, borderProps?.className, {
      &#039;is-applying&#039;: isInProgress
    }),
    style: {
      ...borderProps?.style,
      width: width || clientWidth,
      height: editedHeight
    },
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Cropper, {
      image: editedUrl || url,
      disabled: isInProgress,
      minZoom: MIN_ZOOM / 100,
      maxZoom: MAX_ZOOM / 100,
      crop: position,
      zoom: zoom / 100,
      aspect: aspect,
      onCropChange: pos =&gt; {
        setPosition(pos);
      },
      onCropComplete: newCropPercent =&gt; {
        setCrop(newCropPercent);
      },
      onZoomChange: newZoom =&gt; {
        setZoom(newZoom * 100);
      }
    }), isInProgress &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Spinner, {})]
  });
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
    children: [contentResizeListener, area]
  });
}

;// ./node_modules/@wordpress/icons/build-module/library/search.js
/**
 * WordPress dependencies
 */


const search = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;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&quot;
  })
});
/* harmony default export */ const library_search = (search);

;// ./node_modules/@wordpress/block-editor/build-module/components/image-editor/zoom-dropdown.js
/**
 * WordPress dependencies
 */




/**
 * Internal dependencies
 */



function ZoomDropdown() {
  const {
    isInProgress,
    zoom,
    setZoom
  } = useImageEditingContext();
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Dropdown, {
    contentClassName: &quot;wp-block-image__zoom&quot;,
    popoverProps: constants_POPOVER_PROPS,
    renderToggle: ({
      isOpen,
      onToggle
    }) =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarButton, {
      icon: library_search,
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Zoom&#039;),
      onClick: onToggle,
      &quot;aria-expanded&quot;: isOpen,
      disabled: isInProgress
    }),
    renderContent: () =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalDropdownContentWrapper, {
      paddingSize: &quot;medium&quot;,
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.RangeControl, {
        __next40pxDefaultSize: true,
        __nextHasNoMarginBottom: true,
        label: (0,external_wp_i18n_namespaceObject.__)(&#039;Zoom&#039;),
        min: MIN_ZOOM,
        max: MAX_ZOOM,
        value: Math.round(zoom),
        onChange: setZoom
      })
    })
  });
}

;// ./node_modules/@wordpress/icons/build-module/library/rotate-right.js
/**
 * WordPress dependencies
 */


const rotateRight = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;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&quot;
  })
});
/* harmony default export */ const rotate_right = (rotateRight);

;// ./node_modules/@wordpress/block-editor/build-module/components/image-editor/rotation-button.js
/**
 * WordPress dependencies
 */





/**
 * Internal dependencies
 */


function RotationButton() {
  const {
    isInProgress,
    rotateClockwise
  } = useImageEditingContext();
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarButton, {
    icon: rotate_right,
    label: (0,external_wp_i18n_namespaceObject.__)(&#039;Rotate&#039;),
    onClick: rotateClockwise,
    disabled: isInProgress
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/image-editor/form-controls.js
/**
 * WordPress dependencies
 */



/**
 * Internal dependencies
 */


function FormControls() {
  const {
    isInProgress,
    apply,
    cancel
  } = useImageEditingContext();
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarButton, {
      onClick: apply,
      disabled: isInProgress,
      children: (0,external_wp_i18n_namespaceObject.__)(&#039;Apply&#039;)
    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarButton, {
      onClick: cancel,
      children: (0,external_wp_i18n_namespaceObject.__)(&#039;Cancel&#039;)
    })]
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/image-editor/index.js
/**
 * WordPress dependencies
 */


/**
 * Internal dependencies
 */








function ImageEditor({
  id,
  url,
  width,
  height,
  naturalHeight,
  naturalWidth,
  onSaveImage,
  onFinishEditing,
  borderProps
}) {
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(ImageEditingProvider, {
    id: id,
    url: url,
    naturalWidth: naturalWidth,
    naturalHeight: naturalHeight,
    onSaveImage: onSaveImage,
    onFinishEditing: onFinishEditing,
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ImageCropper, {
      borderProps: borderProps,
      url: url,
      width: width,
      height: height,
      naturalHeight: naturalHeight,
      naturalWidth: naturalWidth
    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(block_controls, {
      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.ToolbarGroup, {
        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ZoomDropdown, {}), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarItem, {
          children: toggleProps =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(AspectRatioDropdown, {
            toggleProps: toggleProps
          })
        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(RotationButton, {})]
      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarGroup, {
        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(FormControls, {})
      })]
    })]
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/image-size-control/use-dimension-handler.js
/**
 * WordPress dependencies
 */

function useDimensionHandler(customHeight, customWidth, defaultHeight, defaultWidth, onChange) {
  var _ref, _ref2;
  const [currentWidth, setCurrentWidth] = (0,external_wp_element_namespaceObject.useState)((_ref = customWidth !== null &amp;&amp; customWidth !== void 0 ? customWidth : defaultWidth) !== null &amp;&amp; _ref !== void 0 ? _ref : &#039;&#039;);
  const [currentHeight, setCurrentHeight] = (0,external_wp_element_namespaceObject.useState)((_ref2 = customHeight !== null &amp;&amp; customHeight !== void 0 ? customHeight : defaultHeight) !== null &amp;&amp; _ref2 !== void 0 ? _ref2 : &#039;&#039;);

  // When an image is first inserted, the default dimensions are initially
  // undefined. This effect updates the dimensions when the default values
  // come through.
  (0,external_wp_element_namespaceObject.useEffect)(() =&gt; {
    if (customWidth === undefined &amp;&amp; defaultWidth !== undefined) {
      setCurrentWidth(defaultWidth);
    }
    if (customHeight === undefined &amp;&amp; defaultHeight !== undefined) {
      setCurrentHeight(defaultHeight);
    }
  }, [defaultWidth, defaultHeight]);

  // If custom values change, it means an outsider has resized the image using some other method (eg resize box)
  // this keeps track of these values too. We need to parse before comparing; custom values can be strings.
  (0,external_wp_element_namespaceObject.useEffect)(() =&gt; {
    if (customWidth !== undefined &amp;&amp; Number.parseInt(customWidth) !== Number.parseInt(currentWidth)) {
      setCurrentWidth(customWidth);
    }
    if (customHeight !== undefined &amp;&amp; Number.parseInt(customHeight) !== Number.parseInt(currentHeight)) {
      setCurrentHeight(customHeight);
    }
  }, [customWidth, customHeight]);
  const updateDimension = (dimension, value) =&gt; {
    const parsedValue = value === &#039;&#039; ? undefined : parseInt(value, 10);
    if (dimension === &#039;width&#039;) {
      setCurrentWidth(parsedValue);
    } else {
      setCurrentHeight(parsedValue);
    }
    onChange({
      [dimension]: parsedValue
    });
  };
  const updateDimensions = (nextHeight, nextWidth) =&gt; {
    setCurrentHeight(nextHeight !== null &amp;&amp; nextHeight !== void 0 ? nextHeight : defaultHeight);
    setCurrentWidth(nextWidth !== null &amp;&amp; nextWidth !== void 0 ? nextWidth : defaultWidth);
    onChange({
      height: nextHeight,
      width: nextWidth
    });
  };
  return {
    currentHeight,
    currentWidth,
    updateDimension,
    updateDimensions
  };
}

;// ./node_modules/@wordpress/block-editor/build-module/components/image-size-control/index.js
/**
 * WordPress dependencies
 */



/**
 * Internal dependencies
 */


const IMAGE_SIZE_PRESETS = [25, 50, 75, 100];
const image_size_control_noop = () =&gt; {};

/**
 * Get scaled width and height for the given scale.
 *
 * @param {number} scale       The scale to get the scaled width and height for.
 * @param {number} imageWidth  The image width.
 * @param {number} imageHeight The image height.
 *
 * @return {Object} The scaled width and height.
 */
function getScaledWidthAndHeight(scale, imageWidth, imageHeight) {
  const scaledWidth = Math.round(imageWidth * (scale / 100));
  const scaledHeight = Math.round(imageHeight * (scale / 100));
  return {
    scaledWidth,
    scaledHeight
  };
}
function ImageSizeControl({
  imageSizeHelp,
  imageWidth,
  imageHeight,
  imageSizeOptions = [],
  isResizable = true,
  slug,
  width,
  height,
  onChange,
  onChangeImage = image_size_control_noop
}) {
  const {
    currentHeight,
    currentWidth,
    updateDimension,
    updateDimensions
  } = useDimensionHandler(height, width, imageHeight, imageWidth, onChange);

  /**
   * Updates the dimensions for the given scale.
   * Handler for toggle group control change.
   *
   * @param {number} scale The scale to update the dimensions for.
   */
  const handleUpdateDimensions = scale =&gt; {
    if (undefined === scale) {
      updateDimensions();
      return;
    }
    const {
      scaledWidth,
      scaledHeight
    } = getScaledWidthAndHeight(scale, imageWidth, imageHeight);
    updateDimensions(scaledHeight, scaledWidth);
  };

  /**
   * Add the stored image preset value to toggle group control.
   */
  const selectedValue = IMAGE_SIZE_PRESETS.find(scale =&gt; {
    const {
      scaledWidth,
      scaledHeight
    } = getScaledWidthAndHeight(scale, imageWidth, imageHeight);
    return currentWidth === scaledWidth &amp;&amp; currentHeight === scaledHeight;
  });
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
    children: [imageSizeOptions &amp;&amp; imageSizeOptions.length &gt; 0 &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.SelectControl, {
      __nextHasNoMarginBottom: true,
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Resolution&#039;),
      value: slug,
      options: imageSizeOptions,
      onChange: onChangeImage,
      help: imageSizeHelp,
      size: &quot;__unstable-large&quot;
    }), isResizable &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;div&quot;, {
      className: &quot;block-editor-image-size-control&quot;,
      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalHStack, {
        align: &quot;baseline&quot;,
        spacing: &quot;3&quot;,
        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalNumberControl, {
          className: &quot;block-editor-image-size-control__width&quot;,
          label: (0,external_wp_i18n_namespaceObject.__)(&#039;Width&#039;),
          value: currentWidth,
          min: 1,
          onChange: value =&gt; updateDimension(&#039;width&#039;, value),
          size: &quot;__unstable-large&quot;
        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalNumberControl, {
          className: &quot;block-editor-image-size-control__height&quot;,
          label: (0,external_wp_i18n_namespaceObject.__)(&#039;Height&#039;),
          value: currentHeight,
          min: 1,
          onChange: value =&gt; updateDimension(&#039;height&#039;, value),
          size: &quot;__unstable-large&quot;
        })]
      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControl, {
        label: (0,external_wp_i18n_namespaceObject.__)(&#039;Image size presets&#039;),
        hideLabelFromVision: true,
        onChange: handleUpdateDimensions,
        value: selectedValue,
        isBlock: true,
        __next40pxDefaultSize: true,
        __nextHasNoMarginBottom: true,
        children: IMAGE_SIZE_PRESETS.map(scale =&gt; {
          return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControlOption, {
            value: scale,
            label: (0,external_wp_i18n_namespaceObject.sprintf)(/* translators: Percentage value. */
            (0,external_wp_i18n_namespaceObject.__)(&#039;%d%%&#039;), scale)
          }, scale);
        })
      })]
    })]
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/url-popover/link-viewer-url.js
/**
 * External dependencies
 */


/**
 * WordPress dependencies
 */



function LinkViewerURL({
  url,
  urlLabel,
  className
}) {
  const linkClassName = dist_clsx(className, &#039;block-editor-url-popover__link-viewer-url&#039;);
  if (!url) {
    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;span&quot;, {
      className: linkClassName
    });
  }
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ExternalLink, {
    className: linkClassName,
    href: url,
    children: urlLabel || (0,external_wp_url_namespaceObject.filterURLForDisplay)((0,external_wp_url_namespaceObject.safeDecodeURI)(url))
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/url-popover/link-viewer.js
/**
 * External dependencies
 */


/**
 * WordPress dependencies
 */




/**
 * Internal dependencies
 */


function LinkViewer({
  className,
  linkClassName,
  onEditLinkClick,
  url,
  urlLabel,
  ...props
}) {
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;div&quot;, {
    className: dist_clsx(&#039;block-editor-url-popover__link-viewer&#039;, className),
    ...props,
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(LinkViewerURL, {
      url: url,
      urlLabel: urlLabel,
      className: linkClassName
    }), onEditLinkClick &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
      icon: edit,
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Edit&#039;),
      onClick: onEditLinkClick,
      size: &quot;compact&quot;
    })]
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/url-popover/link-editor.js
/**
 * External dependencies
 */


/**
 * WordPress dependencies
 */




/**
 * Internal dependencies
 */


function LinkEditor({
  autocompleteRef,
  className,
  onChangeInputValue,
  value,
  ...props
}) {
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;form&quot;, {
    className: dist_clsx(&#039;block-editor-url-popover__link-editor&#039;, className),
    ...props,
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(url_input, {
      value: value,
      onChange: onChangeInputValue,
      autocompleteRef: autocompleteRef
    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
      icon: keyboard_return,
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Apply&#039;),
      type: &quot;submit&quot;,
      size: &quot;compact&quot;
    })]
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/url-popover/index.js
/**
 * WordPress dependencies
 */






/**
 * Internal dependencies
 */




const {
  __experimentalPopoverLegacyPositionToPlacement
} = unlock(external_wp_components_namespaceObject.privateApis);
const DEFAULT_PLACEMENT = &#039;bottom&#039;;
const URLPopover = (0,external_wp_element_namespaceObject.forwardRef)(({
  additionalControls,
  children,
  renderSettings,
  // The DEFAULT_PLACEMENT value is assigned inside the function&#039;s body
  placement,
  focusOnMount = &#039;firstElement&#039;,
  // Deprecated
  position,
  // Rest
  ...popoverProps
}, ref) =&gt; {
  if (position !== undefined) {
    external_wp_deprecated_default()(&#039;`position` prop in wp.blockEditor.URLPopover&#039;, {
      since: &#039;6.2&#039;,
      alternative: &#039;`placement` prop&#039;
    });
  }

  // Compute popover&#039;s placement:
  // - give priority to `placement` prop, if defined
  // - otherwise, compute it from the legacy `position` prop (if defined)
  // - finally, fallback to the DEFAULT_PLACEMENT.
  let computedPlacement;
  if (placement !== undefined) {
    computedPlacement = placement;
  } else if (position !== undefined) {
    computedPlacement = __experimentalPopoverLegacyPositionToPlacement(position);
  }
  computedPlacement = computedPlacement || DEFAULT_PLACEMENT;
  const [isSettingsExpanded, setIsSettingsExpanded] = (0,external_wp_element_namespaceObject.useState)(false);
  const showSettings = !!renderSettings &amp;&amp; isSettingsExpanded;
  const toggleSettingsVisibility = () =&gt; {
    setIsSettingsExpanded(!isSettingsExpanded);
  };
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.Popover, {
    ref: ref,
    role: &quot;dialog&quot;,
    &quot;aria-modal&quot;: &quot;true&quot;,
    &quot;aria-label&quot;: (0,external_wp_i18n_namespaceObject.__)(&#039;Edit URL&#039;),
    className: &quot;block-editor-url-popover&quot;,
    focusOnMount: focusOnMount,
    placement: computedPlacement,
    shift: true,
    variant: &quot;toolbar&quot;,
    ...popoverProps,
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
      className: &quot;block-editor-url-popover__input-container&quot;,
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;div&quot;, {
        className: &quot;block-editor-url-popover__row&quot;,
        children: [children, !!renderSettings &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
          className: &quot;block-editor-url-popover__settings-toggle&quot;,
          icon: chevron_down,
          label: (0,external_wp_i18n_namespaceObject.__)(&#039;Link settings&#039;),
          onClick: toggleSettingsVisibility,
          &quot;aria-expanded&quot;: isSettingsExpanded,
          size: &quot;compact&quot;
        })]
      })
    }), showSettings &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
      className: &quot;block-editor-url-popover__settings&quot;,
      children: renderSettings()
    }), additionalControls &amp;&amp; !showSettings &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
      className: &quot;block-editor-url-popover__additional-controls&quot;,
      children: additionalControls
    })]
  });
});
URLPopover.LinkEditor = LinkEditor;
URLPopover.LinkViewer = LinkViewer;

/**
 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/url-popover/README.md
 */
/* harmony default export */ const url_popover = (URLPopover);

;// ./node_modules/@wordpress/block-editor/build-module/components/media-placeholder/index.js
/**
 * External dependencies
 */


/**
 * WordPress dependencies
 */







/**
 * Internal dependencies
 */






const media_placeholder_noop = () =&gt; {};
const InsertFromURLPopover = ({
  src,
  onChange,
  onSubmit,
  onClose,
  popoverAnchor
}) =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(url_popover, {
  anchor: popoverAnchor,
  onClose: onClose,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;form&quot;, {
    className: &quot;block-editor-media-placeholder__url-input-form&quot;,
    onSubmit: onSubmit,
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalInputControl, {
      __next40pxDefaultSize: true,
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;URL&#039;),
      type: &quot;url&quot;,
      hideLabelFromVision: true,
      placeholder: (0,external_wp_i18n_namespaceObject.__)(&#039;Paste or type URL&#039;),
      onChange: onChange,
      value: src,
      suffix: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalInputControlSuffixWrapper, {
        variant: &quot;control&quot;,
        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
          size: &quot;small&quot;,
          icon: keyboard_return,
          label: (0,external_wp_i18n_namespaceObject.__)(&#039;Apply&#039;),
          type: &quot;submit&quot;
        })
      })
    })
  })
});
const URLSelectionUI = ({
  src,
  onChangeSrc,
  onSelectURL
}) =&gt; {
  // Use internal state instead of a ref to make sure that the component
  // re-renders when the popover&#039;s anchor updates.
  const [popoverAnchor, setPopoverAnchor] = (0,external_wp_element_namespaceObject.useState)(null);
  const [isURLInputVisible, setIsURLInputVisible] = (0,external_wp_element_namespaceObject.useState)(false);
  const openURLInput = () =&gt; {
    setIsURLInputVisible(true);
  };
  const closeURLInput = () =&gt; {
    setIsURLInputVisible(false);
    popoverAnchor?.focus();
  };
  const onSubmitSrc = event =&gt; {
    event.preventDefault();
    if (src &amp;&amp; onSelectURL) {
      onSelectURL(src);
      closeURLInput();
    }
  };
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;div&quot;, {
    className: &quot;block-editor-media-placeholder__url-input-container&quot;,
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
      __next40pxDefaultSize: true,
      className: &quot;block-editor-media-placeholder__button&quot;,
      onClick: openURLInput,
      isPressed: isURLInputVisible,
      variant: &quot;secondary&quot;,
      &quot;aria-haspopup&quot;: &quot;dialog&quot;,
      ref: setPopoverAnchor,
      children: (0,external_wp_i18n_namespaceObject.__)(&#039;Insert from URL&#039;)
    }), isURLInputVisible &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(InsertFromURLPopover, {
      src: src,
      onChange: onChangeSrc,
      onSubmit: onSubmitSrc,
      onClose: closeURLInput,
      popoverAnchor: popoverAnchor
    })]
  });
};
function MediaPlaceholder({
  value = {},
  allowedTypes,
  className,
  icon,
  labels = {},
  mediaPreview,
  notices,
  isAppender,
  accept,
  addToGallery,
  multiple = false,
  handleUpload = true,
  disableDropZone,
  disableMediaButtons,
  onError,
  onSelect,
  onCancel,
  onSelectURL,
  onToggleFeaturedImage,
  onDoubleClick,
  onFilesPreUpload = media_placeholder_noop,
  onHTMLDrop: deprecatedOnHTMLDrop,
  children,
  mediaLibraryButton,
  placeholder,
  style
}) {
  if (deprecatedOnHTMLDrop) {
    external_wp_deprecated_default()(&#039;wp.blockEditor.MediaPlaceholder onHTMLDrop prop&#039;, {
      since: &#039;6.2&#039;,
      version: &#039;6.4&#039;
    });
  }
  const mediaUpload = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      getSettings
    } = select(store);
    return getSettings().mediaUpload;
  }, []);
  const [src, setSrc] = (0,external_wp_element_namespaceObject.useState)(&#039;&#039;);
  (0,external_wp_element_namespaceObject.useEffect)(() =&gt; {
    var _value$src;
    setSrc((_value$src = value?.src) !== null &amp;&amp; _value$src !== void 0 ? _value$src : &#039;&#039;);
  }, [value?.src]);
  const onlyAllowsImages = () =&gt; {
    if (!allowedTypes || allowedTypes.length === 0) {
      return false;
    }
    return allowedTypes.every(allowedType =&gt; allowedType === &#039;image&#039; || allowedType.startsWith(&#039;image/&#039;));
  };
  const onFilesUpload = files =&gt; {
    if (!handleUpload || typeof handleUpload === &#039;function&#039; &amp;&amp; !handleUpload(files)) {
      return onSelect(files);
    }
    onFilesPreUpload(files);
    let setMedia;
    if (multiple) {
      if (addToGallery) {
        // Since the setMedia function runs multiple times per upload group
        // and is passed newMedia containing every item in its group each time, we must
        // filter out whatever this upload group had previously returned to the
        // gallery before adding and returning the image array with replacement newMedia
        // values.

        // Define an array to store urls from newMedia between subsequent function calls.
        let lastMediaPassed = [];
        setMedia = newMedia =&gt; {
          // Remove any images this upload group is responsible for (lastMediaPassed).
          // Their replacements are contained in newMedia.
          const filteredMedia = (value !== null &amp;&amp; value !== void 0 ? value : []).filter(item =&gt; {
            // If Item has id, only remove it if lastMediaPassed has an item with that id.
            if (item.id) {
              return !lastMediaPassed.some(
              // Be sure to convert to number for comparison.
              ({
                id
              }) =&gt; Number(id) === Number(item.id));
            }
            // Compare transient images via .includes since gallery may append extra info onto the url.
            return !lastMediaPassed.some(({
              urlSlug
            }) =&gt; item.url.includes(urlSlug));
          });
          // Return the filtered media array along with newMedia.
          onSelect(filteredMedia.concat(newMedia));
          // Reset lastMediaPassed and set it with ids and urls from newMedia.
          lastMediaPassed = newMedia.map(media =&gt; {
            // Add everything up to &#039;.fileType&#039; to compare via .includes.
            const cutOffIndex = media.url.lastIndexOf(&#039;.&#039;);
            const urlSlug = media.url.slice(0, cutOffIndex);
            return {
              id: media.id,
              urlSlug
            };
          });
        };
      } else {
        setMedia = onSelect;
      }
    } else {
      setMedia = ([media]) =&gt; onSelect(media);
    }
    mediaUpload({
      allowedTypes,
      filesList: files,
      onFileChange: setMedia,
      onError,
      multiple
    });
  };
  async function handleBlocksDrop(event) {
    const {
      blocks
    } = parseDropEvent(event);
    if (!blocks?.length) {
      return;
    }
    const uploadedMediaList = await Promise.all(blocks.map(block =&gt; {
      const blockType = block.name.split(&#039;/&#039;)[1];
      if (block.attributes.id) {
        block.attributes.type = blockType;
        return block.attributes;
      }
      return new Promise((resolve, reject) =&gt; {
        window.fetch(block.attributes.url).then(response =&gt; response.blob()).then(blob =&gt; mediaUpload({
          filesList: [blob],
          additionalData: {
            title: block.attributes.title,
            alt_text: block.attributes.alt,
            caption: block.attributes.caption,
            type: blockType
          },
          onFileChange: ([media]) =&gt; {
            if (media.id) {
              resolve(media);
            }
          },
          allowedTypes,
          onError: reject
        })).catch(() =&gt; resolve(block.attributes.url));
      });
    })).catch(err =&gt; onError(err));
    if (multiple) {
      onSelect(uploadedMediaList);
    } else {
      onSelect(uploadedMediaList[0]);
    }
  }
  const onUpload = event =&gt; {
    onFilesUpload(event.target.files);
  };
  const defaultRenderPlaceholder = content =&gt; {
    let {
      instructions,
      title
    } = labels;
    if (!mediaUpload &amp;&amp; !onSelectURL) {
      instructions = (0,external_wp_i18n_namespaceObject.__)(&#039;To edit this block, you need permission to upload media.&#039;);
    }
    if (instructions === undefined || title === undefined) {
      const typesAllowed = allowedTypes !== null &amp;&amp; allowedTypes !== void 0 ? allowedTypes : [];
      const [firstAllowedType] = typesAllowed;
      const isOneType = 1 === typesAllowed.length;
      const isAudio = isOneType &amp;&amp; &#039;audio&#039; === firstAllowedType;
      const isImage = isOneType &amp;&amp; &#039;image&#039; === firstAllowedType;
      const isVideo = isOneType &amp;&amp; &#039;video&#039; === firstAllowedType;
      if (instructions === undefined &amp;&amp; mediaUpload) {
        instructions = (0,external_wp_i18n_namespaceObject.__)(&#039;Drag and drop an image or video, upload, or choose from your library.&#039;);
        if (isAudio) {
          instructions = (0,external_wp_i18n_namespaceObject.__)(&#039;Drag and drop an audio file, upload, or choose from your library.&#039;);
        } else if (isImage) {
          instructions = (0,external_wp_i18n_namespaceObject.__)(&#039;Drag and drop an image, upload, or choose from your library.&#039;);
        } else if (isVideo) {
          instructions = (0,external_wp_i18n_namespaceObject.__)(&#039;Drag and drop a video, upload, or choose from your library.&#039;);
        }
      }
      if (title === undefined) {
        title = (0,external_wp_i18n_namespaceObject.__)(&#039;Media&#039;);
        if (isAudio) {
          title = (0,external_wp_i18n_namespaceObject.__)(&#039;Audio&#039;);
        } else if (isImage) {
          title = (0,external_wp_i18n_namespaceObject.__)(&#039;Image&#039;);
        } else if (isVideo) {
          title = (0,external_wp_i18n_namespaceObject.__)(&#039;Video&#039;);
        }
      }
    }
    const placeholderClassName = dist_clsx(&#039;block-editor-media-placeholder&#039;, className, {
      &#039;is-appender&#039;: isAppender
    });
    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.Placeholder, {
      icon: icon,
      label: title,
      instructions: instructions,
      className: placeholderClassName,
      notices: notices,
      onDoubleClick: onDoubleClick,
      preview: mediaPreview,
      style: style,
      children: [content, children]
    });
  };
  const renderPlaceholder = placeholder !== null &amp;&amp; placeholder !== void 0 ? placeholder : defaultRenderPlaceholder;
  const renderDropZone = () =&gt; {
    if (disableDropZone) {
      return null;
    }
    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.DropZone, {
      onFilesDrop: onFilesUpload,
      onDrop: handleBlocksDrop,
      isEligible: dataTransfer =&gt; {
        const prefix = &#039;wp-block:core/&#039;;
        const types = [];
        for (const type of dataTransfer.types) {
          if (type.startsWith(prefix)) {
            types.push(type.slice(prefix.length));
          }
        }
        return types.every(type =&gt; allowedTypes.includes(type)) &amp;&amp; (multiple ? true : types.length === 1);
      }
    });
  };
  const renderCancelLink = () =&gt; {
    return onCancel &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
      __next40pxDefaultSize: true,
      className: &quot;block-editor-media-placeholder__cancel-button&quot;,
      title: (0,external_wp_i18n_namespaceObject.__)(&#039;Cancel&#039;),
      variant: &quot;link&quot;,
      onClick: onCancel,
      children: (0,external_wp_i18n_namespaceObject.__)(&#039;Cancel&#039;)
    });
  };
  const renderUrlSelectionUI = () =&gt; {
    return onSelectURL &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(URLSelectionUI, {
      src: src,
      onChangeSrc: setSrc,
      onSelectURL: onSelectURL
    });
  };
  const renderFeaturedImageToggle = () =&gt; {
    return onToggleFeaturedImage &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
      className: &quot;block-editor-media-placeholder__url-input-container&quot;,
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
        __next40pxDefaultSize: true,
        className: &quot;block-editor-media-placeholder__button&quot;,
        onClick: onToggleFeaturedImage,
        variant: &quot;secondary&quot;,
        children: (0,external_wp_i18n_namespaceObject.__)(&#039;Use featured image&#039;)
      })
    });
  };
  const renderMediaUploadChecked = () =&gt; {
    const defaultButton = ({
      open
    }) =&gt; {
      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
        __next40pxDefaultSize: true,
        variant: &quot;secondary&quot;,
        onClick: () =&gt; {
          open();
        },
        children: (0,external_wp_i18n_namespaceObject.__)(&#039;Media Library&#039;)
      });
    };
    const libraryButton = mediaLibraryButton !== null &amp;&amp; mediaLibraryButton !== void 0 ? mediaLibraryButton : defaultButton;
    const uploadMediaLibraryButton = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(media_upload, {
      addToGallery: addToGallery,
      gallery: multiple &amp;&amp; onlyAllowsImages(),
      multiple: multiple,
      onSelect: onSelect,
      allowedTypes: allowedTypes,
      mode: &quot;browse&quot;,
      value: Array.isArray(value) ? value.map(({
        id
      }) =&gt; id) : value.id,
      render: libraryButton
    });
    if (mediaUpload &amp;&amp; isAppender) {
      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
        children: [renderDropZone(), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FormFileUpload, {
          onChange: onUpload,
          accept: accept,
          multiple: !!multiple,
          render: ({
            openFileDialog
          }) =&gt; {
            const content = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
              children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
                __next40pxDefaultSize: true,
                variant: &quot;primary&quot;,
                className: dist_clsx(&#039;block-editor-media-placeholder__button&#039;, &#039;block-editor-media-placeholder__upload-button&#039;),
                onClick: openFileDialog,
                children: (0,external_wp_i18n_namespaceObject._x)(&#039;Upload&#039;, &#039;verb&#039;)
              }), uploadMediaLibraryButton, renderUrlSelectionUI(), renderFeaturedImageToggle(), renderCancelLink()]
            });
            return renderPlaceholder(content);
          }
        })]
      });
    }
    if (mediaUpload) {
      const content = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
        children: [renderDropZone(), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FormFileUpload, {
          render: ({
            openFileDialog
          }) =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
            __next40pxDefaultSize: true,
            onClick: openFileDialog,
            variant: &quot;primary&quot;,
            className: dist_clsx(&#039;block-editor-media-placeholder__button&#039;, &#039;block-editor-media-placeholder__upload-button&#039;),
            children: (0,external_wp_i18n_namespaceObject._x)(&#039;Upload&#039;, &#039;verb&#039;)
          }),
          onChange: onUpload,
          accept: accept,
          multiple: !!multiple
        }), uploadMediaLibraryButton, renderUrlSelectionUI(), renderFeaturedImageToggle(), renderCancelLink()]
      });
      return renderPlaceholder(content);
    }
    return renderPlaceholder(uploadMediaLibraryButton);
  };
  if (disableMediaButtons) {
    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(check, {
      children: renderDropZone()
    });
  }
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(check, {
    fallback: renderPlaceholder(renderUrlSelectionUI()),
    children: renderMediaUploadChecked()
  });
}

/**
 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/media-placeholder/README.md
 */
/* harmony default export */ const media_placeholder = ((0,external_wp_components_namespaceObject.withFilters)(&#039;editor.MediaPlaceholder&#039;)(MediaPlaceholder));

;// ./node_modules/@wordpress/block-editor/build-module/components/panel-color-settings/index.js
/**
 * Internal dependencies
 */


const PanelColorSettings = ({
  colorSettings,
  ...props
}) =&gt; {
  const settings = colorSettings.map(setting =&gt; {
    if (!setting) {
      return setting;
    }
    const {
      value,
      onChange,
      ...otherSettings
    } = setting;
    return {
      ...otherSettings,
      colorValue: value,
      onColorChange: onChange
    };
  });
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(panel_color_gradient_settings, {
    settings: settings,
    gradients: [],
    disableCustomGradients: true,
    ...props
  });
};
/* harmony default export */ const panel_color_settings = (PanelColorSettings);

;// ./node_modules/@wordpress/block-editor/build-module/components/rich-text/format-toolbar/index.js
/**
 * External dependencies
 */


/**
 * WordPress dependencies
 */




/**
 * Internal dependencies
 */


const format_toolbar_POPOVER_PROPS = {
  placement: &#039;bottom-start&#039;
};
const FormatToolbar = () =&gt; {
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
    children: [[&#039;bold&#039;, &#039;italic&#039;, &#039;link&#039;, &#039;unknown&#039;].map(format =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Slot, {
      name: `RichText.ToolbarControls.${format}`
    }, format)), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Slot, {
      name: &quot;RichText.ToolbarControls&quot;,
      children: fills =&gt; {
        if (!fills.length) {
          return null;
        }
        const allProps = fills.map(([{
          props
        }]) =&gt; props);
        const hasActive = allProps.some(({
          isActive
        }) =&gt; isActive);
        return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarItem, {
          children: toggleProps =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.DropdownMenu, {
            icon: chevron_down
            /* translators: button label text should, if possible, be under 16 characters. */,
            label: (0,external_wp_i18n_namespaceObject.__)(&#039;More&#039;),
            toggleProps: {
              ...toggleProps,
              className: dist_clsx(toggleProps.className, {
                &#039;is-pressed&#039;: hasActive
              }),
              description: (0,external_wp_i18n_namespaceObject.__)(&#039;Displays more block tools&#039;)
            },
            controls: orderBy(fills.map(([{
              props
            }]) =&gt; props), &#039;title&#039;),
            popoverProps: format_toolbar_POPOVER_PROPS
          })
        });
      }
    })]
  });
};
/* harmony default export */ const format_toolbar = (FormatToolbar);

;// ./node_modules/@wordpress/block-editor/build-module/components/rich-text/format-toolbar-container.js
/**
 * WordPress dependencies
 */



/**
 * Internal dependencies
 */




function InlineToolbar({
  popoverAnchor
}) {
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Popover, {
    placement: &quot;top&quot;,
    focusOnMount: false,
    anchor: popoverAnchor,
    className: &quot;block-editor-rich-text__inline-format-toolbar&quot;,
    __unstableSlotName: &quot;block-toolbar&quot;,
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(NavigableToolbar, {
      className: &quot;block-editor-rich-text__inline-format-toolbar-group&quot;
      /* translators: accessibility text for the inline format toolbar */,
      &quot;aria-label&quot;: (0,external_wp_i18n_namespaceObject.__)(&#039;Format tools&#039;),
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarGroup, {
        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(format_toolbar, {})
      })
    })
  });
}
const FormatToolbarContainer = ({
  inline,
  editableContentElement
}) =&gt; {
  if (inline) {
    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(InlineToolbar, {
      popoverAnchor: editableContentElement
    });
  }

  // Render regular toolbar.
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_controls, {
    group: &quot;inline&quot;,
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(format_toolbar, {})
  });
};
/* harmony default export */ const format_toolbar_container = (FormatToolbarContainer);

;// ./node_modules/@wordpress/block-editor/build-module/components/rich-text/use-mark-persistent.js
/**
 * WordPress dependencies
 */



/**
 * Internal dependencies
 */

function useMarkPersistent({
  html,
  value
}) {
  const previousTextRef = (0,external_wp_element_namespaceObject.useRef)();
  const hasActiveFormats = !!value.activeFormats?.length;
  const {
    __unstableMarkLastChangeAsPersistent
  } = (0,external_wp_data_namespaceObject.useDispatch)(store);

  // Must be set synchronously to make sure it applies to the last change.
  (0,external_wp_element_namespaceObject.useLayoutEffect)(() =&gt; {
    // Ignore mount.
    if (!previousTextRef.current) {
      previousTextRef.current = value.text;
      return;
    }

    // Text input, so don&#039;t create an undo level for every character.
    // Create an undo level after 1 second of no input.
    if (previousTextRef.current !== value.text) {
      const timeout = window.setTimeout(() =&gt; {
        __unstableMarkLastChangeAsPersistent();
      }, 1000);
      previousTextRef.current = value.text;
      return () =&gt; {
        window.clearTimeout(timeout);
      };
    }
    __unstableMarkLastChangeAsPersistent();
  }, [html, hasActiveFormats]);
}

;// ./node_modules/@wordpress/block-editor/build-module/components/rich-text/use-format-types.js
/**
 * WordPress dependencies
 */



function formatTypesSelector(select) {
  return select(external_wp_richText_namespaceObject.store).getFormatTypes();
}

/**
 * Set of all interactive content tags.
 *
 * @see https://html.spec.whatwg.org/multipage/dom.html#interactive-content
 */
const interactiveContentTags = new Set([&#039;a&#039;, &#039;audio&#039;, &#039;button&#039;, &#039;details&#039;, &#039;embed&#039;, &#039;iframe&#039;, &#039;input&#039;, &#039;label&#039;, &#039;select&#039;, &#039;textarea&#039;, &#039;video&#039;]);
function prefixSelectKeys(selected, prefix) {
  if (typeof selected !== &#039;object&#039;) {
    return {
      [prefix]: selected
    };
  }
  return Object.fromEntries(Object.entries(selected).map(([key, value]) =&gt; [`${prefix}.${key}`, value]));
}
function getPrefixedSelectKeys(selected, prefix) {
  if (selected[prefix]) {
    return selected[prefix];
  }
  return Object.keys(selected).filter(key =&gt; key.startsWith(prefix + &#039;.&#039;)).reduce((accumulator, key) =&gt; {
    accumulator[key.slice(prefix.length + 1)] = selected[key];
    return accumulator;
  }, {});
}

/**
 * This hook provides RichText with the `formatTypes` and its derived props from
 * experimental format type settings.
 *
 * @param {Object}  $0                              Options
 * @param {string}  $0.clientId                     Block client ID.
 * @param {string}  $0.identifier                   Block attribute.
 * @param {boolean} $0.withoutInteractiveFormatting Whether to clean the interactive formatting or not.
 * @param {Array}   $0.allowedFormats               Allowed formats
 */
function useFormatTypes({
  clientId,
  identifier,
  withoutInteractiveFormatting,
  allowedFormats
}) {
  const allFormatTypes = (0,external_wp_data_namespaceObject.useSelect)(formatTypesSelector, []);
  const formatTypes = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; {
    return allFormatTypes.filter(({
      name,
      interactive,
      tagName
    }) =&gt; {
      if (allowedFormats &amp;&amp; !allowedFormats.includes(name)) {
        return false;
      }
      if (withoutInteractiveFormatting &amp;&amp; (interactive || interactiveContentTags.has(tagName))) {
        return false;
      }
      return true;
    });
  }, [allFormatTypes, allowedFormats, withoutInteractiveFormatting]);
  const keyedSelected = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; formatTypes.reduce((accumulator, type) =&gt; {
    if (!type.__experimentalGetPropsForEditableTreePreparation) {
      return accumulator;
    }
    return {
      ...accumulator,
      ...prefixSelectKeys(type.__experimentalGetPropsForEditableTreePreparation(select, {
        richTextIdentifier: identifier,
        blockClientId: clientId
      }), type.name)
    };
  }, {}), [formatTypes, clientId, identifier]);
  const dispatch = (0,external_wp_data_namespaceObject.useDispatch)();
  const prepareHandlers = [];
  const valueHandlers = [];
  const changeHandlers = [];
  const dependencies = [];
  for (const key in keyedSelected) {
    dependencies.push(keyedSelected[key]);
  }
  formatTypes.forEach(type =&gt; {
    if (type.__experimentalCreatePrepareEditableTree) {
      const handler = type.__experimentalCreatePrepareEditableTree(getPrefixedSelectKeys(keyedSelected, type.name), {
        richTextIdentifier: identifier,
        blockClientId: clientId
      });
      if (type.__experimentalCreateOnChangeEditableValue) {
        valueHandlers.push(handler);
      } else {
        prepareHandlers.push(handler);
      }
    }
    if (type.__experimentalCreateOnChangeEditableValue) {
      let dispatchers = {};
      if (type.__experimentalGetPropsForEditableTreeChangeHandler) {
        dispatchers = type.__experimentalGetPropsForEditableTreeChangeHandler(dispatch, {
          richTextIdentifier: identifier,
          blockClientId: clientId
        });
      }
      const selected = getPrefixedSelectKeys(keyedSelected, type.name);
      changeHandlers.push(type.__experimentalCreateOnChangeEditableValue({
        ...(typeof selected === &#039;object&#039; ? selected : {}),
        ...dispatchers
      }, {
        richTextIdentifier: identifier,
        blockClientId: clientId
      }));
    }
  });
  return {
    formatTypes,
    prepareHandlers,
    valueHandlers,
    changeHandlers,
    dependencies
  };
}

;// ./node_modules/@wordpress/block-editor/build-module/components/rich-text/event-listeners/before-input-rules.js
/**
 * WordPress dependencies
 */



/**
 * Internal dependencies
 */


/**
 * When typing over a selection, the selection will we wrapped by a matching
 * character pair. The second character is optional, it defaults to the first
 * character.
 *
 * @type {string[]} Array of character pairs.
 */
const wrapSelectionSettings = [&#039;`&#039;, &#039;&quot;&#039;, &quot;&#039;&quot;, &#039;“”&#039;, &#039;‘’&#039;];
/* harmony default export */ const before_input_rules = (props =&gt; element =&gt; {
  function onInput(event) {
    const {
      inputType,
      data
    } = event;
    const {
      value,
      onChange,
      registry
    } = props.current;

    // Only run the rules when inserting text.
    if (inputType !== &#039;insertText&#039;) {
      return;
    }
    if ((0,external_wp_richText_namespaceObject.isCollapsed)(value)) {
      return;
    }
    const pair = (0,external_wp_hooks_namespaceObject.applyFilters)(&#039;blockEditor.wrapSelectionSettings&#039;, wrapSelectionSettings).find(([startChar, endChar]) =&gt; startChar === data || endChar === data);
    if (!pair) {
      return;
    }
    const [startChar, endChar = startChar] = pair;
    const start = value.start;
    const end = value.end + startChar.length;
    let newValue = (0,external_wp_richText_namespaceObject.insert)(value, startChar, start, start);
    newValue = (0,external_wp_richText_namespaceObject.insert)(newValue, endChar, end, end);
    const {
      __unstableMarkLastChangeAsPersistent,
      __unstableMarkAutomaticChange
    } = registry.dispatch(store);
    __unstableMarkLastChangeAsPersistent();
    onChange(newValue);
    __unstableMarkAutomaticChange();
    const init = {};
    for (const key in event) {
      init[key] = event[key];
    }
    init.data = endChar;
    const {
      ownerDocument
    } = element;
    const {
      defaultView
    } = ownerDocument;
    const newEvent = new defaultView.InputEvent(&#039;input&#039;, init);

    // Dispatch an `input` event with the new data. This will trigger the
    // input rules.
    // Postpone the `input` to the next event loop tick so that the dispatch
    // doesn&#039;t happen synchronously in the middle of `beforeinput` dispatch.
    // This is closer to how native `input` event would be timed, and also
    // makes sure that the `input` event is dispatched only after the `onChange`
    // call few lines above has fully updated the data store state and rerendered
    // all affected components.
    window.queueMicrotask(() =&gt; {
      event.target.dispatchEvent(newEvent);
    });
    event.preventDefault();
  }
  element.addEventListener(&#039;beforeinput&#039;, onInput);
  return () =&gt; {
    element.removeEventListener(&#039;beforeinput&#039;, onInput);
  };
});

;// ./node_modules/@wordpress/block-editor/build-module/components/rich-text/prevent-event-discovery.js
/**
 * WordPress dependencies
 */

function preventEventDiscovery(value) {
  const searchText = &#039;tales of gutenberg&#039;;
  const addText = &#039; �ŸĦ�Ÿ˘�ŸĤ€�Ÿ¤�ŸĤ‹�Ÿ˜�Ÿ§�Ÿı�ŸĤ�ŸĤ„�ŸĤ�Ÿĵ�Ÿż�ŸŽƒ�Ÿ´�Ÿ�Ÿ†�ŸĤ•�ŸĤ”�ŸŒħ�Ÿ‡Ï€�ŸŒ�Ÿ‰�Ÿ’§�Ÿ�¨�ŸŒŒ�Ÿ‚�Ÿ �Ÿ�Ĥ�Ÿ�š�Ÿ��ŸŽŸ�Ÿ���Ÿ�’�Ÿ›µ�Ÿ�–�Ÿ’�ŸŻ�ŸŽ��ŸŽ²�Ÿş�Ÿš�Ÿ�⌛️&#039;;
  const {
    start,
    text
  } = value;
  if (start &lt; searchText.length) {
    return value;
  }
  const charactersBefore = text.slice(start - searchText.length, start);
  if (charactersBefore.toLowerCase() !== searchText) {
    return value;
  }
  return (0,external_wp_richText_namespaceObject.insert)(value, addText);
}

;// ./node_modules/@wordpress/block-editor/build-module/components/rich-text/event-listeners/input-rules.js
/**
 * WordPress dependencies
 */



/**
 * Internal dependencies
 */



function findSelection(blocks) {
  let i = blocks.length;
  while (i--) {
    const attributeKey = retrieveSelectedAttribute(blocks[i].attributes);
    if (attributeKey) {
      blocks[i].attributes[attributeKey] = blocks[i].attributes[attributeKey]
      // To do: refactor this to use rich text&#039;s selection instead, so
      // we no longer have to use on this hack inserting a special
      // character.
      .toString().replace(START_OF_SELECTED_AREA, &#039;&#039;);
      return [blocks[i].clientId, attributeKey, 0, 0];
    }
    const nestedSelection = findSelection(blocks[i].innerBlocks);
    if (nestedSelection) {
      return nestedSelection;
    }
  }
  return [];
}
/* harmony default export */ const input_rules = (props =&gt; element =&gt; {
  function inputRule() {
    const {
      getValue,
      onReplace,
      selectionChange,
      registry
    } = props.current;
    if (!onReplace) {
      return;
    }

    // We must use getValue() here because value may be update
    // asynchronously.
    const value = getValue();
    const {
      start,
      text
    } = value;
    const characterBefore = text.slice(start - 1, start);

    // The character right before the caret must be a plain space.
    if (characterBefore !== &#039; &#039;) {
      return;
    }
    const trimmedTextBefore = text.slice(0, start).trim();
    const prefixTransforms = (0,external_wp_blocks_namespaceObject.getBlockTransforms)(&#039;from&#039;).filter(({
      type
    }) =&gt; type === &#039;prefix&#039;);
    const transformation = (0,external_wp_blocks_namespaceObject.findTransform)(prefixTransforms, ({
      prefix
    }) =&gt; {
      return trimmedTextBefore === prefix;
    });
    if (!transformation) {
      return;
    }
    const content = (0,external_wp_richText_namespaceObject.toHTMLString)({
      value: (0,external_wp_richText_namespaceObject.insert)(value, START_OF_SELECTED_AREA, 0, start)
    });
    const block = transformation.transform(content);
    selectionChange(...findSelection([block]));
    onReplace([block]);
    registry.dispatch(store).__unstableMarkAutomaticChange();
    return true;
  }
  function onInput(event) {
    const {
      inputType,
      type
    } = event;
    const {
      getValue,
      onChange,
      __unstableAllowPrefixTransformations,
      formatTypes,
      registry
    } = props.current;

    // Only run input rules when inserting text.
    if (inputType !== &#039;insertText&#039; &amp;&amp; type !== &#039;compositionend&#039;) {
      return;
    }
    if (__unstableAllowPrefixTransformations &amp;&amp; inputRule()) {
      return;
    }
    const value = getValue();
    const transformed = formatTypes.reduce((accumulator, {
      __unstableInputRule
    }) =&gt; {
      if (__unstableInputRule) {
        accumulator = __unstableInputRule(accumulator);
      }
      return accumulator;
    }, preventEventDiscovery(value));
    const {
      __unstableMarkLastChangeAsPersistent,
      __unstableMarkAutomaticChange
    } = registry.dispatch(store);
    if (transformed !== value) {
      __unstableMarkLastChangeAsPersistent();
      onChange({
        ...transformed,
        activeFormats: value.activeFormats
      });
      __unstableMarkAutomaticChange();
    }
  }
  element.addEventListener(&#039;input&#039;, onInput);
  element.addEventListener(&#039;compositionend&#039;, onInput);
  return () =&gt; {
    element.removeEventListener(&#039;input&#039;, onInput);
    element.removeEventListener(&#039;compositionend&#039;, onInput);
  };
});

;// ./node_modules/@wordpress/block-editor/build-module/components/rich-text/event-listeners/insert-replacement-text.js
/**
 * Internal dependencies
 */


/**
 * When the browser is about to auto correct, add an undo level so the user can
 * revert the change.
 *
 * @param {Object} props
 */
/* harmony default export */ const insert_replacement_text = (props =&gt; element =&gt; {
  function onInput(event) {
    if (event.inputType !== &#039;insertReplacementText&#039;) {
      return;
    }
    const {
      registry
    } = props.current;
    registry.dispatch(store).__unstableMarkLastChangeAsPersistent();
  }
  element.addEventListener(&#039;beforeinput&#039;, onInput);
  return () =&gt; {
    element.removeEventListener(&#039;beforeinput&#039;, onInput);
  };
});

;// ./node_modules/@wordpress/block-editor/build-module/components/rich-text/event-listeners/remove-browser-shortcuts.js
/**
 * WordPress dependencies
 */


/**
 * Hook to prevent default behaviors for key combinations otherwise handled
 * internally by RichText.
 */
/* harmony default export */ const remove_browser_shortcuts = (() =&gt; node =&gt; {
  function onKeydown(event) {
    if (external_wp_keycodes_namespaceObject.isKeyboardEvent.primary(event, &#039;z&#039;) || external_wp_keycodes_namespaceObject.isKeyboardEvent.primary(event, &#039;y&#039;) || external_wp_keycodes_namespaceObject.isKeyboardEvent.primaryShift(event, &#039;z&#039;)) {
      event.preventDefault();
    }
  }
  node.addEventListener(&#039;keydown&#039;, onKeydown);
  return () =&gt; {
    node.removeEventListener(&#039;keydown&#039;, onKeydown);
  };
});

;// ./node_modules/@wordpress/block-editor/build-module/components/rich-text/event-listeners/shortcuts.js
/* harmony default export */ const shortcuts = (props =&gt; element =&gt; {
  const {
    keyboardShortcuts
  } = props.current;
  function onKeyDown(event) {
    for (const keyboardShortcut of keyboardShortcuts.current) {
      keyboardShortcut(event);
    }
  }
  element.addEventListener(&#039;keydown&#039;, onKeyDown);
  return () =&gt; {
    element.removeEventListener(&#039;keydown&#039;, onKeyDown);
  };
});

;// ./node_modules/@wordpress/block-editor/build-module/components/rich-text/event-listeners/input-events.js
/* harmony default export */ const input_events = (props =&gt; element =&gt; {
  const {
    inputEvents
  } = props.current;
  function onInput(event) {
    for (const keyboardShortcut of inputEvents.current) {
      keyboardShortcut(event);
    }
  }
  element.addEventListener(&#039;input&#039;, onInput);
  return () =&gt; {
    element.removeEventListener(&#039;input&#039;, onInput);
  };
});

;// ./node_modules/@wordpress/block-editor/build-module/components/rich-text/event-listeners/undo-automatic-change.js
/**
 * WordPress dependencies
 */


/**
 * Internal dependencies
 */

/* harmony default export */ const undo_automatic_change = (props =&gt; element =&gt; {
  function onKeyDown(event) {
    const {
      keyCode
    } = event;
    if (event.defaultPrevented) {
      return;
    }
    if (keyCode !== external_wp_keycodes_namespaceObject.BACKSPACE &amp;&amp; keyCode !== external_wp_keycodes_namespaceObject.ESCAPE) {
      return;
    }
    const {
      registry
    } = props.current;
    const {
      didAutomaticChange,
      getSettings
    } = registry.select(store);
    const {
      __experimentalUndo
    } = getSettings();
    if (!__experimentalUndo) {
      return;
    }
    if (!didAutomaticChange()) {
      return;
    }
    event.preventDefault();
    __experimentalUndo();
  }
  element.addEventListener(&#039;keydown&#039;, onKeyDown);
  return () =&gt; {
    element.removeEventListener(&#039;keydown&#039;, onKeyDown);
  };
});

;// ./node_modules/@wordpress/block-editor/build-module/components/rich-text/utils.js
/**
 * WordPress dependencies
 */



function addActiveFormats(value, activeFormats) {
  if (activeFormats?.length) {
    let index = value.formats.length;
    while (index--) {
      value.formats[index] = [...activeFormats, ...(value.formats[index] || [])];
    }
  }
}

/**
 * Get the multiline tag based on the multiline prop.
 *
 * @param {?(string|boolean)} multiline The multiline prop.
 *
 * @return {string | undefined} The multiline tag.
 */
function getMultilineTag(multiline) {
  if (multiline !== true &amp;&amp; multiline !== &#039;p&#039; &amp;&amp; multiline !== &#039;li&#039;) {
    return;
  }
  return multiline === true ? &#039;p&#039; : multiline;
}
function getAllowedFormats({
  allowedFormats,
  disableFormats
}) {
  if (disableFormats) {
    return getAllowedFormats.EMPTY_ARRAY;
  }
  return allowedFormats;
}
getAllowedFormats.EMPTY_ARRAY = [];

/**
 * Creates a link from pasted URL.
 * Creates a paragraph block containing a link to the URL, and calls `onReplace`.
 *
 * @param {string}   url       The URL that could not be embedded.
 * @param {Function} onReplace Function to call with the created fallback block.
 */
function createLinkInParagraph(url, onReplace) {
  const link = /*#__PURE__*/_jsx(&quot;a&quot;, {
    href: url,
    children: url
  });
  onReplace(createBlock(&#039;core/paragraph&#039;, {
    content: renderToString(link)
  }));
}

;// ./node_modules/@wordpress/block-editor/build-module/components/rich-text/event-listeners/paste-handler.js
/**
 * WordPress dependencies
 */




/**
 * Internal dependencies
 */



/** @typedef {import(&#039;@wordpress/rich-text&#039;).RichTextValue} RichTextValue */

/* harmony default export */ const paste_handler = (props =&gt; element =&gt; {
  function _onPaste(event) {
    const {
      disableFormats,
      onChange,
      value,
      formatTypes,
      tagName,
      onReplace,
      __unstableEmbedURLOnPaste,
      preserveWhiteSpace,
      pastePlainText
    } = props.current;

    // The event listener is attached to the window, so we need to check if
    // the target is the element or inside the element.
    if (!element.contains(event.target)) {
      return;
    }
    if (event.defaultPrevented) {
      return;
    }
    const {
      plainText,
      html
    } = getPasteEventData(event);
    event.preventDefault();

    // Allows us to ask for this information when we get a report.
    window.console.log(&#039;Received HTML:\n\n&#039;, html);
    window.console.log(&#039;Received plain text:\n\n&#039;, plainText);
    if (disableFormats) {
      onChange((0,external_wp_richText_namespaceObject.insert)(value, plainText));
      return;
    }
    const isInternal = event.clipboardData.getData(&#039;rich-text&#039;) === &#039;true&#039;;
    function pasteInline(content) {
      const transformed = formatTypes.reduce((accumulator, {
        __unstablePasteRule
      }) =&gt; {
        // Only allow one transform.
        if (__unstablePasteRule &amp;&amp; accumulator === value) {
          accumulator = __unstablePasteRule(value, {
            html,
            plainText
          });
        }
        return accumulator;
      }, value);
      if (transformed !== value) {
        onChange(transformed);
      } else {
        const valueToInsert = (0,external_wp_richText_namespaceObject.create)({
          html: content
        });
        addActiveFormats(valueToInsert, value.activeFormats);
        onChange((0,external_wp_richText_namespaceObject.insert)(value, valueToInsert));
      }
    }

    // If the data comes from a rich text instance, we can directly use it
    // without filtering the data. The filters are only meant for externally
    // pasted content and remove inline styles.
    if (isInternal) {
      pasteInline(html);
      return;
    }
    if (pastePlainText) {
      onChange((0,external_wp_richText_namespaceObject.insert)(value, (0,external_wp_richText_namespaceObject.create)({
        text: plainText
      })));
      return;
    }
    let mode = &#039;INLINE&#039;;
    const trimmedPlainText = plainText.trim();
    if (__unstableEmbedURLOnPaste &amp;&amp; (0,external_wp_richText_namespaceObject.isEmpty)(value) &amp;&amp; (0,external_wp_url_namespaceObject.isURL)(trimmedPlainText) &amp;&amp;
    // For the link pasting feature, allow only http(s) protocols.
    /^https?:/.test(trimmedPlainText)) {
      mode = &#039;BLOCKS&#039;;
    }
    const content = (0,external_wp_blocks_namespaceObject.pasteHandler)({
      HTML: html,
      plainText,
      mode,
      tagName,
      preserveWhiteSpace
    });
    if (typeof content === &#039;string&#039;) {
      pasteInline(content);
    } else if (content.length &gt; 0) {
      if (onReplace &amp;&amp; (0,external_wp_richText_namespaceObject.isEmpty)(value)) {
        onReplace(content, content.length - 1, -1);
      }
    }
  }
  const {
    defaultView
  } = element.ownerDocument;

  // Attach the listener to the window so parent elements have the chance to
  // prevent the default behavior.
  defaultView.addEventListener(&#039;paste&#039;, _onPaste);
  return () =&gt; {
    defaultView.removeEventListener(&#039;paste&#039;, _onPaste);
  };
});

;// ./node_modules/@wordpress/block-editor/build-module/components/rich-text/event-listeners/delete.js
/**
 * WordPress dependencies
 */


/* harmony default export */ const event_listeners_delete = (props =&gt; element =&gt; {
  function onKeyDown(event) {
    const {
      keyCode,
      shiftKey,
      ctrlKey,
      metaKey
    } = event;
    if (event.defaultPrevented) {
      return;
    }
    const {
      value,
      onMerge,
      onRemove
    } = props.current;
    if (keyCode === external_wp_keycodes_namespaceObject.DELETE || keyCode === external_wp_keycodes_namespaceObject.BACKSPACE) {
      const {
        start,
        end,
        text
      } = value;
      const isReverse = keyCode === external_wp_keycodes_namespaceObject.BACKSPACE;
      const hasActiveFormats = value.activeFormats &amp;&amp; !!value.activeFormats.length;

      // Only process delete if the key press occurs at an uncollapsed edge.
      if (!(0,external_wp_richText_namespaceObject.isCollapsed)(value) || hasActiveFormats || isReverse &amp;&amp; start !== 0 || !isReverse &amp;&amp; end !== text.length) {
        return;
      }

      // Exclude (command|ctrl)+shift+backspace as they are shortcuts for deleting blocks.
      if (shiftKey &amp;&amp; (ctrlKey || metaKey)) {
        return;
      }
      if (onMerge) {
        onMerge(!isReverse);
      }

      // Only handle remove on Backspace. This serves dual-purpose of being
      // an intentional user interaction distinguishing between Backspace and
      // Delete to remove the empty field, but also to avoid merge &amp; remove
      // causing destruction of two fields (merge, then removed merged).
      else if (onRemove &amp;&amp; (0,external_wp_richText_namespaceObject.isEmpty)(value) &amp;&amp; isReverse) {
        onRemove(!isReverse);
      }
      event.preventDefault();
    }
  }
  element.addEventListener(&#039;keydown&#039;, onKeyDown);
  return () =&gt; {
    element.removeEventListener(&#039;keydown&#039;, onKeyDown);
  };
});

;// ./node_modules/@wordpress/block-editor/build-module/components/rich-text/event-listeners/enter.js
/**
 * WordPress dependencies
 */


/* harmony default export */ const enter = (props =&gt; element =&gt; {
  function onKeyDownDeprecated(event) {
    if (event.keyCode !== external_wp_keycodes_namespaceObject.ENTER) {
      return;
    }
    const {
      onReplace,
      onSplit
    } = props.current;
    if (onReplace &amp;&amp; onSplit) {
      event.__deprecatedOnSplit = true;
    }
  }
  function onKeyDown(event) {
    if (event.defaultPrevented) {
      return;
    }

    // The event listener is attached to the window, so we need to check if
    // the target is the element.
    if (event.target !== element) {
      return;
    }
    if (event.keyCode !== external_wp_keycodes_namespaceObject.ENTER) {
      return;
    }
    const {
      value,
      onChange,
      disableLineBreaks,
      onSplitAtEnd,
      onSplitAtDoubleLineEnd,
      registry
    } = props.current;
    event.preventDefault();
    const {
      text,
      start,
      end
    } = value;
    if (event.shiftKey) {
      if (!disableLineBreaks) {
        onChange((0,external_wp_richText_namespaceObject.insert)(value, &#039;\n&#039;));
      }
    } else if (onSplitAtEnd &amp;&amp; start === end &amp;&amp; end === text.length) {
      onSplitAtEnd();
    } else if (
    // For some blocks it&#039;s desirable to split at the end of the
    // block when there are two line breaks at the end of the
    // block, so triple Enter exits the block.
    onSplitAtDoubleLineEnd &amp;&amp; start === end &amp;&amp; end === text.length &amp;&amp; text.slice(-2) === &#039;\n\n&#039;) {
      registry.batch(() =&gt; {
        const _value = {
          ...value
        };
        _value.start = _value.end - 2;
        onChange((0,external_wp_richText_namespaceObject.remove)(_value));
        onSplitAtDoubleLineEnd();
      });
    } else if (!disableLineBreaks) {
      onChange((0,external_wp_richText_namespaceObject.insert)(value, &#039;\n&#039;));
    }
  }
  const {
    defaultView
  } = element.ownerDocument;

  // Attach the listener to the window so parent elements have the chance to
  // prevent the default behavior.
  defaultView.addEventListener(&#039;keydown&#039;, onKeyDown);
  element.addEventListener(&#039;keydown&#039;, onKeyDownDeprecated);
  return () =&gt; {
    defaultView.removeEventListener(&#039;keydown&#039;, onKeyDown);
    element.removeEventListener(&#039;keydown&#039;, onKeyDownDeprecated);
  };
});

;// ./node_modules/@wordpress/block-editor/build-module/components/rich-text/event-listeners/firefox-compat.js
/**
 * Internal dependencies
 */

/* harmony default export */ const firefox_compat = (props =&gt; element =&gt; {
  function onFocus() {
    const {
      registry
    } = props.current;
    if (!registry.select(store).isMultiSelecting()) {
      return;
    }

    // This is a little hack to work around focus issues with nested
    // editable elements in Firefox. For some reason the editable child
    // element sometimes regains focus, while it should not be focusable
    // and focus should remain on the editable parent element.
    // To do: try to find the cause of the shifting focus.
    const parentEditable = element.parentElement.closest(&#039;[contenteditable=&quot;true&quot;]&#039;);
    if (parentEditable) {
      parentEditable.focus();
    }
  }
  element.addEventListener(&#039;focus&#039;, onFocus);
  return () =&gt; {
    element.removeEventListener(&#039;focus&#039;, onFocus);
  };
});

;// ./node_modules/@wordpress/block-editor/build-module/components/rich-text/event-listeners/index.js
/**
 * WordPress dependencies
 */



/**
 * Internal dependencies
 */











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];
function useEventListeners(props) {
  const propsRef = (0,external_wp_element_namespaceObject.useRef)(props);
  (0,external_wp_element_namespaceObject.useInsertionEffect)(() =&gt; {
    propsRef.current = props;
  });
  const refEffects = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; allEventListeners.map(refEffect =&gt; refEffect(propsRef)), [propsRef]);
  return (0,external_wp_compose_namespaceObject.useRefEffect)(element =&gt; {
    if (!props.isSelected) {
      return;
    }
    const cleanups = refEffects.map(effect =&gt; effect(element));
    return () =&gt; {
      cleanups.forEach(cleanup =&gt; cleanup());
    };
  }, [refEffects, props.isSelected]);
}

;// ./node_modules/@wordpress/block-editor/build-module/components/rich-text/format-edit.js
/**
 * WordPress dependencies
 */



/**
 * Internal dependencies
 */



const format_edit_DEFAULT_BLOCK_CONTEXT = {};
const usesContextKey = Symbol(&#039;usesContext&#039;);
function format_edit_Edit({
  onChange,
  onFocus,
  value,
  forwardedRef,
  settings
}) {
  const {
    name,
    edit: EditFunction,
    [usesContextKey]: usesContext
  } = settings;
  const blockContext = (0,external_wp_element_namespaceObject.useContext)(block_context);

  // Assign context values using the block type&#039;s declared context needs.
  const context = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; {
    return usesContext ? Object.fromEntries(Object.entries(blockContext).filter(([key]) =&gt; usesContext.includes(key))) : format_edit_DEFAULT_BLOCK_CONTEXT;
  }, [usesContext, blockContext]);
  if (!EditFunction) {
    return null;
  }
  const activeFormat = (0,external_wp_richText_namespaceObject.getActiveFormat)(value, name);
  const isActive = activeFormat !== undefined;
  const activeObject = (0,external_wp_richText_namespaceObject.getActiveObject)(value);
  const isObjectActive = activeObject !== undefined &amp;&amp; activeObject.type === name;
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(EditFunction, {
    isActive: isActive,
    activeAttributes: isActive ? activeFormat.attributes || {} : {},
    isObjectActive: isObjectActive,
    activeObjectAttributes: isObjectActive ? activeObject.attributes || {} : {},
    value: value,
    onChange: onChange,
    onFocus: onFocus,
    contentRef: forwardedRef,
    context: context
  }, name);
}
function FormatEdit({
  formatTypes,
  ...props
}) {
  return formatTypes.map(settings =&gt; /*#__PURE__*/(0,external_React_.createElement)(format_edit_Edit, {
    settings: settings,
    ...props,
    key: settings.name
  }));
}

;// ./node_modules/@wordpress/block-editor/build-module/components/rich-text/content.js
/**
 * WordPress dependencies
 */




/**
 * Internal dependencies
 */


/**
 * Internal dependencies
 */


function valueToHTMLString(value, multiline) {
  if (rich_text.isEmpty(value)) {
    const multilineTag = getMultilineTag(multiline);
    return multilineTag ? `&lt;${multilineTag}&gt;&lt;/${multilineTag}&gt;` : &#039;&#039;;
  }
  if (Array.isArray(value)) {
    external_wp_deprecated_default()(&#039;wp.blockEditor.RichText value prop as children type&#039;, {
      since: &#039;6.1&#039;,
      version: &#039;6.3&#039;,
      alternative: &#039;value prop as string&#039;,
      link: &#039;https://developer.wordpress.org/block-editor/how-to-guides/block-tutorial/introducing-attributes-and-editable-fields/&#039;
    });
    return external_wp_blocks_namespaceObject.children.toHTML(value);
  }

  // To do: deprecate string type.
  if (typeof value === &#039;string&#039;) {
    return value;
  }

  // To do: create a toReactComponent method on RichTextData, which we
  // might in the future also use for the editable tree. See
  // https://github.com/WordPress/gutenberg/pull/41655.
  return value.toHTMLString();
}
function Content({
  value,
  tagName: Tag,
  multiline,
  format,
  ...props
}) {
  value = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_element_namespaceObject.RawHTML, {
    children: valueToHTMLString(value, multiline)
  });
  return Tag ? /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Tag, {
    ...props,
    children: value
  }) : value;
}

;// ./node_modules/@wordpress/block-editor/build-module/components/rich-text/multiline.js
/**
 * WordPress dependencies
 */






/**
 * Internal dependencies
 */





function RichTextMultiline({
  children,
  identifier,
  tagName: TagName = &#039;div&#039;,
  value = &#039;&#039;,
  onChange,
  multiline,
  ...props
}, forwardedRef) {
  external_wp_deprecated_default()(&#039;wp.blockEditor.RichText multiline prop&#039;, {
    since: &#039;6.1&#039;,
    version: &#039;6.3&#039;,
    alternative: &#039;nested blocks (InnerBlocks)&#039;,
    link: &#039;https://developer.wordpress.org/block-editor/how-to-guides/block-tutorial/nested-blocks-inner-blocks/&#039;
  });
  const {
    clientId
  } = useBlockEditContext();
  const {
    getSelectionStart,
    getSelectionEnd
  } = (0,external_wp_data_namespaceObject.useSelect)(store);
  const {
    selectionChange
  } = (0,external_wp_data_namespaceObject.useDispatch)(store);
  const multilineTagName = getMultilineTag(multiline);
  value = value || `&lt;${multilineTagName}&gt;&lt;/${multilineTagName}&gt;`;
  const padded = `&lt;/${multilineTagName}&gt;${value}&lt;${multilineTagName}&gt;`;
  const values = padded.split(`&lt;/${multilineTagName}&gt;&lt;${multilineTagName}&gt;`);
  values.shift();
  values.pop();
  function _onChange(newValues) {
    onChange(`&lt;${multilineTagName}&gt;${newValues.join(`&lt;/${multilineTagName}&gt;&lt;${multilineTagName}&gt;`)}&lt;/${multilineTagName}&gt;`);
  }
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(TagName, {
    ref: forwardedRef,
    children: values.map((_value, index) =&gt; {
      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(RichTextWrapper, {
        identifier: `${identifier}-${index}`,
        tagName: multilineTagName,
        value: _value,
        onChange: newValue =&gt; {
          const newValues = values.slice();
          newValues[index] = newValue;
          _onChange(newValues);
        },
        isSelected: undefined,
        onKeyDown: event =&gt; {
          if (event.keyCode !== external_wp_keycodes_namespaceObject.ENTER) {
            return;
          }
          event.preventDefault();
          const {
            offset: start
          } = getSelectionStart();
          const {
            offset: end
          } = getSelectionEnd();

          // Cannot split if there is no selection.
          if (typeof start !== &#039;number&#039; || typeof end !== &#039;number&#039;) {
            return;
          }
          const richTextValue = (0,external_wp_richText_namespaceObject.create)({
            html: _value
          });
          richTextValue.start = start;
          richTextValue.end = end;
          const array = (0,external_wp_richText_namespaceObject.split)(richTextValue).map(v =&gt; (0,external_wp_richText_namespaceObject.toHTMLString)({
            value: v
          }));
          const newValues = values.slice();
          newValues.splice(index, 1, ...array);
          _onChange(newValues);
          selectionChange(clientId, `${identifier}-${index + 1}`, 0, 0);
        },
        onMerge: forward =&gt; {
          const newValues = values.slice();
          let offset = 0;
          if (forward) {
            if (!newValues[index + 1]) {
              return;
            }
            newValues.splice(index, 2, newValues[index] + newValues[index + 1]);
            offset = newValues[index].length - 1;
          } else {
            if (!newValues[index - 1]) {
              return;
            }
            newValues.splice(index - 1, 2, newValues[index - 1] + newValues[index]);
            offset = newValues[index - 1].length - 1;
          }
          _onChange(newValues);
          selectionChange(clientId, `${identifier}-${index - (forward ? 0 : 1)}`, offset, offset);
        },
        ...props
      }, index);
    })
  });
}
/* harmony default export */ const multiline = ((0,external_wp_element_namespaceObject.forwardRef)(RichTextMultiline));

;// ./node_modules/@wordpress/block-editor/build-module/components/rich-text/with-deprecations.js
/**
 * WordPress dependencies
 */





/**
 * Internal dependencies
 */


function withDeprecations(Component) {
  return (0,external_wp_element_namespaceObject.forwardRef)((props, ref) =&gt; {
    let value = props.value;
    let onChange = props.onChange;

    // Handle deprecated format.
    if (Array.isArray(value)) {
      external_wp_deprecated_default()(&#039;wp.blockEditor.RichText value prop as children type&#039;, {
        since: &#039;6.1&#039;,
        version: &#039;6.3&#039;,
        alternative: &#039;value prop as string&#039;,
        link: &#039;https://developer.wordpress.org/block-editor/how-to-guides/block-tutorial/introducing-attributes-and-editable-fields/&#039;
      });
      value = external_wp_blocks_namespaceObject.children.toHTML(props.value);
      onChange = newValue =&gt; props.onChange(external_wp_blocks_namespaceObject.children.fromDOM((0,external_wp_richText_namespaceObject.__unstableCreateElement)(document, newValue).childNodes));
    }
    const NewComponent = props.multiline ? multiline : Component;
    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(NewComponent, {
      ...props,
      value: value,
      onChange: onChange,
      ref: ref
    });
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/rich-text/index.js
/**
 * External dependencies
 */


/**
 * WordPress dependencies
 */









/**
 * Internal dependencies
 */















const keyboardShortcutContext = (0,external_wp_element_namespaceObject.createContext)();
const inputEventContext = (0,external_wp_element_namespaceObject.createContext)();
const instanceIdKey = Symbol(&#039;instanceId&#039;);

/**
 * Removes props used for the native version of RichText so that they are not
 * passed to the DOM element and log warnings.
 *
 * @param {Object} props Props to filter.
 *
 * @return {Object} Filtered props.
 */
function removeNativeProps(props) {
  const {
    __unstableMobileNoFocusOnMount,
    deleteEnter,
    placeholderTextColor,
    textAlign,
    selectionColor,
    tagsToEliminate,
    disableEditingMenu,
    fontSize,
    fontFamily,
    fontWeight,
    fontStyle,
    minWidth,
    maxWidth,
    disableSuggestions,
    disableAutocorrection,
    ...restProps
  } = props;
  return restProps;
}
function RichTextWrapper({
  children,
  tagName = &#039;div&#039;,
  value: adjustedValue = &#039;&#039;,
  onChange: adjustedOnChange,
  isSelected: originalIsSelected,
  multiline,
  inlineToolbar,
  wrapperClassName,
  autocompleters,
  onReplace,
  placeholder,
  allowedFormats,
  withoutInteractiveFormatting,
  onRemove,
  onMerge,
  onSplit,
  __unstableOnSplitAtEnd: onSplitAtEnd,
  __unstableOnSplitAtDoubleLineEnd: onSplitAtDoubleLineEnd,
  identifier,
  preserveWhiteSpace,
  __unstablePastePlainText: pastePlainText,
  __unstableEmbedURLOnPaste,
  __unstableDisableFormats: disableFormats,
  disableLineBreaks,
  __unstableAllowPrefixTransformations,
  readOnly,
  ...props
}, forwardedRef) {
  props = removeNativeProps(props);
  if (onSplit) {
    external_wp_deprecated_default()(&#039;wp.blockEditor.RichText onSplit prop&#039;, {
      since: &#039;6.4&#039;,
      alternative: &#039;block.json support key: &quot;splitting&quot;&#039;
    });
  }
  const instanceId = (0,external_wp_compose_namespaceObject.useInstanceId)(RichTextWrapper);
  const anchorRef = (0,external_wp_element_namespaceObject.useRef)();
  const context = useBlockEditContext();
  const {
    clientId,
    isSelected: isBlockSelected,
    name: blockName
  } = context;
  const blockBindings = context[blockBindingsKey];
  const blockContext = (0,external_wp_element_namespaceObject.useContext)(block_context);
  const registry = (0,external_wp_data_namespaceObject.useRegistry)();
  const selector = select =&gt; {
    // Avoid subscribing to the block editor store if the block is not
    // selected.
    if (!isBlockSelected) {
      return {
        isSelected: false
      };
    }
    const {
      getSelectionStart,
      getSelectionEnd
    } = select(store);
    const selectionStart = getSelectionStart();
    const selectionEnd = getSelectionEnd();
    let isSelected;
    if (originalIsSelected === undefined) {
      isSelected = selectionStart.clientId === clientId &amp;&amp; selectionEnd.clientId === clientId &amp;&amp; (identifier ? selectionStart.attributeKey === identifier : selectionStart[instanceIdKey] === instanceId);
    } else if (originalIsSelected) {
      isSelected = selectionStart.clientId === clientId;
    }
    return {
      selectionStart: isSelected ? selectionStart.offset : undefined,
      selectionEnd: isSelected ? selectionEnd.offset : undefined,
      isSelected
    };
  };
  const {
    selectionStart,
    selectionEnd,
    isSelected
  } = (0,external_wp_data_namespaceObject.useSelect)(selector, [clientId, identifier, instanceId, originalIsSelected, isBlockSelected]);
  const {
    disableBoundBlock,
    bindingsPlaceholder,
    bindingsLabel
  } = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    var _fieldsList$relatedBi;
    if (!blockBindings?.[identifier] || !canBindBlock(blockName)) {
      return {};
    }
    const relatedBinding = blockBindings[identifier];
    const blockBindingsSource = (0,external_wp_blocks_namespaceObject.getBlockBindingsSource)(relatedBinding.source);
    const blockBindingsContext = {};
    if (blockBindingsSource?.usesContext?.length) {
      for (const key of blockBindingsSource.usesContext) {
        blockBindingsContext[key] = blockContext[key];
      }
    }
    const _disableBoundBlock = !blockBindingsSource?.canUserEditValue?.({
      select,
      context: blockBindingsContext,
      args: relatedBinding.args
    });

    // Don&#039;t modify placeholders if value is not empty.
    if (adjustedValue.length &gt; 0) {
      return {
        disableBoundBlock: _disableBoundBlock,
        // Null values will make them fall back to the default behavior.
        bindingsPlaceholder: null,
        bindingsLabel: null
      };
    }
    const {
      getBlockAttributes
    } = select(store);
    const blockAttributes = getBlockAttributes(clientId);
    const fieldsList = blockBindingsSource?.getFieldsList?.({
      select,
      context: blockBindingsContext
    });
    const bindingKey = (_fieldsList$relatedBi = fieldsList?.[relatedBinding?.args?.key]?.label) !== null &amp;&amp; _fieldsList$relatedBi !== void 0 ? _fieldsList$relatedBi : blockBindingsSource?.label;
    const _bindingsPlaceholder = _disableBoundBlock ? bindingKey : (0,external_wp_i18n_namespaceObject.sprintf)(/* translators: %s: connected field label or source label */
    (0,external_wp_i18n_namespaceObject.__)(&#039;Add %s&#039;), bindingKey);
    const _bindingsLabel = _disableBoundBlock ? relatedBinding?.args?.key || blockBindingsSource?.label : (0,external_wp_i18n_namespaceObject.sprintf)(/* translators: %s: source label or key */
    (0,external_wp_i18n_namespaceObject.__)(&#039;Empty %s; start writing to edit its value&#039;), relatedBinding?.args?.key || blockBindingsSource?.label);
    return {
      disableBoundBlock: _disableBoundBlock,
      bindingsPlaceholder: blockAttributes?.placeholder || _bindingsPlaceholder,
      bindingsLabel: _bindingsLabel
    };
  }, [blockBindings, identifier, blockName, adjustedValue, clientId, blockContext]);
  const shouldDisableEditing = readOnly || disableBoundBlock;
  const {
    getSelectionStart,
    getSelectionEnd,
    getBlockRootClientId
  } = (0,external_wp_data_namespaceObject.useSelect)(store);
  const {
    selectionChange
  } = (0,external_wp_data_namespaceObject.useDispatch)(store);
  const adjustedAllowedFormats = getAllowedFormats({
    allowedFormats,
    disableFormats
  });
  const hasFormats = !adjustedAllowedFormats || adjustedAllowedFormats.length &gt; 0;
  const onSelectionChange = (0,external_wp_element_namespaceObject.useCallback)((start, end) =&gt; {
    const selection = {};
    const unset = start === undefined &amp;&amp; end === undefined;
    const baseSelection = {
      clientId,
      [identifier ? &#039;attributeKey&#039; : instanceIdKey]: identifier ? identifier : instanceId
    };
    if (typeof start === &#039;number&#039; || unset) {
      // If we are only setting the start (or the end below), which
      // means a partial selection, and we&#039;re not updating a selection
      // with the same client ID, abort. This means the selected block
      // is a parent block.
      if (end === undefined &amp;&amp; getBlockRootClientId(clientId) !== getBlockRootClientId(getSelectionEnd().clientId)) {
        return;
      }
      selection.start = {
        ...baseSelection,
        offset: start
      };
    }
    if (typeof end === &#039;number&#039; || unset) {
      if (start === undefined &amp;&amp; getBlockRootClientId(clientId) !== getBlockRootClientId(getSelectionStart().clientId)) {
        return;
      }
      selection.end = {
        ...baseSelection,
        offset: end
      };
    }
    selectionChange(selection);
  }, [clientId, getBlockRootClientId, getSelectionEnd, getSelectionStart, identifier, instanceId, selectionChange]);
  const {
    formatTypes,
    prepareHandlers,
    valueHandlers,
    changeHandlers,
    dependencies
  } = useFormatTypes({
    clientId,
    identifier,
    withoutInteractiveFormatting,
    allowedFormats: adjustedAllowedFormats
  });
  function addEditorOnlyFormats(value) {
    return valueHandlers.reduce((accumulator, fn) =&gt; fn(accumulator, value.text), value.formats);
  }
  function removeEditorOnlyFormats(value) {
    formatTypes.forEach(formatType =&gt; {
      // Remove formats created by prepareEditableTree, because they are editor only.
      if (formatType.__experimentalCreatePrepareEditableTree) {
        value = (0,external_wp_richText_namespaceObject.removeFormat)(value, formatType.name, 0, value.text.length);
      }
    });
    return value.formats;
  }
  function addInvisibleFormats(value) {
    return prepareHandlers.reduce((accumulator, fn) =&gt; fn(accumulator, value.text), value.formats);
  }
  const {
    value,
    getValue,
    onChange,
    ref: richTextRef
  } = (0,external_wp_richText_namespaceObject.__unstableUseRichText)({
    value: adjustedValue,
    onChange(html, {
      __unstableFormats,
      __unstableText
    }) {
      adjustedOnChange(html);
      Object.values(changeHandlers).forEach(changeHandler =&gt; {
        changeHandler(__unstableFormats, __unstableText);
      });
    },
    selectionStart,
    selectionEnd,
    onSelectionChange,
    placeholder: bindingsPlaceholder || placeholder,
    __unstableIsSelected: isSelected,
    __unstableDisableFormats: disableFormats,
    preserveWhiteSpace,
    __unstableDependencies: [...dependencies, tagName],
    __unstableAfterParse: addEditorOnlyFormats,
    __unstableBeforeSerialize: removeEditorOnlyFormats,
    __unstableAddInvisibleFormats: addInvisibleFormats
  });
  const autocompleteProps = useBlockEditorAutocompleteProps({
    onReplace,
    completers: autocompleters,
    record: value,
    onChange
  });
  useMarkPersistent({
    html: adjustedValue,
    value
  });
  const keyboardShortcuts = (0,external_wp_element_namespaceObject.useRef)(new Set());
  const inputEvents = (0,external_wp_element_namespaceObject.useRef)(new Set());
  function onFocus() {
    anchorRef.current?.focus();
  }
  const TagName = tagName;
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
    children: [isSelected &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(keyboardShortcutContext.Provider, {
      value: keyboardShortcuts,
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inputEventContext.Provider, {
        value: inputEvents,
        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.Popover.__unstableSlotNameProvider, {
          value: &quot;__unstable-block-tools-after&quot;,
          children: [children &amp;&amp; children({
            value,
            onChange,
            onFocus
          }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(FormatEdit, {
            value: value,
            onChange: onChange,
            onFocus: onFocus,
            formatTypes: formatTypes,
            forwardedRef: anchorRef
          })]
        })
      })
    }), isSelected &amp;&amp; hasFormats &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(format_toolbar_container, {
      inline: inlineToolbar,
      editableContentElement: anchorRef.current
    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(TagName
    // Overridable props.
    , {
      role: &quot;textbox&quot;,
      &quot;aria-multiline&quot;: !disableLineBreaks,
      &quot;aria-readonly&quot;: shouldDisableEditing,
      ...props,
      // Unset draggable (coming from block props) for contentEditable
      // elements because it will interfere with multi block selection
      // when the contentEditable and draggable elements are the same
      // element.
      draggable: undefined,
      &quot;aria-label&quot;: bindingsLabel || props[&#039;aria-label&#039;] || placeholder,
      ...autocompleteProps,
      ref: (0,external_wp_compose_namespaceObject.useMergeRefs)([
      // Rich text ref must be first because its focus listener
      // must be set up before any other ref calls .focus() on
      // mount.
      richTextRef, forwardedRef, autocompleteProps.ref, props.ref, useEventListeners({
        registry,
        getValue,
        onChange,
        __unstableAllowPrefixTransformations,
        formatTypes,
        onReplace,
        selectionChange,
        isSelected,
        disableFormats,
        value,
        tagName,
        onSplit,
        __unstableEmbedURLOnPaste,
        pastePlainText,
        onMerge,
        onRemove,
        removeEditorOnlyFormats,
        disableLineBreaks,
        onSplitAtEnd,
        onSplitAtDoubleLineEnd,
        keyboardShortcuts,
        inputEvents
      }), anchorRef]),
      contentEditable: !shouldDisableEditing,
      suppressContentEditableWarning: true,
      className: dist_clsx(&#039;block-editor-rich-text__editable&#039;, props.className, &#039;rich-text&#039;)
      // Setting tabIndex to 0 is unnecessary, the element is already
      // focusable because it&#039;s contentEditable. This also fixes a
      // Safari bug where it&#039;s not possible to Shift+Click multi
      // select blocks when Shift Clicking into an element with
      // tabIndex because Safari will focus the element. However,
      // Safari will correctly ignore nested contentEditable elements.
      ,
      tabIndex: props.tabIndex === 0 &amp;&amp; !shouldDisableEditing ? null : props.tabIndex,
      &quot;data-wp-block-attribute-key&quot;: identifier
    })]
  });
}

// This is the private API for the RichText component.
// It allows access to all props, not just the public ones.
const PrivateRichText = withDeprecations((0,external_wp_element_namespaceObject.forwardRef)(RichTextWrapper));
PrivateRichText.Content = Content;
PrivateRichText.isEmpty = value =&gt; {
  return !value || value.length === 0;
};

// This is the public API for the RichText component.
// We wrap the PrivateRichText component to hide some props from the public API.
/**
 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/rich-text/README.md
 */
const PublicForwardedRichTextContainer = (0,external_wp_element_namespaceObject.forwardRef)((props, ref) =&gt; {
  const context = useBlockEditContext();
  const isPreviewMode = context[isPreviewModeKey];
  if (isPreviewMode) {
    // Remove all non-content props.
    const {
      children,
      tagName: Tag = &#039;div&#039;,
      value,
      onChange,
      isSelected,
      multiline,
      inlineToolbar,
      wrapperClassName,
      autocompleters,
      onReplace,
      placeholder,
      allowedFormats,
      withoutInteractiveFormatting,
      onRemove,
      onMerge,
      onSplit,
      __unstableOnSplitAtEnd,
      __unstableOnSplitAtDoubleLineEnd,
      identifier,
      preserveWhiteSpace,
      __unstablePastePlainText,
      __unstableEmbedURLOnPaste,
      __unstableDisableFormats,
      disableLineBreaks,
      __unstableAllowPrefixTransformations,
      readOnly,
      ...contentProps
    } = removeNativeProps(props);
    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Tag, {
      ...contentProps,
      dangerouslySetInnerHTML: {
        __html: valueToHTMLString(value, multiline)
      }
    });
  }
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PrivateRichText, {
    ref: ref,
    ...props,
    readOnly: false
  });
});
PublicForwardedRichTextContainer.Content = Content;
PublicForwardedRichTextContainer.isEmpty = value =&gt; {
  return !value || value.length === 0;
};
/* harmony default export */ const rich_text = (PublicForwardedRichTextContainer);




;// ./node_modules/@wordpress/block-editor/build-module/components/editable-text/index.js
/**
 * WordPress dependencies
 */


/**
 * Internal dependencies
 */


const EditableText = (0,external_wp_element_namespaceObject.forwardRef)((props, ref) =&gt; {
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(rich_text, {
    ref: ref,
    ...props,
    __unstableDisableFormats: true
  });
});
EditableText.Content = ({
  value = &#039;&#039;,
  tagName: Tag = &#039;div&#039;,
  ...props
}) =&gt; {
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(Tag, {
    ...props,
    children: value
  });
};

/**
 * Renders an editable text input in which text formatting is not allowed.
 */
/* harmony default export */ const editable_text = (EditableText);

;// ./node_modules/@wordpress/block-editor/build-module/components/plain-text/index.js
/**
 * External dependencies
 */



/**
 * WordPress dependencies
 */


/**
 * Internal dependencies
 */


/**
 * Render an auto-growing textarea allow users to fill any textual content.
 *
 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/plain-text/README.md
 *
 * @example
 * ```jsx
 * import { registerBlockType } from &#039;@wordpress/blocks&#039;;
 * import { PlainText } from &#039;@wordpress/block-editor&#039;;
 *
 * registerBlockType( &#039;my-plugin/example-block&#039;, {
 *   // ...
 *
 *   attributes: {
 *     content: {
 *       type: &#039;string&#039;,
 *     },
 *   },
 *
 *   edit( { className, attributes, setAttributes } ) {
 *     return (
 *       &lt;PlainText
 *         className={ className }
 *         value={ attributes.content }
 *         onChange={ ( content ) =&gt; setAttributes( { content } ) }
 *       /&gt;
 *     );
 *   },
 * } );
 * ````
 *
 * @param {Object}   props          Component props.
 * @param {string}   props.value    String value of the textarea.
 * @param {Function} props.onChange Function called when the text value changes.
 * @param {Object}   [props.ref]    The component forwards the `ref` property to the `TextareaAutosize` component.
 * @return {Element} Plain text component
 */

const PlainText = (0,external_wp_element_namespaceObject.forwardRef)(({
  __experimentalVersion,
  ...props
}, ref) =&gt; {
  if (__experimentalVersion === 2) {
    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(editable_text, {
      ref: ref,
      ...props
    });
  }
  const {
    className,
    onChange,
    ...remainingProps
  } = props;
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(lib/* default */.A, {
    ref: ref,
    className: dist_clsx(&#039;block-editor-plain-text&#039;, className),
    onChange: event =&gt; onChange(event.target.value),
    ...remainingProps
  });
});
/* harmony default export */ const plain_text = (PlainText);

;// ./node_modules/@wordpress/block-editor/build-module/components/responsive-block-control/label.js
/**
 * WordPress dependencies
 */




function ResponsiveBlockControlLabel({
  property,
  viewport,
  desc
}) {
  const instanceId = (0,external_wp_compose_namespaceObject.useInstanceId)(ResponsiveBlockControlLabel);
  const accessibleLabel = desc || (0,external_wp_i18n_namespaceObject.sprintf)(/* translators: 1: property name. 2: viewport name. */
  (0,external_wp_i18n_namespaceObject._x)(&#039;Controls the %1$s property for %2$s viewports.&#039;, &#039;Text labelling a interface as controlling a given layout property (eg: margin) for a given screen size.&#039;), property, viewport.label);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;span&quot;, {
      &quot;aria-describedby&quot;: `rbc-desc-${instanceId}`,
      children: viewport.label
    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.VisuallyHidden, {
      as: &quot;span&quot;,
      id: `rbc-desc-${instanceId}`,
      children: accessibleLabel
    })]
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/responsive-block-control/index.js
/**
 * External dependencies
 */


/**
 * WordPress dependencies
 */




/**
 * Internal dependencies
 */


function ResponsiveBlockControl(props) {
  const {
    title,
    property,
    toggleLabel,
    onIsResponsiveChange,
    renderDefaultControl,
    renderResponsiveControls,
    isResponsive = false,
    defaultLabel = {
      id: &#039;all&#039;,
      label: (0,external_wp_i18n_namespaceObject._x)(&#039;All&#039;, &#039;screen sizes&#039;)
    },
    viewports = [{
      id: &#039;small&#039;,
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Small screens&#039;)
    }, {
      id: &#039;medium&#039;,
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Medium screens&#039;)
    }, {
      id: &#039;large&#039;,
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Large screens&#039;)
    }]
  } = props;
  if (!title || !property || !renderDefaultControl) {
    return null;
  }
  const toggleControlLabel = toggleLabel || (0,external_wp_i18n_namespaceObject.sprintf)(/* translators: %s: Property value for the control (eg: margin, padding, etc.). */
  (0,external_wp_i18n_namespaceObject.__)(&#039;Use the same %s on all screen sizes.&#039;), property);
  const toggleHelpText = (0,external_wp_i18n_namespaceObject.__)(&#039;Choose whether to use the same value for all screen sizes or a unique value for each screen size.&#039;);
  const defaultControl = renderDefaultControl(/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ResponsiveBlockControlLabel, {
    property: property,
    viewport: defaultLabel
  }), defaultLabel);
  const defaultResponsiveControls = () =&gt; {
    return viewports.map(viewport =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_element_namespaceObject.Fragment, {
      children: renderDefaultControl(/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ResponsiveBlockControlLabel, {
        property: property,
        viewport: viewport
      }), viewport)
    }, viewport.id));
  };
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;fieldset&quot;, {
    className: &quot;block-editor-responsive-block-control&quot;,
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;legend&quot;, {
      className: &quot;block-editor-responsive-block-control__title&quot;,
      children: title
    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;div&quot;, {
      className: &quot;block-editor-responsive-block-control__inner&quot;,
      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToggleControl, {
        __nextHasNoMarginBottom: true,
        className: &quot;block-editor-responsive-block-control__toggle&quot;,
        label: toggleControlLabel,
        checked: !isResponsive,
        onChange: onIsResponsiveChange,
        help: toggleHelpText
      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;div&quot;, {
        className: dist_clsx(&#039;block-editor-responsive-block-control__group&#039;, {
          &#039;is-responsive&#039;: isResponsive
        }),
        children: [!isResponsive &amp;&amp; defaultControl, isResponsive &amp;&amp; (renderResponsiveControls ? renderResponsiveControls(viewports) : defaultResponsiveControls())]
      })]
    })]
  });
}
/* harmony default export */ const responsive_block_control = (ResponsiveBlockControl);

;// ./node_modules/@wordpress/block-editor/build-module/components/rich-text/shortcut.js
/**
 * WordPress dependencies
 */



/**
 * Internal dependencies
 */

function RichTextShortcut({
  character,
  type,
  onUse
}) {
  const keyboardShortcuts = (0,external_wp_element_namespaceObject.useContext)(keyboardShortcutContext);
  const onUseRef = (0,external_wp_element_namespaceObject.useRef)();
  onUseRef.current = onUse;
  (0,external_wp_element_namespaceObject.useEffect)(() =&gt; {
    function callback(event) {
      if (external_wp_keycodes_namespaceObject.isKeyboardEvent[type](event, character)) {
        onUseRef.current();
        event.preventDefault();
      }
    }
    keyboardShortcuts.current.add(callback);
    return () =&gt; {
      keyboardShortcuts.current.delete(callback);
    };
  }, [character, type]);
  return null;
}

;// ./node_modules/@wordpress/block-editor/build-module/components/rich-text/toolbar-button.js
/**
 * WordPress dependencies
 */



function RichTextToolbarButton({
  name,
  shortcutType,
  shortcutCharacter,
  ...props
}) {
  let shortcut;
  let fillName = &#039;RichText.ToolbarControls&#039;;
  if (name) {
    fillName += `.${name}`;
  }
  if (shortcutType &amp;&amp; shortcutCharacter) {
    shortcut = external_wp_keycodes_namespaceObject.displayShortcut[shortcutType](shortcutCharacter);
  }
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Fill, {
    name: fillName,
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarButton, {
      ...props,
      shortcut: shortcut
    })
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/rich-text/input-event.js
/**
 * WordPress dependencies
 */


/**
 * Internal dependencies
 */

function __unstableRichTextInputEvent({
  inputType,
  onInput
}) {
  const callbacks = (0,external_wp_element_namespaceObject.useContext)(inputEventContext);
  const onInputRef = (0,external_wp_element_namespaceObject.useRef)();
  onInputRef.current = onInput;
  (0,external_wp_element_namespaceObject.useEffect)(() =&gt; {
    function callback(event) {
      if (event.inputType === inputType) {
        onInputRef.current();
        event.preventDefault();
      }
    }
    callbacks.current.add(callback);
    return () =&gt; {
      callbacks.current.delete(callback);
    };
  }, [inputType]);
  return null;
}

;// ./node_modules/@wordpress/block-editor/build-module/components/tool-selector/index.js
/**
 * WordPress dependencies
 */






/**
 * Internal dependencies
 */


const selectIcon = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  width: &quot;24&quot;,
  height: &quot;24&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Path, {
    d: &quot;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&quot;
  })
});
function ToolSelector(props, ref) {
  const mode = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; select(store).__unstableGetEditorMode(), []);
  const {
    __unstableSetEditorMode
  } = (0,external_wp_data_namespaceObject.useDispatch)(store);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Dropdown, {
    renderToggle: ({
      isOpen,
      onToggle
    }) =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
      size: &quot;compact&quot;,
      ...props,
      ref: ref,
      icon: mode === &#039;navigation&#039; ? edit : selectIcon,
      &quot;aria-expanded&quot;: isOpen,
      &quot;aria-haspopup&quot;: &quot;true&quot;,
      onClick: onToggle
      /* translators: button label text should, if possible, be under 16 characters. */,
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Tools&#039;)
    }),
    popoverProps: {
      placement: &#039;bottom-start&#039;
    },
    renderContent: () =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.NavigableMenu, {
        className: &quot;block-editor-tool-selector__menu&quot;,
        role: &quot;menu&quot;,
        &quot;aria-label&quot;: (0,external_wp_i18n_namespaceObject.__)(&#039;Tools&#039;),
        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItemsChoice, {
          value: mode === &#039;navigation&#039; ? &#039;navigation&#039; : &#039;edit&#039;,
          onSelect: newMode =&gt; {
            __unstableSetEditorMode(newMode);
          },
          choices: [{
            value: &#039;navigation&#039;,
            label: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
              children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(build_module_icon, {
                icon: edit
              }), (0,external_wp_i18n_namespaceObject.__)(&#039;Write&#039;)]
            }),
            info: (0,external_wp_i18n_namespaceObject.__)(&#039;Focus on content.&#039;),
            &#039;aria-label&#039;: (0,external_wp_i18n_namespaceObject.__)(&#039;Write&#039;)
          }, {
            value: &#039;edit&#039;,
            label: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
              children: [selectIcon, (0,external_wp_i18n_namespaceObject.__)(&#039;Design&#039;)]
            }),
            info: (0,external_wp_i18n_namespaceObject.__)(&#039;Edit layout and styles.&#039;),
            &#039;aria-label&#039;: (0,external_wp_i18n_namespaceObject.__)(&#039;Design&#039;)
          }]
        })
      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
        className: &quot;block-editor-tool-selector__help&quot;,
        children: (0,external_wp_i18n_namespaceObject.__)(&#039;Tools provide different sets of interactions for blocks. Choose between simplified content tools (Write) and advanced visual editing tools (Design).&#039;)
      })]
    })
  });
}
/* harmony default export */ const tool_selector = ((0,external_wp_element_namespaceObject.forwardRef)(ToolSelector));

;// ./node_modules/@wordpress/block-editor/build-module/components/unit-control/index.js
/**
 * WordPress dependencies
 */


/**
 * Internal dependencies
 */


function UnitControl({
  units: unitsProp,
  ...props
}) {
  const [availableUnits] = use_settings_useSettings(&#039;spacing.units&#039;);
  const units = (0,external_wp_components_namespaceObject.__experimentalUseCustomUnits)({
    availableUnits: availableUnits || [&#039;%&#039;, &#039;px&#039;, &#039;em&#039;, &#039;rem&#039;, &#039;vw&#039;],
    units: unitsProp
  });
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalUnitControl, {
    units: units,
    ...props
  });
}

;// ./node_modules/@wordpress/icons/build-module/library/arrow-left.js
/**
 * WordPress dependencies
 */


const arrowLeft = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;M20 11.2H6.8l3.7-3.7-1-1L3.9 12l5.6 5.5 1-1-3.7-3.7H20z&quot;
  })
});
/* harmony default export */ const arrow_left = (arrowLeft);

;// ./node_modules/@wordpress/block-editor/build-module/components/url-input/button.js
/**
 * WordPress dependencies
 */





/**
 * Internal dependencies
 */


class URLInputButton extends external_wp_element_namespaceObject.Component {
  constructor() {
    super(...arguments);
    this.toggle = this.toggle.bind(this);
    this.submitLink = this.submitLink.bind(this);
    this.state = {
      expanded: false
    };
  }
  toggle() {
    this.setState({
      expanded: !this.state.expanded
    });
  }
  submitLink(event) {
    event.preventDefault();
    this.toggle();
  }
  render() {
    const {
      url,
      onChange
    } = this.props;
    const {
      expanded
    } = this.state;
    const buttonLabel = url ? (0,external_wp_i18n_namespaceObject.__)(&#039;Edit link&#039;) : (0,external_wp_i18n_namespaceObject.__)(&#039;Insert link&#039;);
    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;div&quot;, {
      className: &quot;block-editor-url-input__button&quot;,
      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
        size: &quot;compact&quot;,
        icon: library_link,
        label: buttonLabel,
        onClick: this.toggle,
        className: &quot;components-toolbar__control&quot;,
        isPressed: !!url
      }), expanded &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;form&quot;, {
        className: &quot;block-editor-url-input__button-modal&quot;,
        onSubmit: this.submitLink,
        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;div&quot;, {
          className: &quot;block-editor-url-input__button-modal-line&quot;,
          children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
            __next40pxDefaultSize: true,
            className: &quot;block-editor-url-input__back&quot;,
            icon: arrow_left,
            label: (0,external_wp_i18n_namespaceObject.__)(&#039;Close&#039;),
            onClick: this.toggle
          }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(url_input, {
            value: url || &#039;&#039;,
            onChange: onChange,
            suffix: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalInputControlSuffixWrapper, {
              variant: &quot;control&quot;,
              children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
                size: &quot;small&quot;,
                icon: keyboard_return,
                label: (0,external_wp_i18n_namespaceObject.__)(&#039;Submit&#039;),
                type: &quot;submit&quot;
              })
            })
          })]
        })
      })]
    });
  }
}

/**
 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/url-input/README.md
 */
/* harmony default export */ const url_input_button = (URLInputButton);

;// ./node_modules/@wordpress/icons/build-module/library/image.js
/**
 * WordPress dependencies
 */


const image_image = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  viewBox: &quot;0 0 24 24&quot;,
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;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&quot;
  })
});
/* harmony default export */ const library_image = (image_image);

;// ./node_modules/@wordpress/block-editor/build-module/components/url-popover/image-url-input-ui.js
/**
 * WordPress dependencies
 */






/**
 * Internal dependencies
 */


const LINK_DESTINATION_NONE = &#039;none&#039;;
const LINK_DESTINATION_CUSTOM = &#039;custom&#039;;
const LINK_DESTINATION_MEDIA = &#039;media&#039;;
const LINK_DESTINATION_ATTACHMENT = &#039;attachment&#039;;
const NEW_TAB_REL = [&#039;noreferrer&#039;, &#039;noopener&#039;];
const ImageURLInputUI = ({
  linkDestination,
  onChangeUrl,
  url,
  mediaType = &#039;image&#039;,
  mediaUrl,
  mediaLink,
  linkTarget,
  linkClass,
  rel,
  showLightboxSetting,
  lightboxEnabled,
  onSetLightbox,
  resetLightbox
}) =&gt; {
  const [isOpen, setIsOpen] = (0,external_wp_element_namespaceObject.useState)(false);
  // Use internal state instead of a ref to make sure that the component
  // re-renders when the popover&#039;s anchor updates.
  const [popoverAnchor, setPopoverAnchor] = (0,external_wp_element_namespaceObject.useState)(null);
  const openLinkUI = () =&gt; {
    setIsOpen(true);
  };
  const [isEditingLink, setIsEditingLink] = (0,external_wp_element_namespaceObject.useState)(false);
  const [urlInput, setUrlInput] = (0,external_wp_element_namespaceObject.useState)(null);
  const autocompleteRef = (0,external_wp_element_namespaceObject.useRef)(null);
  const wrapperRef = (0,external_wp_element_namespaceObject.useRef)();
  (0,external_wp_element_namespaceObject.useEffect)(() =&gt; {
    if (!wrapperRef.current) {
      return;
    }
    const nextFocusTarget = external_wp_dom_namespaceObject.focus.focusable.find(wrapperRef.current)[0] || wrapperRef.current;
    nextFocusTarget.focus();
  }, [isEditingLink, url, lightboxEnabled]);
  const startEditLink = () =&gt; {
    if (linkDestination === LINK_DESTINATION_MEDIA || linkDestination === LINK_DESTINATION_ATTACHMENT) {
      setUrlInput(&#039;&#039;);
    }
    setIsEditingLink(true);
  };
  const stopEditLink = () =&gt; {
    setIsEditingLink(false);
  };
  const closeLinkUI = () =&gt; {
    setUrlInput(null);
    stopEditLink();
    setIsOpen(false);
  };
  const getUpdatedLinkTargetSettings = value =&gt; {
    const newLinkTarget = value ? &#039;_blank&#039; : undefined;
    let updatedRel;
    if (newLinkTarget) {
      const rels = (rel !== null &amp;&amp; rel !== void 0 ? rel : &#039;&#039;).split(&#039; &#039;);
      NEW_TAB_REL.forEach(relVal =&gt; {
        if (!rels.includes(relVal)) {
          rels.push(relVal);
        }
      });
      updatedRel = rels.join(&#039; &#039;);
    } else {
      const rels = (rel !== null &amp;&amp; rel !== void 0 ? rel : &#039;&#039;).split(&#039; &#039;).filter(relVal =&gt; NEW_TAB_REL.includes(relVal) === false);
      updatedRel = rels.length ? rels.join(&#039; &#039;) : undefined;
    }
    return {
      linkTarget: newLinkTarget,
      rel: updatedRel
    };
  };
  const onFocusOutside = () =&gt; {
    return event =&gt; {
      // The autocomplete suggestions list renders in a separate popover (in a portal),
      // so onFocusOutside fails to detect that a click on a suggestion occurred in the
      // LinkContainer. Detect clicks on autocomplete suggestions using a ref here, and
      // return to avoid the popover being closed.
      const autocompleteElement = autocompleteRef.current;
      if (autocompleteElement &amp;&amp; autocompleteElement.contains(event.target)) {
        return;
      }
      setIsOpen(false);
      setUrlInput(null);
      stopEditLink();
    };
  };
  const onSubmitLinkChange = () =&gt; {
    return event =&gt; {
      if (urlInput) {
        // It is possible the entered URL actually matches a named link destination.
        // This check will ensure our link destination is correct.
        const selectedDestination = getLinkDestinations().find(destination =&gt; destination.url === urlInput)?.linkDestination || LINK_DESTINATION_CUSTOM;
        onChangeUrl({
          href: urlInput,
          linkDestination: selectedDestination,
          lightbox: {
            enabled: false
          }
        });
      }
      stopEditLink();
      setUrlInput(null);
      event.preventDefault();
    };
  };
  const onLinkRemove = () =&gt; {
    onChangeUrl({
      linkDestination: LINK_DESTINATION_NONE,
      href: &#039;&#039;
    });
  };
  const getLinkDestinations = () =&gt; {
    const linkDestinations = [{
      linkDestination: LINK_DESTINATION_MEDIA,
      title: (0,external_wp_i18n_namespaceObject.__)(&#039;Link to image file&#039;),
      url: mediaType === &#039;image&#039; ? mediaUrl : undefined,
      icon: library_image
    }];
    if (mediaType === &#039;image&#039; &amp;&amp; mediaLink) {
      linkDestinations.push({
        linkDestination: LINK_DESTINATION_ATTACHMENT,
        title: (0,external_wp_i18n_namespaceObject.__)(&#039;Link to attachment page&#039;),
        url: mediaType === &#039;image&#039; ? mediaLink : undefined,
        icon: library_page
      });
    }
    return linkDestinations;
  };
  const onSetHref = value =&gt; {
    const linkDestinations = getLinkDestinations();
    let linkDestinationInput;
    if (!value) {
      linkDestinationInput = LINK_DESTINATION_NONE;
    } else {
      linkDestinationInput = (linkDestinations.find(destination =&gt; {
        return destination.url === value;
      }) || {
        linkDestination: LINK_DESTINATION_CUSTOM
      }).linkDestination;
    }
    onChangeUrl({
      linkDestination: linkDestinationInput,
      href: value
    });
  };
  const onSetNewTab = value =&gt; {
    const updatedLinkTarget = getUpdatedLinkTargetSettings(value);
    onChangeUrl(updatedLinkTarget);
  };
  const onSetLinkRel = value =&gt; {
    onChangeUrl({
      rel: value
    });
  };
  const onSetLinkClass = value =&gt; {
    onChangeUrl({
      linkClass: value
    });
  };
  const advancedOptions = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalVStack, {
    spacing: &quot;3&quot;,
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToggleControl, {
      __nextHasNoMarginBottom: true,
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Open in new tab&#039;),
      onChange: onSetNewTab,
      checked: linkTarget === &#039;_blank&#039;
    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.TextControl, {
      __next40pxDefaultSize: true,
      __nextHasNoMarginBottom: true,
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Link rel&#039;),
      value: rel !== null &amp;&amp; rel !== void 0 ? rel : &#039;&#039;,
      onChange: onSetLinkRel
    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.TextControl, {
      __next40pxDefaultSize: true,
      __nextHasNoMarginBottom: true,
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Link CSS class&#039;),
      value: linkClass || &#039;&#039;,
      onChange: onSetLinkClass
    })]
  });
  const linkEditorValue = urlInput !== null ? urlInput : url;
  const hideLightboxPanel = !lightboxEnabled || lightboxEnabled &amp;&amp; !showLightboxSetting;
  const showLinkEditor = !linkEditorValue &amp;&amp; hideLightboxPanel;
  const urlLabel = (getLinkDestinations().find(destination =&gt; destination.linkDestination === linkDestination) || {}).title;
  const PopoverChildren = () =&gt; {
    if (lightboxEnabled &amp;&amp; showLightboxSetting &amp;&amp; !url &amp;&amp; !isEditingLink) {
      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;div&quot;, {
        className: &quot;block-editor-url-popover__expand-on-click&quot;,
        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(build_module_icon, {
          icon: library_fullscreen
        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;div&quot;, {
          className: &quot;text&quot;,
          children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;p&quot;, {
            children: (0,external_wp_i18n_namespaceObject.__)(&#039;Enlarge on click&#039;)
          }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;p&quot;, {
            className: &quot;description&quot;,
            children: (0,external_wp_i18n_namespaceObject.__)(&#039;Scales the image with a lightbox effect&#039;)
          })]
        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
          icon: link_off,
          label: (0,external_wp_i18n_namespaceObject.__)(&#039;Disable enlarge on click&#039;),
          onClick: () =&gt; {
            onSetLightbox?.(false);
          },
          size: &quot;compact&quot;
        })]
      });
    } else if (!url || isEditingLink) {
      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(url_popover.LinkEditor, {
        className: &quot;block-editor-format-toolbar__link-container-content&quot;,
        value: linkEditorValue,
        onChangeInputValue: setUrlInput,
        onSubmit: onSubmitLinkChange(),
        autocompleteRef: autocompleteRef
      });
    } else if (url &amp;&amp; !isEditingLink) {
      return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(url_popover.LinkViewer, {
          className: &quot;block-editor-format-toolbar__link-container-content&quot;,
          url: url,
          onEditLinkClick: startEditLink,
          urlLabel: urlLabel
        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
          icon: link_off,
          label: (0,external_wp_i18n_namespaceObject.__)(&#039;Remove link&#039;),
          onClick: () =&gt; {
            onLinkRemove();
            resetLightbox?.();
          },
          size: &quot;compact&quot;
        })]
      });
    }
  };
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToolbarButton, {
      icon: library_link,
      className: &quot;components-toolbar__control&quot;,
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Link&#039;),
      &quot;aria-expanded&quot;: isOpen,
      onClick: openLinkUI,
      ref: setPopoverAnchor,
      isActive: !!url || lightboxEnabled &amp;&amp; showLightboxSetting
    }), isOpen &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(url_popover, {
      ref: wrapperRef,
      anchor: popoverAnchor,
      onFocusOutside: onFocusOutside(),
      onClose: closeLinkUI,
      renderSettings: hideLightboxPanel ? () =&gt; advancedOptions : null,
      additionalControls: showLinkEditor &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.NavigableMenu, {
        children: [getLinkDestinations().map(link =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, {
          icon: link.icon,
          iconPosition: &quot;left&quot;,
          onClick: () =&gt; {
            setUrlInput(null);
            onSetHref(link.url);
            stopEditLink();
          },
          children: link.title
        }, link.linkDestination)), showLightboxSetting &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, {
          className: &quot;block-editor-url-popover__expand-on-click&quot;,
          icon: library_fullscreen,
          info: (0,external_wp_i18n_namespaceObject.__)(&#039;Scale the image with a lightbox effect.&#039;),
          iconPosition: &quot;left&quot;,
          onClick: () =&gt; {
            setUrlInput(null);
            onChangeUrl({
              linkDestination: LINK_DESTINATION_NONE,
              href: &#039;&#039;
            });
            onSetLightbox?.(true);
            stopEditLink();
          },
          children: (0,external_wp_i18n_namespaceObject.__)(&#039;Enlarge on click&#039;)
        }, &quot;expand-on-click&quot;)]
      }),
      offset: 13,
      children: PopoverChildren()
    })]
  });
};


;// ./node_modules/@wordpress/block-editor/build-module/components/preview-options/index.js
/**
 * WordPress dependencies
 */

function PreviewOptions() {
  external_wp_deprecated_default()(&#039;wp.blockEditor.PreviewOptions&#039;, {
    version: &#039;6.5&#039;
  });
  return null;
}

;// ./node_modules/@wordpress/block-editor/build-module/components/use-resize-canvas/index.js
/**
 * WordPress dependencies
 */


/**
 * Function to resize the editor window.
 *
 * @param {string} deviceType Used for determining the size of the container (e.g. Desktop, Tablet, Mobile)
 *
 * @return {Object} Inline styles to be added to resizable container.
 */
function useResizeCanvas(deviceType) {
  const [actualWidth, updateActualWidth] = (0,external_wp_element_namespaceObject.useState)(window.innerWidth);
  (0,external_wp_element_namespaceObject.useEffect)(() =&gt; {
    if (deviceType === &#039;Desktop&#039;) {
      return;
    }
    const resizeListener = () =&gt; updateActualWidth(window.innerWidth);
    window.addEventListener(&#039;resize&#039;, resizeListener);
    return () =&gt; {
      window.removeEventListener(&#039;resize&#039;, resizeListener);
    };
  }, [deviceType]);
  const getCanvasWidth = device =&gt; {
    let deviceWidth;
    switch (device) {
      case &#039;Tablet&#039;:
        deviceWidth = 780;
        break;
      case &#039;Mobile&#039;:
        deviceWidth = 360;
        break;
      default:
        return null;
    }
    return deviceWidth &lt; actualWidth ? deviceWidth : actualWidth;
  };
  const contentInlineStyles = device =&gt; {
    const height = device === &#039;Mobile&#039; ? &#039;768px&#039; : &#039;1024px&#039;;
    const marginVertical = &#039;40px&#039;;
    const marginHorizontal = &#039;auto&#039;;
    switch (device) {
      case &#039;Tablet&#039;:
      case &#039;Mobile&#039;:
        return {
          width: getCanvasWidth(device),
          // Keeping margin styles separate to avoid warnings
          // when those props get overridden in the iframe component
          marginTop: marginVertical,
          marginBottom: marginVertical,
          marginLeft: marginHorizontal,
          marginRight: marginHorizontal,
          height,
          maxWidth: &#039;100%&#039;
        };
      default:
        return {
          marginLeft: marginHorizontal,
          marginRight: marginHorizontal
        };
    }
  };
  return contentInlineStyles(deviceType);
}

;// ./node_modules/@wordpress/block-editor/build-module/components/skip-to-selected-block/index.js
/**
 * WordPress dependencies
 */





/**
 * Internal dependencies
 */



/**
 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/skip-to-selected-block/README.md
 */

function SkipToSelectedBlock() {
  const selectedBlockClientId = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; select(store).getBlockSelectionStart(), []);
  const ref = (0,external_wp_element_namespaceObject.useRef)();
  useBlockElementRef(selectedBlockClientId, ref);
  const onClick = () =&gt; {
    ref.current?.focus();
  };
  return selectedBlockClientId ? /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
    __next40pxDefaultSize: true,
    variant: &quot;secondary&quot;,
    className: &quot;block-editor-skip-to-selected-block&quot;,
    onClick: onClick,
    children: (0,external_wp_i18n_namespaceObject.__)(&#039;Skip to the selected block&#039;)
  }) : null;
}

;// ./node_modules/@wordpress/block-editor/build-module/components/multi-selection-inspector/index.js
/**
 * WordPress dependencies
 */





/**
 * Internal dependencies
 */



function MultiSelectionInspector() {
  const selectedBlockCount = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; select(store).getSelectedBlockCount(), []);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalHStack, {
    justify: &quot;flex-start&quot;,
    spacing: 2,
    className: &quot;block-editor-multi-selection-inspector__card&quot;,
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_icon, {
      icon: library_copy,
      showColors: true
    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
      className: &quot;block-editor-multi-selection-inspector__card-title&quot;,
      children: (0,external_wp_i18n_namespaceObject.sprintf)(/* translators: %d: number of blocks */
      (0,external_wp_i18n_namespaceObject._n)(&#039;%d Block&#039;, &#039;%d Blocks&#039;, selectedBlockCount), selectedBlockCount)
    })]
  });
}

;// ./node_modules/@wordpress/icons/build-module/library/cog.js
/**
 * WordPress dependencies
 */


const cog = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    fillRule: &quot;evenodd&quot;,
    d: &quot;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&quot;,
    clipRule: &quot;evenodd&quot;
  })
});
/* harmony default export */ const library_cog = (cog);

;// ./node_modules/@wordpress/icons/build-module/library/styles.js
/**
 * WordPress dependencies
 */


const styles = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  viewBox: &quot;0 0 24 24&quot;,
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    fillRule: &quot;evenodd&quot;,
    clipRule: &quot;evenodd&quot;,
    d: &quot;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&quot;
  })
});
/* harmony default export */ const library_styles = (styles);

;// ./node_modules/@wordpress/block-editor/build-module/components/inspector-controls-tabs/utils.js
/**
 * WordPress dependencies
 */


const TAB_SETTINGS = {
  name: &#039;settings&#039;,
  title: (0,external_wp_i18n_namespaceObject.__)(&#039;Settings&#039;),
  value: &#039;settings&#039;,
  icon: library_cog
};
const TAB_STYLES = {
  name: &#039;styles&#039;,
  title: (0,external_wp_i18n_namespaceObject.__)(&#039;Styles&#039;),
  value: &#039;styles&#039;,
  icon: library_styles
};
const TAB_LIST_VIEW = {
  name: &#039;list&#039;,
  title: (0,external_wp_i18n_namespaceObject.__)(&#039;List View&#039;),
  value: &#039;list-view&#039;,
  icon: list_view
};

;// ./node_modules/@wordpress/block-editor/build-module/components/inspector-controls-tabs/advanced-controls-panel.js
/**
 * WordPress dependencies
 */



/**
 * Internal dependencies
 */


const AdvancedControls = () =&gt; {
  const fills = (0,external_wp_components_namespaceObject.__experimentalUseSlotFills)(InspectorAdvancedControls.slotName);
  const hasFills = Boolean(fills &amp;&amp; fills.length);
  if (!hasFills) {
    return null;
  }
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.PanelBody, {
    className: &quot;block-editor-block-inspector__advanced&quot;,
    title: (0,external_wp_i18n_namespaceObject.__)(&#039;Advanced&#039;),
    initialOpen: false,
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls.Slot, {
      group: &quot;advanced&quot;
    })
  });
};
/* harmony default export */ const advanced_controls_panel = (AdvancedControls);

;// ./node_modules/@wordpress/block-editor/build-module/components/inspector-controls-tabs/position-controls-panel.js
/**
 * WordPress dependencies
 */




/**
 * Internal dependencies
 */






const PositionControlsPanel = () =&gt; {
  const {
    selectedClientIds,
    selectedBlocks,
    hasPositionAttribute
  } = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      getBlocksByClientId,
      getSelectedBlockClientIds
    } = select(store);
    const selectedBlockClientIds = getSelectedBlockClientIds();
    const _selectedBlocks = getBlocksByClientId(selectedBlockClientIds);
    return {
      selectedClientIds: selectedBlockClientIds,
      selectedBlocks: _selectedBlocks,
      hasPositionAttribute: _selectedBlocks?.some(({
        attributes
      }) =&gt; !!attributes?.style?.position?.type)
    };
  }, []);
  const {
    updateBlockAttributes
  } = (0,external_wp_data_namespaceObject.useDispatch)(store);
  const dropdownMenuProps = useToolsPanelDropdownMenuProps();
  function resetPosition() {
    if (!selectedClientIds?.length || !selectedBlocks?.length) {
      return;
    }
    const attributesByClientId = Object.fromEntries(selectedBlocks?.map(({
      clientId,
      attributes
    }) =&gt; [clientId, {
      style: utils_cleanEmptyObject({
        ...attributes?.style,
        position: {
          ...attributes?.style?.position,
          type: undefined,
          top: undefined,
          right: undefined,
          bottom: undefined,
          left: undefined
        }
      })
    }]));
    updateBlockAttributes(selectedClientIds, attributesByClientId, true);
  }
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanel, {
    className: &quot;block-editor-block-inspector__position&quot;,
    label: (0,external_wp_i18n_namespaceObject.__)(&#039;Position&#039;),
    resetAll: resetPosition,
    dropdownMenuProps: dropdownMenuProps,
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanelItem, {
      isShownByDefault: hasPositionAttribute,
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Position&#039;),
      hasValue: () =&gt; hasPositionAttribute,
      onDeselect: resetPosition,
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls.Slot, {
        group: &quot;position&quot;
      })
    })
  });
};
const PositionControls = () =&gt; {
  const fills = (0,external_wp_components_namespaceObject.__experimentalUseSlotFills)(inspector_controls_groups.position.name);
  const hasFills = Boolean(fills &amp;&amp; fills.length);
  if (!hasFills) {
    return null;
  }
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PositionControlsPanel, {});
};
/* harmony default export */ const position_controls_panel = (PositionControls);

;// ./node_modules/@wordpress/block-editor/build-module/components/inspector-controls-tabs/settings-tab.js
/**
 * Internal dependencies
 */




const SettingsTab = ({
  showAdvancedControls = false
}) =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
  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, {
    group: &quot;bindings&quot;
  }), showAdvancedControls &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(advanced_controls_panel, {})
  })]
});
/* harmony default export */ const settings_tab = (SettingsTab);

;// ./node_modules/@wordpress/block-editor/build-module/components/inspector-controls-tabs/styles-tab.js
/**
 * WordPress dependencies
 */



/**
 * Internal dependencies
 */




const StylesTab = ({
  blockName,
  clientId,
  hasBlockStyles
}) =&gt; {
  const borderPanelLabel = useBorderPanelLabel({
    blockName
  });
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
    children: [hasBlockStyles &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.PanelBody, {
        title: (0,external_wp_i18n_namespaceObject.__)(&#039;Styles&#039;),
        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_styles, {
          clientId: clientId
        })
      })
    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls.Slot, {
      group: &quot;color&quot;,
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Color&#039;),
      className: &quot;color-block-support-panel__inner-wrapper&quot;
    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls.Slot, {
      group: &quot;background&quot;,
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Background image&#039;)
    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls.Slot, {
      group: &quot;filter&quot;
    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls.Slot, {
      group: &quot;typography&quot;,
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Typography&#039;)
    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls.Slot, {
      group: &quot;dimensions&quot;,
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Dimensions&#039;)
    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls.Slot, {
      group: &quot;border&quot;,
      label: borderPanelLabel
    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls.Slot, {
      group: &quot;styles&quot;
    })]
  });
};
/* harmony default export */ const styles_tab = (StylesTab);

;// ./node_modules/@wordpress/block-editor/build-module/components/inspector-controls-tabs/use-is-list-view-tab-disabled.js
// List view tab restricts the blocks that may render to it via the
// allowlist below.
const allowlist = [&#039;core/navigation&#039;];
const useIsListViewTabDisabled = blockName =&gt; {
  return !allowlist.includes(blockName);
};
/* harmony default export */ const use_is_list_view_tab_disabled = (useIsListViewTabDisabled);

;// ./node_modules/@wordpress/block-editor/build-module/components/inspector-controls-tabs/index.js
/**
 * WordPress dependencies
 */




/**
 * Internal dependencies
 */







const {
  Tabs: inspector_controls_tabs_Tabs
} = unlock(external_wp_components_namespaceObject.privateApis);
function InspectorControlsTabs({
  blockName,
  clientId,
  hasBlockStyles,
  tabs
}) {
  const showIconLabels = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    return select(external_wp_preferences_namespaceObject.store).get(&#039;core&#039;, &#039;showIconLabels&#039;);
  }, []);

  // The tabs panel will mount before fills are rendered to the list view
  // slot. This means the list view tab isn&#039;t initially included in the
  // available tabs so the panel defaults selection to the settings tab
  // which at the time is the first tab. This check allows blocks known to
  // include the list view tab to set it as the tab selected by default.
  const initialTabName = !use_is_list_view_tab_disabled(blockName) ? TAB_LIST_VIEW.name : undefined;
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
    className: &quot;block-editor-block-inspector__tabs&quot;,
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(inspector_controls_tabs_Tabs, {
      defaultTabId: initialTabName,
      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls_tabs_Tabs.TabList, {
        children: tabs.map(tab =&gt; showIconLabels ? /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls_tabs_Tabs.Tab, {
          tabId: tab.name,
          children: tab.title
        }, tab.name) : /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Tooltip, {
          text: tab.title,
          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls_tabs_Tabs.Tab, {
            tabId: tab.name,
            &quot;aria-label&quot;: tab.title,
            children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Icon, {
              icon: tab.icon
            })
          })
        }, tab.name))
      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls_tabs_Tabs.TabPanel, {
        tabId: TAB_SETTINGS.name,
        focusable: false,
        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(settings_tab, {
          showAdvancedControls: !!blockName
        })
      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls_tabs_Tabs.TabPanel, {
        tabId: TAB_STYLES.name,
        focusable: false,
        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(styles_tab, {
          blockName: blockName,
          clientId: clientId,
          hasBlockStyles: hasBlockStyles
        })
      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls_tabs_Tabs.TabPanel, {
        tabId: TAB_LIST_VIEW.name,
        focusable: false,
        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls.Slot, {
          group: &quot;list&quot;
        })
      })]
    }, clientId)
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/inspector-controls-tabs/use-inspector-controls-tabs.js
/**
 * WordPress dependencies
 */



/**
 * Internal dependencies
 */





const use_inspector_controls_tabs_EMPTY_ARRAY = [];
function getShowTabs(blockName, tabSettings = {}) {
  // Block specific setting takes precedence over generic default.
  if (tabSettings[blockName] !== undefined) {
    return tabSettings[blockName];
  }

  // Use generic default if set over the Gutenberg experiment option.
  if (tabSettings.default !== undefined) {
    return tabSettings.default;
  }
  return true;
}
function useInspectorControlsTabs(blockName) {
  const tabs = [];
  const {
    bindings: bindingsGroup,
    border: borderGroup,
    color: colorGroup,
    default: defaultGroup,
    dimensions: dimensionsGroup,
    list: listGroup,
    position: positionGroup,
    styles: stylesGroup,
    typography: typographyGroup,
    effects: effectsGroup
  } = inspector_controls_groups;

  // List View Tab: If there are any fills for the list group add that tab.
  const listViewDisabled = use_is_list_view_tab_disabled(blockName);
  const listFills = (0,external_wp_components_namespaceObject.__experimentalUseSlotFills)(listGroup.name);
  const hasListFills = !listViewDisabled &amp;&amp; !!listFills &amp;&amp; listFills.length;

  // Styles Tab: Add this tab if there are any fills for block supports
  // e.g. border, color, spacing, typography, etc.
  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) || [])];
  const hasStyleFills = styleFills.length;

  // Settings Tab: If we don&#039;t have multiple tabs to display
  // (i.e. both list view and styles), check only the default and position
  // InspectorControls slots. If we have multiple tabs, we&#039;ll need to check
  // the advanced controls slot as well to ensure they are rendered.
  const advancedFills = [...((0,external_wp_components_namespaceObject.__experimentalUseSlotFills)(InspectorAdvancedControls.slotName) || []), ...((0,external_wp_components_namespaceObject.__experimentalUseSlotFills)(bindingsGroup.name) || [])];
  const settingsFills = [...((0,external_wp_components_namespaceObject.__experimentalUseSlotFills)(defaultGroup.name) || []), ...((0,external_wp_components_namespaceObject.__experimentalUseSlotFills)(positionGroup.name) || []), ...(hasListFills &amp;&amp; hasStyleFills &gt; 1 ? advancedFills : [])];

  // Add the tabs in the order that they will default to if available.
  // List View &gt; Settings &gt; Styles.
  if (hasListFills) {
    tabs.push(TAB_LIST_VIEW);
  }
  if (settingsFills.length) {
    tabs.push(TAB_SETTINGS);
  }
  if (hasStyleFills) {
    tabs.push(TAB_STYLES);
  }
  const tabSettings = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    return select(store).getSettings().blockInspectorTabs;
  }, []);
  const showTabs = getShowTabs(blockName, tabSettings);
  return showTabs ? tabs : use_inspector_controls_tabs_EMPTY_ARRAY;
}

;// ./node_modules/@wordpress/block-editor/build-module/components/block-inspector/useBlockInspectorAnimationSettings.js
/**
 * WordPress dependencies
 */


/**
 * Internal dependencies
 */

function useBlockInspectorAnimationSettings(blockType) {
  return (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    if (blockType) {
      const globalBlockInspectorAnimationSettings = select(store).getSettings().blockInspectorAnimation;

      // Get the name of the block that will allow it&#039;s children to be animated.
      const animationParent = globalBlockInspectorAnimationSettings?.animationParent;

      // Determine whether the animationParent block is a parent of the selected block.
      const {
        getSelectedBlockClientId,
        getBlockParentsByBlockName
      } = select(store);
      const _selectedBlockClientId = getSelectedBlockClientId();
      const animationParentBlockClientId = getBlockParentsByBlockName(_selectedBlockClientId, animationParent, true)[0];

      // If the selected block is not a child of the animationParent block,
      // and not an animationParent block itself, don&#039;t animate.
      if (!animationParentBlockClientId &amp;&amp; blockType.name !== animationParent) {
        return null;
      }
      return globalBlockInspectorAnimationSettings?.[blockType.name];
    }
    return null;
  }, [blockType]);
}

;// ./node_modules/@wordpress/block-editor/build-module/components/block-quick-navigation/index.js
/**
 * WordPress dependencies
 */



/**
 * Internal dependencies
 */





function BlockQuickNavigation({
  clientIds,
  onSelect
}) {
  if (!clientIds.length) {
    return null;
  }
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalVStack, {
    spacing: 1,
    children: clientIds.map(clientId =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockQuickNavigationItem, {
      onSelect: onSelect,
      clientId: clientId
    }, clientId))
  });
}
function BlockQuickNavigationItem({
  clientId,
  onSelect
}) {
  const blockInformation = useBlockDisplayInformation(clientId);
  const blockTitle = useBlockDisplayTitle({
    clientId,
    context: &#039;list-view&#039;
  });
  const {
    isSelected
  } = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      isBlockSelected,
      hasSelectedInnerBlock
    } = select(store);
    return {
      isSelected: isBlockSelected(clientId) || hasSelectedInnerBlock(clientId, /* deep: */true)
    };
  }, [clientId]);
  const {
    selectBlock
  } = (0,external_wp_data_namespaceObject.useDispatch)(store);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
    __next40pxDefaultSize: true,
    isPressed: isSelected,
    onClick: async () =&gt; {
      await selectBlock(clientId);
      if (onSelect) {
        onSelect(clientId);
      }
    },
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.Flex, {
      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FlexItem, {
        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_icon, {
          icon: blockInformation?.icon
        })
      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.FlexBlock, {
        style: {
          textAlign: &#039;left&#039;
        },
        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalTruncate, {
          children: blockTitle
        })
      })]
    })
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/block-inspector/index.js
/**
 * WordPress dependencies
 */





/**
 * Internal dependencies
 */

















function BlockStylesPanel({
  clientId
}) {
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.PanelBody, {
    title: (0,external_wp_i18n_namespaceObject.__)(&#039;Styles&#039;),
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_styles, {
      clientId: clientId
    })
  });
}
function BlockInspector() {
  const {
    count,
    selectedBlockName,
    selectedBlockClientId,
    blockType,
    isSectionBlock
  } = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      getSelectedBlockClientId,
      getSelectedBlockCount,
      getBlockName,
      getParentSectionBlock,
      isSectionBlock: _isSectionBlock
    } = unlock(select(store));
    const _selectedBlockClientId = getSelectedBlockClientId();
    const renderedBlockClientId = getParentSectionBlock(_selectedBlockClientId) || getSelectedBlockClientId();
    const _selectedBlockName = renderedBlockClientId &amp;&amp; getBlockName(renderedBlockClientId);
    const _blockType = _selectedBlockName &amp;&amp; (0,external_wp_blocks_namespaceObject.getBlockType)(_selectedBlockName);
    return {
      count: getSelectedBlockCount(),
      selectedBlockClientId: renderedBlockClientId,
      selectedBlockName: _selectedBlockName,
      blockType: _blockType,
      isSectionBlock: _isSectionBlock(renderedBlockClientId)
    };
  }, []);
  const availableTabs = useInspectorControlsTabs(blockType?.name);
  const showTabs = availableTabs?.length &gt; 1;

  // The block inspector animation settings will be completely
  // removed in the future to create an API which allows the block
  // inspector to transition between what it
  // displays based on the relationship between the selected block
  // and its parent, and only enable it if the parent is controlling
  // its children blocks.
  const blockInspectorAnimationSettings = useBlockInspectorAnimationSettings(blockType);
  const borderPanelLabel = useBorderPanelLabel({
    blockName: selectedBlockName
  });
  if (count &gt; 1 &amp;&amp; !isSectionBlock) {
    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;div&quot;, {
      className: &quot;block-editor-block-inspector&quot;,
      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(MultiSelectionInspector, {}), showTabs ? /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(InspectorControlsTabs, {
        tabs: availableTabs
      }) : /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls.Slot, {}), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls.Slot, {
          group: &quot;color&quot;,
          label: (0,external_wp_i18n_namespaceObject.__)(&#039;Color&#039;),
          className: &quot;color-block-support-panel__inner-wrapper&quot;
        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls.Slot, {
          group: &quot;background&quot;,
          label: (0,external_wp_i18n_namespaceObject.__)(&#039;Background image&#039;)
        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls.Slot, {
          group: &quot;typography&quot;,
          label: (0,external_wp_i18n_namespaceObject.__)(&#039;Typography&#039;)
        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls.Slot, {
          group: &quot;dimensions&quot;,
          label: (0,external_wp_i18n_namespaceObject.__)(&#039;Dimensions&#039;)
        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls.Slot, {
          group: &quot;border&quot;,
          label: borderPanelLabel
        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls.Slot, {
          group: &quot;styles&quot;
        })]
      })]
    });
  }
  const isSelectedBlockUnregistered = selectedBlockName === (0,external_wp_blocks_namespaceObject.getUnregisteredTypeHandlerName)();

  /*
   * If the selected block is of an unregistered type, avoid showing it as an actual selection
   * because we want the user to focus on the unregistered block warning, not block settings.
   */
  if (!blockType || !selectedBlockClientId || isSelectedBlockUnregistered) {
    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;span&quot;, {
      className: &quot;block-editor-block-inspector__no-blocks&quot;,
      children: (0,external_wp_i18n_namespaceObject.__)(&#039;No block selected.&#039;)
    });
  }
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockInspectorSingleBlockWrapper, {
    animate: blockInspectorAnimationSettings,
    wrapper: children =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(AnimatedContainer, {
      blockInspectorAnimationSettings: blockInspectorAnimationSettings,
      selectedBlockClientId: selectedBlockClientId,
      children: children
    }),
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockInspectorSingleBlock, {
      clientId: selectedBlockClientId,
      blockName: blockType.name,
      isSectionBlock: isSectionBlock
    })
  });
}
const BlockInspectorSingleBlockWrapper = ({
  animate,
  wrapper,
  children
}) =&gt; {
  return animate ? wrapper(children) : children;
};
const AnimatedContainer = ({
  blockInspectorAnimationSettings,
  selectedBlockClientId,
  children
}) =&gt; {
  const animationOrigin = blockInspectorAnimationSettings &amp;&amp; blockInspectorAnimationSettings.enterDirection === &#039;leftToRight&#039; ? -50 : 50;
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__unstableMotion.div, {
    animate: {
      x: 0,
      opacity: 1,
      transition: {
        ease: &#039;easeInOut&#039;,
        duration: 0.14
      }
    },
    initial: {
      x: animationOrigin,
      opacity: 0
    },
    children: children
  }, selectedBlockClientId);
};
const BlockInspectorSingleBlock = ({
  clientId,
  blockName,
  isSectionBlock
}) =&gt; {
  const availableTabs = useInspectorControlsTabs(blockName);
  const showTabs = !isSectionBlock &amp;&amp; availableTabs?.length &gt; 1;
  const hasBlockStyles = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      getBlockStyles
    } = select(external_wp_blocks_namespaceObject.store);
    const blockStyles = getBlockStyles(blockName);
    return blockStyles &amp;&amp; blockStyles.length &gt; 0;
  }, [blockName]);
  const blockInformation = useBlockDisplayInformation(clientId);
  const borderPanelLabel = useBorderPanelLabel({
    blockName
  });
  const contentClientIds = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    // Avoid unnecessary subscription.
    if (!isSectionBlock) {
      return;
    }
    const {
      getClientIdsOfDescendants,
      getBlockName,
      getBlockEditingMode
    } = select(store);
    return getClientIdsOfDescendants(clientId).filter(current =&gt; getBlockName(current) !== &#039;core/list-item&#039; &amp;&amp; getBlockEditingMode(current) === &#039;contentOnly&#039;);
  }, [isSectionBlock, clientId]);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;div&quot;, {
    className: &quot;block-editor-block-inspector&quot;,
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_card, {
      ...blockInformation,
      className: blockInformation.isSynced &amp;&amp; &#039;is-synced&#039;
    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_variation_transforms, {
      blockClientId: clientId
    }), showTabs &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(InspectorControlsTabs, {
      hasBlockStyles: hasBlockStyles,
      clientId: clientId,
      blockName: blockName,
      tabs: availableTabs
    }), !showTabs &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
      children: [hasBlockStyles &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockStylesPanel, {
        clientId: clientId
      }), contentClientIds &amp;&amp; contentClientIds?.length &gt; 0 &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.PanelBody, {
        title: (0,external_wp_i18n_namespaceObject.__)(&#039;Content&#039;),
        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockQuickNavigation, {
          clientIds: contentClientIds
        })
      }), !isSectionBlock &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls.Slot, {}), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls.Slot, {
          group: &quot;list&quot;
        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls.Slot, {
          group: &quot;color&quot;,
          label: (0,external_wp_i18n_namespaceObject.__)(&#039;Color&#039;),
          className: &quot;color-block-support-panel__inner-wrapper&quot;
        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls.Slot, {
          group: &quot;background&quot;,
          label: (0,external_wp_i18n_namespaceObject.__)(&#039;Background image&#039;)
        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls.Slot, {
          group: &quot;typography&quot;,
          label: (0,external_wp_i18n_namespaceObject.__)(&#039;Typography&#039;)
        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls.Slot, {
          group: &quot;dimensions&quot;,
          label: (0,external_wp_i18n_namespaceObject.__)(&#039;Dimensions&#039;)
        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls.Slot, {
          group: &quot;border&quot;,
          label: borderPanelLabel
        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls.Slot, {
          group: &quot;styles&quot;
        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(position_controls_panel, {}), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(inspector_controls.Slot, {
          group: &quot;bindings&quot;
        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
          children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(advanced_controls_panel, {})
        })]
      })]
    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(SkipToSelectedBlock, {}, &quot;back&quot;)]
  });
};

/**
 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/block-editor/src/components/block-inspector/README.md
 */
/* harmony default export */ const block_inspector = (BlockInspector);

;// ./node_modules/@wordpress/block-editor/build-module/components/copy-handler/index.js
/**
 * WordPress dependencies
 */


/**
 * Internal dependencies
 */


/**
 * @deprecated
 */

const __unstableUseClipboardHandler = () =&gt; {
  external_wp_deprecated_default()(&#039;__unstableUseClipboardHandler&#039;, {
    alternative: &#039;BlockCanvas or WritingFlow&#039;,
    since: &#039;6.4&#039;,
    version: &#039;6.7&#039;
  });
  return useClipboardHandler();
};

/**
 * @deprecated
 * @param {Object} props
 */
function CopyHandler(props) {
  external_wp_deprecated_default()(&#039;CopyHandler&#039;, {
    alternative: &#039;BlockCanvas or WritingFlow&#039;,
    since: &#039;6.4&#039;,
    version: &#039;6.7&#039;
  });
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
    ...props,
    ref: useClipboardHandler()
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/inserter/library.js
/**
 * WordPress dependencies
 */



/**
 * Internal dependencies
 */



const library_noop = () =&gt; {};
function InserterLibrary({
  rootClientId,
  clientId,
  isAppender,
  showInserterHelpPanel,
  showMostUsedBlocks = false,
  __experimentalInsertionIndex,
  __experimentalInitialTab,
  __experimentalInitialCategory,
  __experimentalFilterValue,
  onPatternCategorySelection,
  onSelect = library_noop,
  shouldFocusBlock = false,
  onClose
}, ref) {
  const {
    destinationRootClientId
  } = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      getBlockRootClientId
    } = select(store);
    const _rootClientId = rootClientId || getBlockRootClientId(clientId) || undefined;
    return {
      destinationRootClientId: _rootClientId
    };
  }, [clientId, rootClientId]);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PrivateInserterMenu, {
    onSelect: onSelect,
    rootClientId: destinationRootClientId,
    clientId: clientId,
    isAppender: isAppender,
    showInserterHelpPanel: showInserterHelpPanel,
    showMostUsedBlocks: showMostUsedBlocks,
    __experimentalInsertionIndex: __experimentalInsertionIndex,
    __experimentalFilterValue: __experimentalFilterValue,
    onPatternCategorySelection: onPatternCategorySelection,
    __experimentalInitialTab: __experimentalInitialTab,
    __experimentalInitialCategory: __experimentalInitialCategory,
    shouldFocusBlock: shouldFocusBlock,
    ref: ref,
    onClose: onClose
  });
}
const PrivateInserterLibrary = (0,external_wp_element_namespaceObject.forwardRef)(InserterLibrary);
function PublicInserterLibrary(props, ref) {
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PrivateInserterLibrary, {
    ...props,
    onPatternCategorySelection: undefined,
    ref: ref
  });
}
/* harmony default export */ const library = ((0,external_wp_element_namespaceObject.forwardRef)(PublicInserterLibrary));

;// ./node_modules/@wordpress/block-editor/build-module/components/selection-scroll-into-view/index.js
/**
 * WordPress dependencies
 */


/**
 * Scrolls the multi block selection end into view if not in view already. This
 * is important to do after selection by keyboard.
 *
 * @deprecated
 */
function MultiSelectScrollIntoView() {
  external_wp_deprecated_default()(&#039;wp.blockEditor.MultiSelectScrollIntoView&#039;, {
    hint: &#039;This behaviour is now built-in.&#039;,
    since: &#039;5.8&#039;
  });
  return null;
}

;// ./node_modules/@wordpress/block-editor/build-module/components/typewriter/index.js
/**
 * WordPress dependencies
 */





/**
 * Internal dependencies
 */


const isIE = window.navigator.userAgent.indexOf(&#039;Trident&#039;) !== -1;
const arrowKeyCodes = new Set([external_wp_keycodes_namespaceObject.UP, external_wp_keycodes_namespaceObject.DOWN, external_wp_keycodes_namespaceObject.LEFT, external_wp_keycodes_namespaceObject.RIGHT]);
const initialTriggerPercentage = 0.75;
function useTypewriter() {
  const hasSelectedBlock = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; select(store).hasSelectedBlock(), []);
  return (0,external_wp_compose_namespaceObject.useRefEffect)(node =&gt; {
    if (!hasSelectedBlock) {
      return;
    }
    const {
      ownerDocument
    } = node;
    const {
      defaultView
    } = ownerDocument;
    let scrollResizeRafId;
    let onKeyDownRafId;
    let caretRect;
    function onScrollResize() {
      if (scrollResizeRafId) {
        return;
      }
      scrollResizeRafId = defaultView.requestAnimationFrame(() =&gt; {
        computeCaretRectangle();
        scrollResizeRafId = null;
      });
    }
    function onKeyDown(event) {
      // Ensure the any remaining request is cancelled.
      if (onKeyDownRafId) {
        defaultView.cancelAnimationFrame(onKeyDownRafId);
      }

      // Use an animation frame for a smooth result.
      onKeyDownRafId = defaultView.requestAnimationFrame(() =&gt; {
        maintainCaretPosition(event);
        onKeyDownRafId = null;
      });
    }

    /**
     * Maintains the scroll position after a selection change caused by a
     * keyboard event.
     *
     * @param {KeyboardEvent} event Keyboard event.
     */
    function maintainCaretPosition({
      keyCode
    }) {
      if (!isSelectionEligibleForScroll()) {
        return;
      }
      const currentCaretRect = (0,external_wp_dom_namespaceObject.computeCaretRect)(defaultView);
      if (!currentCaretRect) {
        return;
      }

      // If for some reason there is no position set to be scrolled to, let
      // this be the position to be scrolled to in the future.
      if (!caretRect) {
        caretRect = currentCaretRect;
        return;
      }

      // Even though enabling the typewriter effect for arrow keys results in
      // a pleasant experience, it may not be the case for everyone, so, for
      // now, let&#039;s disable it.
      if (arrowKeyCodes.has(keyCode)) {
        // Reset the caret position to maintain.
        caretRect = currentCaretRect;
        return;
      }
      const diff = currentCaretRect.top - caretRect.top;
      if (diff === 0) {
        return;
      }
      const scrollContainer = (0,external_wp_dom_namespaceObject.getScrollContainer)(node);

      // The page must be scrollable.
      if (!scrollContainer) {
        return;
      }
      const windowScroll = scrollContainer === ownerDocument.body || scrollContainer === ownerDocument.documentElement;
      const scrollY = windowScroll ? defaultView.scrollY : scrollContainer.scrollTop;
      const scrollContainerY = windowScroll ? 0 : scrollContainer.getBoundingClientRect().top;
      const relativeScrollPosition = windowScroll ? caretRect.top / defaultView.innerHeight : (caretRect.top - scrollContainerY) / (defaultView.innerHeight - scrollContainerY);

      // If the scroll position is at the start, the active editable element
      // is the last one, and the caret is positioned within the initial
      // trigger percentage of the page, do not scroll the page.
      // The typewriter effect should not kick in until an empty page has been
      // filled with the initial trigger percentage or the user scrolls
      // intentionally down.
      if (scrollY === 0 &amp;&amp; relativeScrollPosition &lt; initialTriggerPercentage &amp;&amp; isLastEditableNode()) {
        // Reset the caret position to maintain.
        caretRect = currentCaretRect;
        return;
      }
      const scrollContainerHeight = windowScroll ? defaultView.innerHeight : scrollContainer.clientHeight;

      // Abort if the target scroll position would scroll the caret out of
      // view.
      if (
      // The caret is under the lower fold.
      caretRect.top + caretRect.height &gt; scrollContainerY + scrollContainerHeight ||
      // The caret is above the upper fold.
      caretRect.top &lt; scrollContainerY) {
        // Reset the caret position to maintain.
        caretRect = currentCaretRect;
        return;
      }
      if (windowScroll) {
        defaultView.scrollBy(0, diff);
      } else {
        scrollContainer.scrollTop += diff;
      }
    }

    /**
     * Adds a `selectionchange` listener to reset the scroll position to be
     * maintained.
     */
    function addSelectionChangeListener() {
      ownerDocument.addEventListener(&#039;selectionchange&#039;, computeCaretRectOnSelectionChange);
    }

    /**
     * Resets the scroll position to be maintained during a `selectionchange`
     * event. Also removes the listener, so it acts as a one-time listener.
     */
    function computeCaretRectOnSelectionChange() {
      ownerDocument.removeEventListener(&#039;selectionchange&#039;, computeCaretRectOnSelectionChange);
      computeCaretRectangle();
    }

    /**
     * Resets the scroll position to be maintained.
     */
    function computeCaretRectangle() {
      if (isSelectionEligibleForScroll()) {
        caretRect = (0,external_wp_dom_namespaceObject.computeCaretRect)(defaultView);
      }
    }

    /**
     * Checks if the current situation is eligible for scroll:
     * - There should be one and only one block selected.
     * - The component must contain the selection.
     * - The active element must be contenteditable.
     */
    function isSelectionEligibleForScroll() {
      return node.contains(ownerDocument.activeElement) &amp;&amp; ownerDocument.activeElement.isContentEditable;
    }
    function isLastEditableNode() {
      const editableNodes = node.querySelectorAll(&#039;[contenteditable=&quot;true&quot;]&#039;);
      const lastEditableNode = editableNodes[editableNodes.length - 1];
      return lastEditableNode === ownerDocument.activeElement;
    }

    // When the user scrolls or resizes, the scroll position should be
    // reset.
    defaultView.addEventListener(&#039;scroll&#039;, onScrollResize, true);
    defaultView.addEventListener(&#039;resize&#039;, onScrollResize, true);
    node.addEventListener(&#039;keydown&#039;, onKeyDown);
    node.addEventListener(&#039;keyup&#039;, maintainCaretPosition);
    node.addEventListener(&#039;mousedown&#039;, addSelectionChangeListener);
    node.addEventListener(&#039;touchstart&#039;, addSelectionChangeListener);
    return () =&gt; {
      defaultView.removeEventListener(&#039;scroll&#039;, onScrollResize, true);
      defaultView.removeEventListener(&#039;resize&#039;, onScrollResize, true);
      node.removeEventListener(&#039;keydown&#039;, onKeyDown);
      node.removeEventListener(&#039;keyup&#039;, maintainCaretPosition);
      node.removeEventListener(&#039;mousedown&#039;, addSelectionChangeListener);
      node.removeEventListener(&#039;touchstart&#039;, addSelectionChangeListener);
      ownerDocument.removeEventListener(&#039;selectionchange&#039;, computeCaretRectOnSelectionChange);
      defaultView.cancelAnimationFrame(scrollResizeRafId);
      defaultView.cancelAnimationFrame(onKeyDownRafId);
    };
  }, [hasSelectedBlock]);
}
function Typewriter({
  children
}) {
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
    ref: useTypewriter(),
    className: &quot;block-editor__typewriter&quot;,
    children: children
  });
}

/**
 * The exported component. The implementation of Typewriter faced technical
 * challenges in Internet Explorer, and is simply skipped, rendering the given
 * props children instead.
 *
 * @type {Component}
 */
const TypewriterOrIEBypass = isIE ? props =&gt; props.children : Typewriter;

/**
 * Ensures that the text selection keeps the same vertical distance from the
 * viewport during keyboard events within this component. The vertical distance
 * can vary. It is the last clicked or scrolled to position.
 */
/* harmony default export */ const typewriter = (TypewriterOrIEBypass);

;// ./node_modules/@wordpress/block-editor/build-module/components/recursion-provider/index.js
/**
 * WordPress dependencies
 */



/**
 * Internal dependencies
 */


const RenderedRefsContext = (0,external_wp_element_namespaceObject.createContext)({});

/**
 * Immutably adds an unique identifier to a set scoped for a given block type.
 *
 * @param {Object} renderedBlocks Rendered blocks grouped by block name
 * @param {string} blockName      Name of the block.
 * @param {*}      uniqueId       Any value that acts as a unique identifier for a block instance.
 *
 * @return {Object} The list of rendered blocks grouped by block name.
 */
function addToBlockType(renderedBlocks, blockName, uniqueId) {
  const result = {
    ...renderedBlocks,
    [blockName]: renderedBlocks[blockName] ? new Set(renderedBlocks[blockName]) : new Set()
  };
  result[blockName].add(uniqueId);
  return result;
}

/**
 * A React context provider for use with the `useHasRecursion` hook to prevent recursive
 * renders.
 *
 * Wrap block content with this provider and provide the same `uniqueId` prop as used
 * with `useHasRecursion`.
 *
 * @param {Object}      props
 * @param {*}           props.uniqueId  Any value that acts as a unique identifier for a block instance.
 * @param {string}      props.blockName Optional block name.
 * @param {JSX.Element} props.children  React children.
 *
 * @return {JSX.Element} A React element.
 */
function RecursionProvider({
  children,
  uniqueId,
  blockName = &#039;&#039;
}) {
  const previouslyRenderedBlocks = (0,external_wp_element_namespaceObject.useContext)(RenderedRefsContext);
  const {
    name
  } = useBlockEditContext();
  blockName = blockName || name;
  const newRenderedBlocks = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; addToBlockType(previouslyRenderedBlocks, blockName, uniqueId), [previouslyRenderedBlocks, blockName, uniqueId]);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(RenderedRefsContext.Provider, {
    value: newRenderedBlocks,
    children: children
  });
}

/**
 * A React hook for keeping track of blocks previously rendered up in the block
 * tree. Blocks susceptible to recursion can use this hook in their `Edit`
 * function to prevent said recursion.
 *
 * Use this with the `RecursionProvider` component, using the same `uniqueId` value
 * for both the hook and the provider.
 *
 * @param {*}      uniqueId  Any value that acts as a unique identifier for a block instance.
 * @param {string} blockName Optional block name.
 *
 * @return {boolean} A boolean describing whether the provided id has already been rendered.
 */
function useHasRecursion(uniqueId, blockName = &#039;&#039;) {
  const previouslyRenderedBlocks = (0,external_wp_element_namespaceObject.useContext)(RenderedRefsContext);
  const {
    name
  } = useBlockEditContext();
  blockName = blockName || name;
  return Boolean(previouslyRenderedBlocks[blockName]?.has(uniqueId));
}
const DeprecatedExperimentalRecursionProvider = props =&gt; {
  external_wp_deprecated_default()(&#039;wp.blockEditor.__experimentalRecursionProvider&#039;, {
    since: &#039;6.5&#039;,
    alternative: &#039;wp.blockEditor.RecursionProvider&#039;
  });
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(RecursionProvider, {
    ...props
  });
};
const DeprecatedExperimentalUseHasRecursion = (...args) =&gt; {
  external_wp_deprecated_default()(&#039;wp.blockEditor.__experimentalUseHasRecursion&#039;, {
    since: &#039;6.5&#039;,
    alternative: &#039;wp.blockEditor.useHasRecursion&#039;
  });
  return useHasRecursion(...args);
};

;// ./node_modules/@wordpress/block-editor/build-module/components/inspector-popover-header/index.js
/**
 * WordPress dependencies
 */




function InspectorPopoverHeader({
  title,
  help,
  actions = [],
  onClose
}) {
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalVStack, {
    className: &quot;block-editor-inspector-popover-header&quot;,
    spacing: 4,
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalHStack, {
      alignment: &quot;center&quot;,
      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalHeading, {
        className: &quot;block-editor-inspector-popover-header__heading&quot;,
        level: 2,
        size: 13,
        children: title
      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalSpacer, {}), actions.map(({
        label,
        icon,
        onClick
      }) =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
        size: &quot;small&quot;,
        className: &quot;block-editor-inspector-popover-header__action&quot;,
        label: label,
        icon: icon,
        variant: !icon &amp;&amp; &#039;tertiary&#039;,
        onClick: onClick,
        children: !icon &amp;&amp; label
      }, label)), onClose &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
        size: &quot;small&quot;,
        className: &quot;block-editor-inspector-popover-header__action&quot;,
        label: (0,external_wp_i18n_namespaceObject.__)(&#039;Close&#039;),
        icon: close_small,
        onClick: onClose
      })]
    }), help &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalText, {
      children: help
    })]
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/publish-date-time-picker/index.js
/**
 * WordPress dependencies
 */





/**
 * Internal dependencies
 */


function PublishDateTimePicker({
  onClose,
  onChange,
  showPopoverHeaderActions,
  isCompact,
  currentDate,
  ...additionalProps
}, ref) {
  const datePickerProps = {
    startOfWeek: (0,external_wp_date_namespaceObject.getSettings)().l10n.startOfWeek,
    onChange,
    currentDate: isCompact ? undefined : currentDate,
    currentTime: isCompact ? currentDate : undefined,
    ...additionalProps
  };
  const DatePickerComponent = isCompact ? external_wp_components_namespaceObject.TimePicker : external_wp_components_namespaceObject.DateTimePicker;
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;div&quot;, {
    ref: ref,
    className: &quot;block-editor-publish-date-time-picker&quot;,
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(InspectorPopoverHeader, {
      title: (0,external_wp_i18n_namespaceObject.__)(&#039;Publish&#039;),
      actions: showPopoverHeaderActions ? [{
        label: (0,external_wp_i18n_namespaceObject.__)(&#039;Now&#039;),
        onClick: () =&gt; onChange?.(null)
      }] : undefined,
      onClose: onClose
    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(DatePickerComponent, {
      ...datePickerProps
    })]
  });
}
const PrivatePublishDateTimePicker = (0,external_wp_element_namespaceObject.forwardRef)(PublishDateTimePicker);
function PublicPublishDateTimePicker(props, ref) {
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PrivatePublishDateTimePicker, {
    ...props,
    showPopoverHeaderActions: true,
    isCompact: false,
    ref: ref
  });
}
/* harmony default export */ const publish_date_time_picker = ((0,external_wp_element_namespaceObject.forwardRef)(PublicPublishDateTimePicker));

;// ./node_modules/@wordpress/block-editor/build-module/components/index.js
/*
 * Block Creation Components
 */






































































/*
 * Content Related Components
 */








































/*
 * State Related Components
 */





;// ./node_modules/@wordpress/block-editor/build-module/elements/index.js
const elements_ELEMENT_CLASS_NAMES = {
  button: &#039;wp-element-button&#039;,
  caption: &#039;wp-element-caption&#039;
};
const __experimentalGetElementClassName = element =&gt; {
  return elements_ELEMENT_CLASS_NAMES[element] ? elements_ELEMENT_CLASS_NAMES[element] : &#039;&#039;;
};

;// ./node_modules/@wordpress/block-editor/build-module/utils/get-px-from-css-unit.js
/**
 * This function was accidentally exposed for mobile/native usage.
 *
 * @deprecated
 *
 * @return {string} Empty string.
 */
/* harmony default export */ const get_px_from_css_unit = (() =&gt; &#039;&#039;);

;// ./node_modules/@wordpress/block-editor/build-module/utils/index.js




;// ./node_modules/@wordpress/block-editor/build-module/components/global-styles/image-settings-panel.js
/**
 * WordPress dependencies
 */



/**
 * Internal dependencies
 */


function useHasImageSettingsPanel(name, value, inheritedValue) {
  // Note: If lightbox `value` exists, that means it was
  // defined via the the Global Styles UI and will NOT
  // be a boolean value or contain the `allowEditing` property,
  // so we should show the settings panel in those cases.
  return name === &#039;core/image&#039; &amp;&amp; inheritedValue?.lightbox?.allowEditing || !!value?.lightbox;
}
function ImageSettingsPanel({
  onChange,
  value,
  inheritedValue,
  panelId
}) {
  const dropdownMenuProps = useToolsPanelDropdownMenuProps();
  const resetLightbox = () =&gt; {
    onChange(undefined);
  };
  const onChangeLightbox = newSetting =&gt; {
    onChange({
      enabled: newSetting
    });
  };
  let lightboxChecked = false;
  if (inheritedValue?.lightbox?.enabled) {
    lightboxChecked = inheritedValue.lightbox.enabled;
  }
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_ReactJSXRuntime_namespaceObject.Fragment, {
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanel, {
      label: (0,external_wp_i18n_namespaceObject._x)(&#039;Settings&#039;, &#039;Image settings&#039;),
      resetAll: resetLightbox,
      panelId: panelId,
      dropdownMenuProps: dropdownMenuProps,
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanelItem
      // We use the `userSettings` prop instead of `settings`, because `settings`
      // contains the core/theme values for the lightbox and we want to show the
      // &quot;RESET&quot; button ONLY when the user has explicitly set a value in the
      // Global Styles.
      , {
        hasValue: () =&gt; !!value?.lightbox,
        label: (0,external_wp_i18n_namespaceObject.__)(&#039;Enlarge on click&#039;),
        onDeselect: resetLightbox,
        isShownByDefault: true,
        panelId: panelId,
        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToggleControl, {
          __nextHasNoMarginBottom: true,
          label: (0,external_wp_i18n_namespaceObject.__)(&#039;Enlarge on click&#039;),
          checked: lightboxChecked,
          onChange: onChangeLightbox
        })
      })
    })
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/global-styles/advanced-panel.js
/**
 * WordPress dependencies
 */




/**
 * Internal dependencies
 */


function AdvancedPanel({
  value,
  onChange,
  inheritedValue = value
}) {
  // Custom CSS
  const [cssError, setCSSError] = (0,external_wp_element_namespaceObject.useState)(null);
  const customCSS = inheritedValue?.css;
  function handleOnChange(newValue) {
    onChange({
      ...value,
      css: newValue
    });
    if (cssError) {
      // Check if the new value is valid CSS, and pass a wrapping selector
      // to ensure that `transformStyles` validates the CSS. Note that the
      // wrapping selector here is not used in the actual output of any styles.
      const [transformed] = transform_styles([{
        css: newValue
      }], &#039;.for-validation-only&#039;);
      if (transformed) {
        setCSSError(null);
      }
    }
  }
  function handleOnBlur(event) {
    if (!event?.target?.value) {
      setCSSError(null);
      return;
    }

    // Check if the new value is valid CSS, and pass a wrapping selector
    // to ensure that `transformStyles` validates the CSS. Note that the
    // wrapping selector here is not used in the actual output of any styles.
    const [transformed] = transform_styles([{
      css: event.target.value
    }], &#039;.for-validation-only&#039;);
    setCSSError(transformed === null ? (0,external_wp_i18n_namespaceObject.__)(&#039;There is an error with your CSS structure.&#039;) : null);
  }
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalVStack, {
    spacing: 3,
    children: [cssError &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Notice, {
      status: &quot;error&quot;,
      onRemove: () =&gt; setCSSError(null),
      children: cssError
    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.TextareaControl, {
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Additional CSS&#039;),
      __nextHasNoMarginBottom: true,
      value: customCSS,
      onChange: newValue =&gt; handleOnChange(newValue),
      onBlur: handleOnBlur,
      className: &quot;block-editor-global-styles-advanced-panel__custom-css-input&quot;,
      spellCheck: false
    })]
  });
}

;// ./node_modules/memize/dist/index.js
/**
 * Memize options object.
 *
 * @typedef MemizeOptions
 *
 * @property {number} [maxSize] Maximum size of the cache.
 */

/**
 * Internal cache entry.
 *
 * @typedef MemizeCacheNode
 *
 * @property {?MemizeCacheNode|undefined} [prev] Previous node.
 * @property {?MemizeCacheNode|undefined} [next] Next node.
 * @property {Array&lt;*&gt;}                   args   Function arguments for cache
 *                                               entry.
 * @property {*}                          val    Function result.
 */

/**
 * Properties of the enhanced function for controlling cache.
 *
 * @typedef MemizeMemoizedFunction
 *
 * @property {()=&gt;void} clear Clear the cache.
 */

/**
 * Accepts a function to be memoized, and returns a new memoized function, with
 * optional options.
 *
 * @template {(...args: any[]) =&gt; any} F
 *
 * @param {F}             fn        Function to memoize.
 * @param {MemizeOptions} [options] Options object.
 *
 * @return {((...args: Parameters&lt;F&gt;) =&gt; ReturnType&lt;F&gt;) &amp; MemizeMemoizedFunction} Memoized function.
 */
function memize(fn, options) {
	var size = 0;

	/** @type {?MemizeCacheNode|undefined} */
	var head;

	/** @type {?MemizeCacheNode|undefined} */
	var tail;

	options = options || {};

	function memoized(/* ...args */) {
		var node = head,
			len = arguments.length,
			args,
			i;

		searchCache: while (node) {
			// Perform a shallow equality test to confirm that whether the node
			// under test is a candidate for the arguments passed. Two arrays
			// are shallowly equal if their length matches and each entry is
			// strictly equal between the two sets. Avoid abstracting to a
			// function which could incur an arguments leaking deoptimization.

			// Check whether node arguments match arguments length
			if (node.args.length !== arguments.length) {
				node = node.next;
				continue;
			}

			// Check whether node arguments match arguments values
			for (i = 0; i &lt; len; i++) {
				if (node.args[i] !== arguments[i]) {
					node = node.next;
					continue searchCache;
				}
			}

			// At this point we can assume we&#039;ve found a match

			// Surface matched node to head if not already
			if (node !== head) {
				// As tail, shift to previous. Must only shift if not also
				// head, since if both head and tail, there is no previous.
				if (node === tail) {
					tail = node.prev;
				}

				// Adjust siblings to point to each other. If node was tail,
				// this also handles new tail&#039;s empty `next` assignment.
				/** @type {MemizeCacheNode} */ (node.prev).next = node.next;
				if (node.next) {
					node.next.prev = node.prev;
				}

				node.next = head;
				node.prev = null;
				/** @type {MemizeCacheNode} */ (head).prev = node;
				head = node;
			}

			// Return immediately
			return node.val;
		}

		// No cached value found. Continue to insertion phase:

		// Create a copy of arguments (avoid leaking deoptimization)
		args = new Array(len);
		for (i = 0; i &lt; len; i++) {
			args[i] = arguments[i];
		}

		node = {
			args: args,

			// Generate the result from original function
			val: fn.apply(null, args),
		};

		// Don&#039;t need to check whether node is already head, since it would
		// have been returned above already if it was

		// Shift existing head down list
		if (head) {
			head.prev = node;
			node.next = head;
		} else {
			// If no head, follows that there&#039;s no tail (at initial or reset)
			tail = node;
		}

		// Trim tail if we&#039;re reached max size and are pending cache insertion
		if (size === /** @type {MemizeOptions} */ (options).maxSize) {
			tail = /** @type {MemizeCacheNode} */ (tail).prev;
			/** @type {MemizeCacheNode} */ (tail).next = null;
		} else {
			size++;
		}

		head = node;

		return node.val;
	}

	memoized.clear = function () {
		head = null;
		tail = null;
		size = 0;
	};

	// Ignore reason: There&#039;s not a clear solution to create an intersection of
	// the function with additional properties, where the goal is to retain the
	// function signature of the incoming argument and add control properties
	// on the return value.

	// @ts-ignore
	return memoized;
}



;// ./node_modules/@wordpress/block-editor/build-module/components/global-styles/get-global-styles-changes.js
/**
 * External dependencies
 */


/**
 * WordPress dependencies
 */


const globalStylesChangesCache = new Map();
const get_global_styles_changes_EMPTY_ARRAY = [];
const translationMap = {
  caption: (0,external_wp_i18n_namespaceObject.__)(&#039;Caption&#039;),
  link: (0,external_wp_i18n_namespaceObject.__)(&#039;Link&#039;),
  button: (0,external_wp_i18n_namespaceObject.__)(&#039;Button&#039;),
  heading: (0,external_wp_i18n_namespaceObject.__)(&#039;Heading&#039;),
  h1: (0,external_wp_i18n_namespaceObject.__)(&#039;H1&#039;),
  h2: (0,external_wp_i18n_namespaceObject.__)(&#039;H2&#039;),
  h3: (0,external_wp_i18n_namespaceObject.__)(&#039;H3&#039;),
  h4: (0,external_wp_i18n_namespaceObject.__)(&#039;H4&#039;),
  h5: (0,external_wp_i18n_namespaceObject.__)(&#039;H5&#039;),
  h6: (0,external_wp_i18n_namespaceObject.__)(&#039;H6&#039;),
  &#039;settings.color&#039;: (0,external_wp_i18n_namespaceObject.__)(&#039;Color&#039;),
  &#039;settings.typography&#039;: (0,external_wp_i18n_namespaceObject.__)(&#039;Typography&#039;),
  &#039;styles.color&#039;: (0,external_wp_i18n_namespaceObject.__)(&#039;Colors&#039;),
  &#039;styles.spacing&#039;: (0,external_wp_i18n_namespaceObject.__)(&#039;Spacing&#039;),
  &#039;styles.background&#039;: (0,external_wp_i18n_namespaceObject.__)(&#039;Background&#039;),
  &#039;styles.typography&#039;: (0,external_wp_i18n_namespaceObject.__)(&#039;Typography&#039;)
};
const getBlockNames = memize(() =&gt; (0,external_wp_blocks_namespaceObject.getBlockTypes)().reduce((accumulator, {
  name,
  title
}) =&gt; {
  accumulator[name] = title;
  return accumulator;
}, {}));
const isObject = obj =&gt; obj !== null &amp;&amp; typeof obj === &#039;object&#039;;

/**
 * Get the translation for a given global styles key.
 * @param {string} key A key representing a path to a global style property or setting.
 * @return {string|undefined}                A translated key or undefined if no translation exists.
 */
function getTranslation(key) {
  if (translationMap[key]) {
    return translationMap[key];
  }
  const keyArray = key.split(&#039;.&#039;);
  if (keyArray?.[0] === &#039;blocks&#039;) {
    const blockName = getBlockNames()?.[keyArray[1]];
    return blockName || keyArray[1];
  }
  if (keyArray?.[0] === &#039;elements&#039;) {
    return translationMap[keyArray[1]] || keyArray[1];
  }
  return undefined;
}

/**
 * A deep comparison of two objects, optimized for comparing global styles.
 * @param {Object} changedObject  The changed object to compare.
 * @param {Object} originalObject The original object to compare against.
 * @param {string} parentPath     A key/value pair object of block names and their rendered titles.
 * @return {string[]}             An array of paths whose values have changed.
 */
function deepCompare(changedObject, originalObject, parentPath = &#039;&#039;) {
  // We have two non-object values to compare.
  if (!isObject(changedObject) &amp;&amp; !isObject(originalObject)) {
    /*
     * Only return a path if the value has changed.
     * And then only the path name up to 2 levels deep.
     */
    return changedObject !== originalObject ? parentPath.split(&#039;.&#039;).slice(0, 2).join(&#039;.&#039;) : undefined;
  }

  // Enable comparison when an object doesn&#039;t have a corresponding property to compare.
  changedObject = isObject(changedObject) ? changedObject : {};
  originalObject = isObject(originalObject) ? originalObject : {};
  const allKeys = new Set([...Object.keys(changedObject), ...Object.keys(originalObject)]);
  let diffs = [];
  for (const key of allKeys) {
    const path = parentPath ? parentPath + &#039;.&#039; + key : key;
    const changedPath = deepCompare(changedObject[key], originalObject[key], path);
    if (changedPath) {
      diffs = diffs.concat(changedPath);
    }
  }
  return diffs;
}

/**
 * Returns an array of translated summarized global styles changes.
 * Results are cached using a Map() key of `JSON.stringify( { next, previous } )`.
 *
 * @param {Object} next     The changed object to compare.
 * @param {Object} previous The original object to compare against.
 * @return {Array[]}        A 2-dimensional array of tuples: [ &quot;group&quot;, &quot;translated change&quot; ].
 */
function getGlobalStylesChangelist(next, previous) {
  const cacheKey = JSON.stringify({
    next,
    previous
  });
  if (globalStylesChangesCache.has(cacheKey)) {
    return globalStylesChangesCache.get(cacheKey);
  }

  /*
   * Compare the two changesets with normalized keys.
   * The order of these keys determines the order in which
   * they&#039;ll appear in the results.
   */
  const changedValueTree = deepCompare({
    styles: {
      background: next?.styles?.background,
      color: next?.styles?.color,
      typography: next?.styles?.typography,
      spacing: next?.styles?.spacing
    },
    blocks: next?.styles?.blocks,
    elements: next?.styles?.elements,
    settings: next?.settings
  }, {
    styles: {
      background: previous?.styles?.background,
      color: previous?.styles?.color,
      typography: previous?.styles?.typography,
      spacing: previous?.styles?.spacing
    },
    blocks: previous?.styles?.blocks,
    elements: previous?.styles?.elements,
    settings: previous?.settings
  });
  if (!changedValueTree.length) {
    globalStylesChangesCache.set(cacheKey, get_global_styles_changes_EMPTY_ARRAY);
    return get_global_styles_changes_EMPTY_ARRAY;
  }

  // Remove duplicate results.
  const result = [...new Set(changedValueTree)]
  /*
   * Translate the keys.
   * Remove empty translations.
   */.reduce((acc, curr) =&gt; {
    const translation = getTranslation(curr);
    if (translation) {
      acc.push([curr.split(&#039;.&#039;)[0], translation]);
    }
    return acc;
  }, []);
  globalStylesChangesCache.set(cacheKey, result);
  return result;
}

/**
 * From a getGlobalStylesChangelist() result, returns an array of translated global styles changes, grouped by type.
 * The types are &#039;blocks&#039;, &#039;elements&#039;, &#039;settings&#039;, and &#039;styles&#039;.
 *
 * @param {Object}              next     The changed object to compare.
 * @param {Object}              previous The original object to compare against.
 * @param {{maxResults:number}} options  Options. maxResults: results to return before truncating.
 * @return {string[]}                    An array of translated changes.
 */
function getGlobalStylesChanges(next, previous, options = {}) {
  let changeList = getGlobalStylesChangelist(next, previous);
  const changesLength = changeList.length;
  const {
    maxResults
  } = options;
  if (changesLength) {
    // Truncate to `n` results if necessary.
    if (!!maxResults &amp;&amp; changesLength &gt; maxResults) {
      changeList = changeList.slice(0, maxResults);
    }
    return Object.entries(changeList.reduce((acc, curr) =&gt; {
      const group = acc[curr[0]] || [];
      if (!group.includes(curr[1])) {
        acc[curr[0]] = [...group, curr[1]];
      }
      return acc;
    }, {})).map(([key, changeValues]) =&gt; {
      const changeValuesLength = changeValues.length;
      const joinedChangesValue = changeValues.join(/* translators: Used between list items, there is a space after the comma. */
      (0,external_wp_i18n_namespaceObject.__)(&#039;, &#039;) // eslint-disable-line @wordpress/i18n-no-flanking-whitespace
      );
      switch (key) {
        case &#039;blocks&#039;:
          {
            return (0,external_wp_i18n_namespaceObject.sprintf)(
            // translators: %s: a list of block names separated by a comma.
            (0,external_wp_i18n_namespaceObject._n)(&#039;%s block.&#039;, &#039;%s blocks.&#039;, changeValuesLength), joinedChangesValue);
          }
        case &#039;elements&#039;:
          {
            return (0,external_wp_i18n_namespaceObject.sprintf)(
            // translators: %s: a list of element names separated by a comma.
            (0,external_wp_i18n_namespaceObject._n)(&#039;%s element.&#039;, &#039;%s elements.&#039;, changeValuesLength), joinedChangesValue);
          }
        case &#039;settings&#039;:
          {
            return (0,external_wp_i18n_namespaceObject.sprintf)(
            // translators: %s: a list of theme.json setting labels separated by a comma.
            (0,external_wp_i18n_namespaceObject.__)(&#039;%s settings.&#039;), joinedChangesValue);
          }
        case &#039;styles&#039;:
          {
            return (0,external_wp_i18n_namespaceObject.sprintf)(
            // translators: %s: a list of theme.json top-level styles labels separated by a comma.
            (0,external_wp_i18n_namespaceObject.__)(&#039;%s styles.&#039;), joinedChangesValue);
          }
        default:
          {
            return (0,external_wp_i18n_namespaceObject.sprintf)(
            // translators: %s: a list of global styles changes separated by a comma.
            (0,external_wp_i18n_namespaceObject.__)(&#039;%s.&#039;), joinedChangesValue);
          }
      }
    });
  }
  return get_global_styles_changes_EMPTY_ARRAY;
}

;// ./node_modules/@wordpress/block-editor/build-module/components/global-styles/index.js















;// ./node_modules/@wordpress/block-editor/build-module/components/rich-text/get-rich-text-values.js
/**
 * WordPress dependencies
 */




/**
 * Internal dependencies
 */



/*
 * This function is similar to `@wordpress/element`&#039;s `renderToString` function,
 * except that it does not render the elements to a string, but instead collects
 * the values of all rich text `Content` elements.
 */

function addValuesForElement(element, values, innerBlocks) {
  if (null === element || undefined === element || false === element) {
    return;
  }
  if (Array.isArray(element)) {
    return addValuesForElements(element, values, innerBlocks);
  }
  switch (typeof element) {
    case &#039;string&#039;:
    case &#039;number&#039;:
      return;
  }
  const {
    type,
    props
  } = element;
  switch (type) {
    case external_wp_element_namespaceObject.StrictMode:
    case external_wp_element_namespaceObject.Fragment:
      return addValuesForElements(props.children, values, innerBlocks);
    case external_wp_element_namespaceObject.RawHTML:
      return;
    case inner_blocks.Content:
      return addValuesForBlocks(values, innerBlocks);
    case Content:
      values.push(props.value);
      return;
  }
  switch (typeof type) {
    case &#039;string&#039;:
      if (typeof props.children !== &#039;undefined&#039;) {
        return addValuesForElements(props.children, values, innerBlocks);
      }
      return;
    case &#039;function&#039;:
      const el = type.prototype &amp;&amp; typeof type.prototype.render === &#039;function&#039; ? new type(props).render() : type(props);
      return addValuesForElement(el, values, innerBlocks);
  }
}
function addValuesForElements(children, ...args) {
  children = Array.isArray(children) ? children : [children];
  for (let i = 0; i &lt; children.length; i++) {
    addValuesForElement(children[i], ...args);
  }
}
function addValuesForBlocks(values, blocks) {
  for (let i = 0; i &lt; blocks.length; i++) {
    const {
      name,
      attributes,
      innerBlocks
    } = blocks[i];
    const saveElement = (0,external_wp_blocks_namespaceObject.getSaveElement)(name, attributes,
    /*#__PURE__*/
    // Instead of letting save elements use `useInnerBlocksProps.save`,
    // force them to use InnerBlocks.Content instead so we can intercept
    // a single component.
    (0,external_ReactJSXRuntime_namespaceObject.jsx)(inner_blocks.Content, {}));
    addValuesForElement(saveElement, values, innerBlocks);
  }
}
function getRichTextValues(blocks = []) {
  external_wp_blocks_namespaceObject.__unstableGetBlockProps.skipFilters = true;
  const values = [];
  addValuesForBlocks(values, blocks);
  external_wp_blocks_namespaceObject.__unstableGetBlockProps.skipFilters = false;
  return values.map(value =&gt; value instanceof external_wp_richText_namespaceObject.RichTextData ? value : external_wp_richText_namespaceObject.RichTextData.fromHTMLString(value));
}

;// ./node_modules/@wordpress/block-editor/build-module/components/resizable-box-popover/index.js
/**
 * WordPress dependencies
 */


/**
 * Internal dependencies
 */


function ResizableBoxPopover({
  clientId,
  resizableBoxProps,
  ...props
}) {
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(cover, {
    clientId: clientId,
    __unstablePopoverSlot: &quot;block-toolbar&quot;,
    ...props,
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ResizableBox, {
      ...resizableBoxProps
    })
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/block-manager/checklist.js
/**
 * WordPress dependencies
 */


/**
 * Internal dependencies
 */


function BlockTypesChecklist({
  blockTypes,
  value,
  onItemChange
}) {
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;ul&quot;, {
    className: &quot;block-editor-block-manager__checklist&quot;,
    children: blockTypes.map(blockType =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;li&quot;, {
      className: &quot;block-editor-block-manager__checklist-item&quot;,
      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.CheckboxControl, {
        __nextHasNoMarginBottom: true,
        label: blockType.title,
        checked: value.includes(blockType.name),
        onChange: (...args) =&gt; onItemChange(blockType, ...args)
      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_icon, {
        icon: blockType.icon
      })]
    }, blockType.name))
  });
}
/* harmony default export */ const checklist = (BlockTypesChecklist);

;// ./node_modules/@wordpress/block-editor/build-module/components/block-manager/category.js
/**
 * WordPress dependencies
 */




/**
 * Internal dependencies
 */


function BlockManagerCategory({
  title,
  blockTypes,
  selectedBlockTypes,
  onChange
}) {
  const instanceId = (0,external_wp_compose_namespaceObject.useInstanceId)(BlockManagerCategory);
  const toggleVisible = (0,external_wp_element_namespaceObject.useCallback)((blockType, nextIsChecked) =&gt; {
    if (nextIsChecked) {
      onChange([...selectedBlockTypes, blockType]);
    } else {
      onChange(selectedBlockTypes.filter(({
        name
      }) =&gt; name !== blockType.name));
    }
  }, [selectedBlockTypes, onChange]);
  const toggleAllVisible = (0,external_wp_element_namespaceObject.useCallback)(nextIsChecked =&gt; {
    if (nextIsChecked) {
      onChange([...selectedBlockTypes, ...blockTypes.filter(blockType =&gt; !selectedBlockTypes.find(({
        name
      }) =&gt; name === blockType.name))]);
    } else {
      onChange(selectedBlockTypes.filter(selectedBlockType =&gt; !blockTypes.find(({
        name
      }) =&gt; name === selectedBlockType.name)));
    }
  }, [blockTypes, selectedBlockTypes, onChange]);
  if (!blockTypes.length) {
    return null;
  }
  const checkedBlockNames = blockTypes.map(({
    name
  }) =&gt; name).filter(type =&gt; (selectedBlockTypes !== null &amp;&amp; selectedBlockTypes !== void 0 ? selectedBlockTypes : []).some(selectedBlockType =&gt; selectedBlockType.name === type));
  const titleId = &#039;block-editor-block-manager__category-title-&#039; + instanceId;
  const isAllChecked = checkedBlockNames.length === blockTypes.length;
  const isIndeterminate = !isAllChecked &amp;&amp; checkedBlockNames.length &gt; 0;
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;div&quot;, {
    role: &quot;group&quot;,
    &quot;aria-labelledby&quot;: titleId,
    className: &quot;block-editor-block-manager__category&quot;,
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.CheckboxControl, {
      __nextHasNoMarginBottom: true,
      checked: isAllChecked,
      onChange: toggleAllVisible,
      className: &quot;block-editor-block-manager__category-title&quot;,
      indeterminate: isIndeterminate,
      label: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;span&quot;, {
        id: titleId,
        children: title
      })
    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(checklist, {
      blockTypes: blockTypes,
      value: checkedBlockNames,
      onItemChange: toggleVisible
    })]
  });
}
/* harmony default export */ const block_manager_category = (BlockManagerCategory);

;// ./node_modules/@wordpress/block-editor/build-module/components/block-manager/index.js
/**
 * WordPress dependencies
 */








/**
 * Internal dependencies
 */


/**
 * Provides a list of blocks with checkboxes.
 *
 * @param {Object}   props                    Props.
 * @param {Array}    props.blockTypes         An array of blocks.
 * @param {Array}    props.selectedBlockTypes An array of selected blocks.
 * @param {Function} props.onChange           Function to be called when the selected blocks change.
 */

function BlockManager({
  blockTypes,
  selectedBlockTypes,
  onChange
}) {
  const debouncedSpeak = (0,external_wp_compose_namespaceObject.useDebounce)(external_wp_a11y_namespaceObject.speak, 500);
  const [search, setSearch] = (0,external_wp_element_namespaceObject.useState)(&#039;&#039;);
  const {
    categories,
    isMatchingSearchTerm
  } = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    return {
      categories: select(external_wp_blocks_namespaceObject.store).getCategories(),
      isMatchingSearchTerm: select(external_wp_blocks_namespaceObject.store).isMatchingSearchTerm
    };
  }, []);
  function enableAllBlockTypes() {
    onChange(blockTypes);
  }
  const filteredBlockTypes = blockTypes.filter(blockType =&gt; {
    return !search || isMatchingSearchTerm(blockType, search);
  });
  const numberOfHiddenBlocks = blockTypes.length - selectedBlockTypes.length;

  // Announce search results on change
  (0,external_wp_element_namespaceObject.useEffect)(() =&gt; {
    if (!search) {
      return;
    }
    const count = filteredBlockTypes.length;
    const resultsFoundMessage = (0,external_wp_i18n_namespaceObject.sprintf)(/* translators: %d: number of results. */
    (0,external_wp_i18n_namespaceObject._n)(&#039;%d result found.&#039;, &#039;%d results found.&#039;, count), count);
    debouncedSpeak(resultsFoundMessage);
  }, [filteredBlockTypes?.length, search, debouncedSpeak]);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;div&quot;, {
    className: &quot;block-editor-block-manager__content&quot;,
    children: [!!numberOfHiddenBlocks &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;div&quot;, {
      className: &quot;block-editor-block-manager__disabled-blocks-count&quot;,
      children: [(0,external_wp_i18n_namespaceObject.sprintf)(/* translators: %d: number of blocks. */
      (0,external_wp_i18n_namespaceObject._n)(&#039;%d block is hidden.&#039;, &#039;%d blocks are hidden.&#039;, numberOfHiddenBlocks), numberOfHiddenBlocks), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
        __next40pxDefaultSize: true,
        variant: &quot;link&quot;,
        onClick: enableAllBlockTypes,
        children: (0,external_wp_i18n_namespaceObject.__)(&#039;Reset&#039;)
      })]
    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.SearchControl, {
      __nextHasNoMarginBottom: true,
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Search for a block&#039;),
      placeholder: (0,external_wp_i18n_namespaceObject.__)(&#039;Search for a block&#039;),
      value: search,
      onChange: nextSearch =&gt; setSearch(nextSearch),
      className: &quot;block-editor-block-manager__search&quot;
    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;div&quot;, {
      tabIndex: &quot;0&quot;,
      role: &quot;region&quot;,
      &quot;aria-label&quot;: (0,external_wp_i18n_namespaceObject.__)(&#039;Available block types&#039;),
      className: &quot;block-editor-block-manager__results&quot;,
      children: [filteredBlockTypes.length === 0 &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;p&quot;, {
        className: &quot;block-editor-block-manager__no-results&quot;,
        children: (0,external_wp_i18n_namespaceObject.__)(&#039;No blocks found.&#039;)
      }), categories.map(category =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_manager_category, {
        title: category.title,
        blockTypes: filteredBlockTypes.filter(blockType =&gt; blockType.category === category.slug),
        selectedBlockTypes: selectedBlockTypes,
        onChange: onChange
      }, category.slug)), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(block_manager_category, {
        title: (0,external_wp_i18n_namespaceObject.__)(&#039;Uncategorized&#039;),
        blockTypes: filteredBlockTypes.filter(({
          category
        }) =&gt; !category),
        selectedBlockTypes: selectedBlockTypes,
        onChange: onChange
      })]
    })]
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/block-removal-warning-modal/index.js
/**
 * WordPress dependencies
 */





/**
 * Internal dependencies
 */



function BlockRemovalWarningModal({
  rules
}) {
  const {
    clientIds,
    selectPrevious,
    message
  } = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; unlock(select(store)).getRemovalPromptData());
  const {
    clearBlockRemovalPrompt,
    setBlockRemovalRules,
    privateRemoveBlocks
  } = unlock((0,external_wp_data_namespaceObject.useDispatch)(store));

  // Load block removal rules, simultaneously signalling that the block
  // removal prompt is in place.
  (0,external_wp_element_namespaceObject.useEffect)(() =&gt; {
    setBlockRemovalRules(rules);
    return () =&gt; {
      setBlockRemovalRules();
    };
  }, [rules, setBlockRemovalRules]);
  if (!message) {
    return;
  }
  const onConfirmRemoval = () =&gt; {
    privateRemoveBlocks(clientIds, selectPrevious, /* force */true);
    clearBlockRemovalPrompt();
  };
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.Modal, {
    title: (0,external_wp_i18n_namespaceObject.__)(&#039;Be careful!&#039;),
    onRequestClose: clearBlockRemovalPrompt,
    size: &quot;medium&quot;,
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;p&quot;, {
      children: message
    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalHStack, {
      justify: &quot;right&quot;,
      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
        variant: &quot;tertiary&quot;,
        onClick: clearBlockRemovalPrompt,
        __next40pxDefaultSize: true,
        children: (0,external_wp_i18n_namespaceObject.__)(&#039;Cancel&#039;)
      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
        variant: &quot;primary&quot;,
        onClick: onConfirmRemoval,
        __next40pxDefaultSize: true,
        children: (0,external_wp_i18n_namespaceObject.__)(&#039;Delete&#039;)
      })]
    })]
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/dimensions-tool/scale-tool.js
/**
 * WordPress dependencies
 */




/**
 * @typedef {import(&#039;@wordpress/components/build-types/select-control/types&#039;).SelectControlProps} SelectControlProps
 */

/**
 * The descriptions are purposely made generic as object-fit could be used for
 * any replaced element. Provide your own set of options if you need different
 * help text or labels.
 *
 * @see https://developer.mozilla.org/en-US/docs/Web/CSS/Replaced_element
 *
 * @type {SelectControlProps[]}
 */

const DEFAULT_SCALE_OPTIONS = [{
  value: &#039;fill&#039;,
  label: (0,external_wp_i18n_namespaceObject._x)(&#039;Fill&#039;, &#039;Scale option for dimensions control&#039;),
  help: (0,external_wp_i18n_namespaceObject.__)(&#039;Fill the space by stretching the content.&#039;)
}, {
  value: &#039;contain&#039;,
  label: (0,external_wp_i18n_namespaceObject._x)(&#039;Contain&#039;, &#039;Scale option for dimensions control&#039;),
  help: (0,external_wp_i18n_namespaceObject.__)(&#039;Fit the content to the space without clipping.&#039;)
}, {
  value: &#039;cover&#039;,
  label: (0,external_wp_i18n_namespaceObject._x)(&#039;Cover&#039;, &#039;Scale option for dimensions control&#039;),
  help: (0,external_wp_i18n_namespaceObject.__)(&quot;Fill the space by clipping what doesn&#039;t fit.&quot;)
}, {
  value: &#039;none&#039;,
  label: (0,external_wp_i18n_namespaceObject._x)(&#039;None&#039;, &#039;Scale option for dimensions control&#039;),
  help: (0,external_wp_i18n_namespaceObject.__)(&#039;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.&#039;)
}, {
  value: &#039;scale-down&#039;,
  label: (0,external_wp_i18n_namespaceObject._x)(&#039;Scale down&#039;, &#039;Scale option for dimensions control&#039;),
  help: (0,external_wp_i18n_namespaceObject.__)(&#039;Scale down the content to fit the space if it is too big. Content that is too small will have additional padding.&#039;)
}];

/**
 * @callback ScaleToolPropsOnChange
 * @param {string} nextValue New scale value.
 * @return {void}
 */

/**
 * @typedef {Object} ScaleToolProps
 * @property {string}                 [panelId]               ID of the panel that contains the controls.
 * @property {string}                 [value]                 Current scale value.
 * @property {ScaleToolPropsOnChange} [onChange]              Callback to update the scale value.
 * @property {SelectControlProps[]}   [options]               Scale options.
 * @property {string}                 [defaultValue]          Default scale value.
 * @property {boolean}                [showControl=true]      Whether to show the control.
 * @property {boolean}                [isShownByDefault=true] Whether the tool panel is shown by default.
 */

/**
 * A tool to select the CSS object-fit property for the image.
 *
 * @param {ScaleToolProps} props
 *
 * @return {import(&#039;react&#039;).ReactElement} The scale tool.
 */
function ScaleTool({
  panelId,
  value,
  onChange,
  options = DEFAULT_SCALE_OPTIONS,
  defaultValue = DEFAULT_SCALE_OPTIONS[0].value,
  isShownByDefault = true
}) {
  // Match the CSS default so if the value is used directly in CSS it will look correct in the control.
  const displayValue = value !== null &amp;&amp; value !== void 0 ? value : &#039;fill&#039;;
  const scaleHelp = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; {
    return options.reduce((acc, option) =&gt; {
      acc[option.value] = option.help;
      return acc;
    }, {});
  }, [options]);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanelItem, {
    label: (0,external_wp_i18n_namespaceObject.__)(&#039;Scale&#039;),
    isShownByDefault: isShownByDefault,
    hasValue: () =&gt; displayValue !== defaultValue,
    onDeselect: () =&gt; onChange(defaultValue),
    panelId: panelId,
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControl, {
      __nextHasNoMarginBottom: true,
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Scale&#039;),
      isBlock: true,
      help: scaleHelp[displayValue],
      value: displayValue,
      onChange: onChange,
      size: &quot;__unstable-large&quot;,
      children: options.map(option =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToggleGroupControlOption, {
        ...option
      }, option.value))
    })
  });
}

;// ./node_modules/@babel/runtime/helpers/esm/extends.js
function extends_extends() {
  return extends_extends = Object.assign ? Object.assign.bind() : function (n) {
    for (var e = 1; e &lt; arguments.length; e++) {
      var t = arguments[e];
      for (var r in t) ({}).hasOwnProperty.call(t, r) &amp;&amp; (n[r] = t[r]);
    }
    return n;
  }, extends_extends.apply(null, arguments);
}

;// ./node_modules/@emotion/memoize/dist/emotion-memoize.esm.js
function memoize(fn) {
  var cache = Object.create(null);
  return function (arg) {
    if (cache[arg] === undefined) cache[arg] = fn(arg);
    return cache[arg];
  };
}



;// ./node_modules/@emotion/styled/node_modules/@emotion/is-prop-valid/dist/emotion-is-prop-valid.esm.js


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

var isPropValid = /* #__PURE__ */memoize(function (prop) {
  return reactPropsRegex.test(prop) || prop.charCodeAt(0) === 111
  /* o */
  &amp;&amp; prop.charCodeAt(1) === 110
  /* n */
  &amp;&amp; prop.charCodeAt(2) &lt; 91;
}
/* Z+1 */
);



;// ./node_modules/@emotion/sheet/dist/emotion-sheet.browser.esm.js
/*

Based off glamor&#039;s StyleSheet, thanks Sunil ❤️

high performance StyleSheet for css-in-js systems

- uses multiple style tags behind the scenes for millions of rules
- uses `insertRule` for appending in production for *much* faster performance

// usage

import { StyleSheet } from &#039;@emotion/sheet&#039;

let styleSheet = new StyleSheet({ key: &#039;&#039;, container: document.head })

styleSheet.insert(&#039;#box { border: 1px solid red; }&#039;)
- appends a css rule into the stylesheet

styleSheet.flush()
- empties the stylesheet of all its contents

*/
// $FlowFixMe
function sheetForTag(tag) {
  if (tag.sheet) {
    // $FlowFixMe
    return tag.sheet;
  } // this weirdness brought to you by firefox

  /* istanbul ignore next */


  for (var i = 0; i &lt; document.styleSheets.length; i++) {
    if (document.styleSheets[i].ownerNode === tag) {
      // $FlowFixMe
      return document.styleSheets[i];
    }
  }
}

function createStyleElement(options) {
  var tag = document.createElement(&#039;style&#039;);
  tag.setAttribute(&#039;data-emotion&#039;, options.key);

  if (options.nonce !== undefined) {
    tag.setAttribute(&#039;nonce&#039;, options.nonce);
  }

  tag.appendChild(document.createTextNode(&#039;&#039;));
  tag.setAttribute(&#039;data-s&#039;, &#039;&#039;);
  return tag;
}

var StyleSheet = /*#__PURE__*/function () {
  // Using Node instead of HTMLElement since container may be a ShadowRoot
  function StyleSheet(options) {
    var _this = this;

    this._insertTag = function (tag) {
      var before;

      if (_this.tags.length === 0) {
        if (_this.insertionPoint) {
          before = _this.insertionPoint.nextSibling;
        } else if (_this.prepend) {
          before = _this.container.firstChild;
        } else {
          before = _this.before;
        }
      } else {
        before = _this.tags[_this.tags.length - 1].nextSibling;
      }

      _this.container.insertBefore(tag, before);

      _this.tags.push(tag);
    };

    this.isSpeedy = options.speedy === undefined ? &quot;production&quot; === &#039;production&#039; : options.speedy;
    this.tags = [];
    this.ctr = 0;
    this.nonce = options.nonce; // key is the value of the data-emotion attribute, it&#039;s used to identify different sheets

    this.key = options.key;
    this.container = options.container;
    this.prepend = options.prepend;
    this.insertionPoint = options.insertionPoint;
    this.before = null;
  }

  var _proto = StyleSheet.prototype;

  _proto.hydrate = function hydrate(nodes) {
    nodes.forEach(this._insertTag);
  };

  _proto.insert = function insert(rule) {
    // the max length is how many rules we have per style tag, it&#039;s 65000 in speedy mode
    // it&#039;s 1 in dev because we insert source maps that map a single rule to a location
    // and you can only have one source map per style tag
    if (this.ctr % (this.isSpeedy ? 65000 : 1) === 0) {
      this._insertTag(createStyleElement(this));
    }

    var tag = this.tags[this.tags.length - 1];

    if (false) { var isImportRule; }

    if (this.isSpeedy) {
      var sheet = sheetForTag(tag);

      try {
        // this is the ultrafast version, works across browsers
        // the big drawback is that the css won&#039;t be editable in devtools
        sheet.insertRule(rule, sheet.cssRules.length);
      } catch (e) {
        if (false) {}
      }
    } else {
      tag.appendChild(document.createTextNode(rule));
    }

    this.ctr++;
  };

  _proto.flush = function flush() {
    // $FlowFixMe
    this.tags.forEach(function (tag) {
      return tag.parentNode &amp;&amp; tag.parentNode.removeChild(tag);
    });
    this.tags = [];
    this.ctr = 0;

    if (false) {}
  };

  return StyleSheet;
}();



;// ./node_modules/stylis/src/Utility.js
/**
 * @param {number}
 * @return {number}
 */
var abs = Math.abs

/**
 * @param {number}
 * @return {string}
 */
var Utility_from = String.fromCharCode

/**
 * @param {object}
 * @return {object}
 */
var Utility_assign = Object.assign

/**
 * @param {string} value
 * @param {number} length
 * @return {number}
 */
function hash (value, length) {
	return Utility_charat(value, 0) ^ 45 ? (((((((length &lt;&lt; 2) ^ Utility_charat(value, 0)) &lt;&lt; 2) ^ Utility_charat(value, 1)) &lt;&lt; 2) ^ Utility_charat(value, 2)) &lt;&lt; 2) ^ Utility_charat(value, 3) : 0
}

/**
 * @param {string} value
 * @return {string}
 */
function trim (value) {
	return value.trim()
}

/**
 * @param {string} value
 * @param {RegExp} pattern
 * @return {string?}
 */
function Utility_match (value, pattern) {
	return (value = pattern.exec(value)) ? value[0] : value
}

/**
 * @param {string} value
 * @param {(string|RegExp)} pattern
 * @param {string} replacement
 * @return {string}
 */
function Utility_replace (value, pattern, replacement) {
	return value.replace(pattern, replacement)
}

/**
 * @param {string} value
 * @param {string} search
 * @return {number}
 */
function indexof (value, search) {
	return value.indexOf(search)
}

/**
 * @param {string} value
 * @param {number} index
 * @return {number}
 */
function Utility_charat (value, index) {
	return value.charCodeAt(index) | 0
}

/**
 * @param {string} value
 * @param {number} begin
 * @param {number} end
 * @return {string}
 */
function Utility_substr (value, begin, end) {
	return value.slice(begin, end)
}

/**
 * @param {string} value
 * @return {number}
 */
function Utility_strlen (value) {
	return value.length
}

/**
 * @param {any[]} value
 * @return {number}
 */
function Utility_sizeof (value) {
	return value.length
}

/**
 * @param {any} value
 * @param {any[]} array
 * @return {any}
 */
function Utility_append (value, array) {
	return array.push(value), value
}

/**
 * @param {string[]} array
 * @param {function} callback
 * @return {string}
 */
function Utility_combine (array, callback) {
	return array.map(callback).join(&#039;&#039;)
}

;// ./node_modules/stylis/src/Tokenizer.js


var line = 1
var column = 1
var Tokenizer_length = 0
var Tokenizer_position = 0
var Tokenizer_character = 0
var characters = &#039;&#039;

/**
 * @param {string} value
 * @param {object | null} root
 * @param {object | null} parent
 * @param {string} type
 * @param {string[] | string} props
 * @param {object[] | string} children
 * @param {number} length
 */
function node (value, root, parent, type, props, children, length) {
	return {value: value, root: root, parent: parent, type: type, props: props, children: children, line: line, column: column, length: length, return: &#039;&#039;}
}

/**
 * @param {object} root
 * @param {object} props
 * @return {object}
 */
function Tokenizer_copy (root, props) {
	return Utility_assign(node(&#039;&#039;, null, null, &#039;&#039;, null, null, 0), root, {length: -root.length}, props)
}

/**
 * @return {number}
 */
function Tokenizer_char () {
	return Tokenizer_character
}

/**
 * @return {number}
 */
function prev () {
	Tokenizer_character = Tokenizer_position &gt; 0 ? Utility_charat(characters, --Tokenizer_position) : 0

	if (column--, Tokenizer_character === 10)
		column = 1, line--

	return Tokenizer_character
}

/**
 * @return {number}
 */
function next () {
	Tokenizer_character = Tokenizer_position &lt; Tokenizer_length ? Utility_charat(characters, Tokenizer_position++) : 0

	if (column++, Tokenizer_character === 10)
		column = 1, line++

	return Tokenizer_character
}

/**
 * @return {number}
 */
function peek () {
	return Utility_charat(characters, Tokenizer_position)
}

/**
 * @return {number}
 */
function caret () {
	return Tokenizer_position
}

/**
 * @param {number} begin
 * @param {number} end
 * @return {string}
 */
function slice (begin, end) {
	return Utility_substr(characters, begin, end)
}

/**
 * @param {number} type
 * @return {number}
 */
function token (type) {
	switch (type) {
		// \0 \t \n \r \s whitespace token
		case 0: case 9: case 10: case 13: case 32:
			return 5
		// ! + , / &gt; @ ~ isolate token
		case 33: case 43: case 44: case 47: case 62: case 64: case 126:
		// ; { } breakpoint token
		case 59: case 123: case 125:
			return 4
		// : accompanied token
		case 58:
			return 3
		// &quot; &#039; ( [ opening delimit token
		case 34: case 39: case 40: case 91:
			return 2
		// ) ] closing delimit token
		case 41: case 93:
			return 1
	}

	return 0
}

/**
 * @param {string} value
 * @return {any[]}
 */
function alloc (value) {
	return line = column = 1, Tokenizer_length = Utility_strlen(characters = value), Tokenizer_position = 0, []
}

/**
 * @param {any} value
 * @return {any}
 */
function dealloc (value) {
	return characters = &#039;&#039;, value
}

/**
 * @param {number} type
 * @return {string}
 */
function delimit (type) {
	return trim(slice(Tokenizer_position - 1, delimiter(type === 91 ? type + 2 : type === 40 ? type + 1 : type)))
}

/**
 * @param {string} value
 * @return {string[]}
 */
function Tokenizer_tokenize (value) {
	return dealloc(tokenizer(alloc(value)))
}

/**
 * @param {number} type
 * @return {string}
 */
function whitespace (type) {
	while (Tokenizer_character = peek())
		if (Tokenizer_character &lt; 33)
			next()
		else
			break

	return token(type) &gt; 2 || token(Tokenizer_character) &gt; 3 ? &#039;&#039; : &#039; &#039;
}

/**
 * @param {string[]} children
 * @return {string[]}
 */
function tokenizer (children) {
	while (next())
		switch (token(Tokenizer_character)) {
			case 0: append(identifier(Tokenizer_position - 1), children)
				break
			case 2: append(delimit(Tokenizer_character), children)
				break
			default: append(from(Tokenizer_character), children)
		}

	return children
}

/**
 * @param {number} index
 * @param {number} count
 * @return {string}
 */
function escaping (index, count) {
	while (--count &amp;&amp; next())
		// not 0-9 A-F a-f
		if (Tokenizer_character &lt; 48 || Tokenizer_character &gt; 102 || (Tokenizer_character &gt; 57 &amp;&amp; Tokenizer_character &lt; 65) || (Tokenizer_character &gt; 70 &amp;&amp; Tokenizer_character &lt; 97))
			break

	return slice(index, caret() + (count &lt; 6 &amp;&amp; peek() == 32 &amp;&amp; next() == 32))
}

/**
 * @param {number} type
 * @return {number}
 */
function delimiter (type) {
	while (next())
		switch (Tokenizer_character) {
			// ] ) &quot; &#039;
			case type:
				return Tokenizer_position
			// &quot; &#039;
			case 34: case 39:
				if (type !== 34 &amp;&amp; type !== 39)
					delimiter(Tokenizer_character)
				break
			// (
			case 40:
				if (type === 41)
					delimiter(type)
				break
			// \
			case 92:
				next()
				break
		}

	return Tokenizer_position
}

/**
 * @param {number} type
 * @param {number} index
 * @return {number}
 */
function commenter (type, index) {
	while (next())
		// //
		if (type + Tokenizer_character === 47 + 10)
			break
		// /*
		else if (type + Tokenizer_character === 42 + 42 &amp;&amp; peek() === 47)
			break

	return &#039;/*&#039; + slice(index, Tokenizer_position - 1) + &#039;*&#039; + Utility_from(type === 47 ? type : next())
}

/**
 * @param {number} index
 * @return {string}
 */
function identifier (index) {
	while (!token(peek()))
		next()

	return slice(index, Tokenizer_position)
}

;// ./node_modules/stylis/src/Enum.js
var Enum_MS = &#039;-ms-&#039;
var Enum_MOZ = &#039;-moz-&#039;
var Enum_WEBKIT = &#039;-webkit-&#039;

var COMMENT = &#039;comm&#039;
var Enum_RULESET = &#039;rule&#039;
var Enum_DECLARATION = &#039;decl&#039;

var PAGE = &#039;@page&#039;
var MEDIA = &#039;@media&#039;
var IMPORT = &#039;@import&#039;
var CHARSET = &#039;@charset&#039;
var VIEWPORT = &#039;@viewport&#039;
var SUPPORTS = &#039;@supports&#039;
var DOCUMENT = &#039;@document&#039;
var NAMESPACE = &#039;@namespace&#039;
var Enum_KEYFRAMES = &#039;@keyframes&#039;
var FONT_FACE = &#039;@font-face&#039;
var COUNTER_STYLE = &#039;@counter-style&#039;
var FONT_FEATURE_VALUES = &#039;@font-feature-values&#039;

;// ./node_modules/stylis/src/Serializer.js



/**
 * @param {object[]} children
 * @param {function} callback
 * @return {string}
 */
function Serializer_serialize (children, callback) {
	var output = &#039;&#039;
	var length = Utility_sizeof(children)

	for (var i = 0; i &lt; length; i++)
		output += callback(children[i], i, children, callback) || &#039;&#039;

	return output
}

/**
 * @param {object} element
 * @param {number} index
 * @param {object[]} children
 * @param {function} callback
 * @return {string}
 */
function Serializer_stringify (element, index, children, callback) {
	switch (element.type) {
		case IMPORT: case Enum_DECLARATION: return element.return = element.return || element.value
		case COMMENT: return &#039;&#039;
		case Enum_KEYFRAMES: return element.return = element.value + &#039;{&#039; + Serializer_serialize(element.children, callback) + &#039;}&#039;
		case Enum_RULESET: element.value = element.props.join(&#039;,&#039;)
	}

	return Utility_strlen(children = Serializer_serialize(element.children, callback)) ? element.return = element.value + &#039;{&#039; + children + &#039;}&#039; : &#039;&#039;
}

;// ./node_modules/stylis/src/Middleware.js






/**
 * @param {function[]} collection
 * @return {function}
 */
function middleware (collection) {
	var length = Utility_sizeof(collection)

	return function (element, index, children, callback) {
		var output = &#039;&#039;

		for (var i = 0; i &lt; length; i++)
			output += collection[i](element, index, children, callback) || &#039;&#039;

		return output
	}
}

/**
 * @param {function} callback
 * @return {function}
 */
function rulesheet (callback) {
	return function (element) {
		if (!element.root)
			if (element = element.return)
				callback(element)
	}
}

/**
 * @param {object} element
 * @param {number} index
 * @param {object[]} children
 * @param {function} callback
 */
function prefixer (element, index, children, callback) {
	if (element.length &gt; -1)
		if (!element.return)
			switch (element.type) {
				case DECLARATION: element.return = prefix(element.value, element.length, children)
					return
				case KEYFRAMES:
					return serialize([copy(element, {value: replace(element.value, &#039;@&#039;, &#039;@&#039; + WEBKIT)})], callback)
				case RULESET:
					if (element.length)
						return combine(element.props, function (value) {
							switch (match(value, /(::plac\w+|:read-\w+)/)) {
								// :read-(only|write)
								case &#039;:read-only&#039;: case &#039;:read-write&#039;:
									return serialize([copy(element, {props: [replace(value, /:(read-\w+)/, &#039;:&#039; + MOZ + &#039;$1&#039;)]})], callback)
								// :placeholder
								case &#039;::placeholder&#039;:
									return serialize([
										copy(element, {props: [replace(value, /:(plac\w+)/, &#039;:&#039; + WEBKIT + &#039;input-$1&#039;)]}),
										copy(element, {props: [replace(value, /:(plac\w+)/, &#039;:&#039; + MOZ + &#039;$1&#039;)]}),
										copy(element, {props: [replace(value, /:(plac\w+)/, MS + &#039;input-$1&#039;)]})
									], callback)
							}

							return &#039;&#039;
						})
			}
}

/**
 * @param {object} element
 * @param {number} index
 * @param {object[]} children
 */
function namespace (element) {
	switch (element.type) {
		case RULESET:
			element.props = element.props.map(function (value) {
				return combine(tokenize(value), function (value, index, children) {
					switch (charat(value, 0)) {
						// \f
						case 12:
							return substr(value, 1, strlen(value))
						// \0 ( + &gt; ~
						case 0: case 40: case 43: case 62: case 126:
							return value
						// :
						case 58:
							if (children[++index] === &#039;global&#039;)
								children[index] = &#039;&#039;, children[++index] = &#039;\f&#039; + substr(children[index], index = 1, -1)
						// \s
						case 32:
							return index === 1 ? &#039;&#039; : value
						default:
							switch (index) {
								case 0: element = value
									return sizeof(children) &gt; 1 ? &#039;&#039; : value
								case index = sizeof(children) - 1: case 2:
									return index === 2 ? value + element + element : value + element
								default:
									return value
							}
					}
				})
			})
	}
}

;// ./node_modules/stylis/src/Parser.js




/**
 * @param {string} value
 * @return {object[]}
 */
function compile (value) {
	return dealloc(Parser_parse(&#039;&#039;, null, null, null, [&#039;&#039;], value = alloc(value), 0, [0], value))
}

/**
 * @param {string} value
 * @param {object} root
 * @param {object?} parent
 * @param {string[]} rule
 * @param {string[]} rules
 * @param {string[]} rulesets
 * @param {number[]} pseudo
 * @param {number[]} points
 * @param {string[]} declarations
 * @return {object}
 */
function Parser_parse (value, root, parent, rule, rules, rulesets, pseudo, points, declarations) {
	var index = 0
	var offset = 0
	var length = pseudo
	var atrule = 0
	var property = 0
	var previous = 0
	var variable = 1
	var scanning = 1
	var ampersand = 1
	var character = 0
	var type = &#039;&#039;
	var props = rules
	var children = rulesets
	var reference = rule
	var characters = type

	while (scanning)
		switch (previous = character, character = next()) {
			// (
			case 40:
				if (previous != 108 &amp;&amp; Utility_charat(characters, length - 1) == 58) {
					if (indexof(characters += Utility_replace(delimit(character), &#039;&amp;&#039;, &#039;&amp;\f&#039;), &#039;&amp;\f&#039;) != -1)
						ampersand = -1
					break
				}
			// &quot; &#039; [
			case 34: case 39: case 91:
				characters += delimit(character)
				break
			// \t \n \r \s
			case 9: case 10: case 13: case 32:
				characters += whitespace(previous)
				break
			// \
			case 92:
				characters += escaping(caret() - 1, 7)
				continue
			// /
			case 47:
				switch (peek()) {
					case 42: case 47:
						Utility_append(comment(commenter(next(), caret()), root, parent), declarations)
						break
					default:
						characters += &#039;/&#039;
				}
				break
			// {
			case 123 * variable:
				points[index++] = Utility_strlen(characters) * ampersand
			// } ; \0
			case 125 * variable: case 59: case 0:
				switch (character) {
					// \0 }
					case 0: case 125: scanning = 0
					// ;
					case 59 + offset:
						if (property &gt; 0 &amp;&amp; (Utility_strlen(characters) - length))
							Utility_append(property &gt; 32 ? declaration(characters + &#039;;&#039;, rule, parent, length - 1) : declaration(Utility_replace(characters, &#039; &#039;, &#039;&#039;) + &#039;;&#039;, rule, parent, length - 2), declarations)
						break
					// @ ;
					case 59: characters += &#039;;&#039;
					// { rule/at-rule
					default:
						Utility_append(reference = ruleset(characters, root, parent, index, offset, rules, points, type, props = [], children = [], length), rulesets)

						if (character === 123)
							if (offset === 0)
								Parser_parse(characters, root, reference, reference, props, rulesets, length, points, children)
							else
								switch (atrule === 99 &amp;&amp; Utility_charat(characters, 3) === 110 ? 100 : atrule) {
									// d m s
									case 100: case 109: case 115:
										Parser_parse(value, reference, reference, rule &amp;&amp; Utility_append(ruleset(value, reference, reference, 0, 0, rules, points, type, rules, props = [], length), children), rules, children, length, points, rule ? props : children)
										break
									default:
										Parser_parse(characters, reference, reference, reference, [&#039;&#039;], children, 0, points, children)
								}
				}

				index = offset = property = 0, variable = ampersand = 1, type = characters = &#039;&#039;, length = pseudo
				break
			// :
			case 58:
				length = 1 + Utility_strlen(characters), property = previous
			default:
				if (variable &lt; 1)
					if (character == 123)
						--variable
					else if (character == 125 &amp;&amp; variable++ == 0 &amp;&amp; prev() == 125)
						continue

				switch (characters += Utility_from(character), character * variable) {
					// &amp;
					case 38:
						ampersand = offset &gt; 0 ? 1 : (characters += &#039;\f&#039;, -1)
						break
					// ,
					case 44:
						points[index++] = (Utility_strlen(characters) - 1) * ampersand, ampersand = 1
						break
					// @
					case 64:
						// -
						if (peek() === 45)
							characters += delimit(next())

						atrule = peek(), offset = length = Utility_strlen(type = characters += identifier(caret())), character++
						break
					// -
					case 45:
						if (previous === 45 &amp;&amp; Utility_strlen(characters) == 2)
							variable = 0
				}
		}

	return rulesets
}

/**
 * @param {string} value
 * @param {object} root
 * @param {object?} parent
 * @param {number} index
 * @param {number} offset
 * @param {string[]} rules
 * @param {number[]} points
 * @param {string} type
 * @param {string[]} props
 * @param {string[]} children
 * @param {number} length
 * @return {object}
 */
function ruleset (value, root, parent, index, offset, rules, points, type, props, children, length) {
	var post = offset - 1
	var rule = offset === 0 ? rules : [&#039;&#039;]
	var size = Utility_sizeof(rule)

	for (var i = 0, j = 0, k = 0; i &lt; index; ++i)
		for (var x = 0, y = Utility_substr(value, post + 1, post = abs(j = points[i])), z = value; x &lt; size; ++x)
			if (z = trim(j &gt; 0 ? rule[x] + &#039; &#039; + y : Utility_replace(y, /&amp;\f/g, rule[x])))
				props[k++] = z

	return node(value, root, parent, offset === 0 ? Enum_RULESET : type, props, children, length)
}

/**
 * @param {number} value
 * @param {object} root
 * @param {object?} parent
 * @return {object}
 */
function comment (value, root, parent) {
	return node(value, root, parent, COMMENT, Utility_from(Tokenizer_char()), Utility_substr(value, 2, -2), 0)
}

/**
 * @param {string} value
 * @param {object} root
 * @param {object?} parent
 * @param {number} length
 * @return {object}
 */
function declaration (value, root, parent, length) {
	return node(value, root, parent, Enum_DECLARATION, Utility_substr(value, 0, length), Utility_substr(value, length + 1, -1), length)
}

;// ./node_modules/@emotion/cache/dist/emotion-cache.browser.esm.js





var identifierWithPointTracking = function identifierWithPointTracking(begin, points, index) {
  var previous = 0;
  var character = 0;

  while (true) {
    previous = character;
    character = peek(); // &amp;\f

    if (previous === 38 &amp;&amp; character === 12) {
      points[index] = 1;
    }

    if (token(character)) {
      break;
    }

    next();
  }

  return slice(begin, Tokenizer_position);
};

var toRules = function toRules(parsed, points) {
  // pretend we&#039;ve started with a comma
  var index = -1;
  var character = 44;

  do {
    switch (token(character)) {
      case 0:
        // &amp;\f
        if (character === 38 &amp;&amp; peek() === 12) {
          // this is not 100% correct, we don&#039;t account for literal sequences here - like for example quoted strings
          // stylis inserts \f after &amp; to know when &amp; where it should replace this sequence with the context selector
          // and when it should just concatenate the outer and inner selectors
          // it&#039;s very unlikely for this sequence to actually appear in a different context, so we just leverage this fact here
          points[index] = 1;
        }

        parsed[index] += identifierWithPointTracking(Tokenizer_position - 1, points, index);
        break;

      case 2:
        parsed[index] += delimit(character);
        break;

      case 4:
        // comma
        if (character === 44) {
          // colon
          parsed[++index] = peek() === 58 ? &#039;&amp;\f&#039; : &#039;&#039;;
          points[index] = parsed[index].length;
          break;
        }

      // fallthrough

      default:
        parsed[index] += Utility_from(character);
    }
  } while (character = next());

  return parsed;
};

var getRules = function getRules(value, points) {
  return dealloc(toRules(alloc(value), points));
}; // WeakSet would be more appropriate, but only WeakMap is supported in IE11


var fixedElements = /* #__PURE__ */new WeakMap();
var compat = function compat(element) {
  if (element.type !== &#039;rule&#039; || !element.parent || // positive .length indicates that this rule contains pseudo
  // negative .length indicates that this rule has been already prefixed
  element.length &lt; 1) {
    return;
  }

  var value = element.value,
      parent = element.parent;
  var isImplicitRule = element.column === parent.column &amp;&amp; element.line === parent.line;

  while (parent.type !== &#039;rule&#039;) {
    parent = parent.parent;
    if (!parent) return;
  } // short-circuit for the simplest case


  if (element.props.length === 1 &amp;&amp; value.charCodeAt(0) !== 58
  /* colon */
  &amp;&amp; !fixedElements.get(parent)) {
    return;
  } // if this is an implicitly inserted rule (the one eagerly inserted at the each new nested level)
  // then the props has already been manipulated beforehand as they that array is shared between it and its &quot;rule parent&quot;


  if (isImplicitRule) {
    return;
  }

  fixedElements.set(element, true);
  var points = [];
  var rules = getRules(value, points);
  var parentRules = parent.props;

  for (var i = 0, k = 0; i &lt; rules.length; i++) {
    for (var j = 0; j &lt; parentRules.length; j++, k++) {
      element.props[k] = points[i] ? rules[i].replace(/&amp;\f/g, parentRules[j]) : parentRules[j] + &quot; &quot; + rules[i];
    }
  }
};
var removeLabel = function removeLabel(element) {
  if (element.type === &#039;decl&#039;) {
    var value = element.value;

    if ( // charcode for l
    value.charCodeAt(0) === 108 &amp;&amp; // charcode for b
    value.charCodeAt(2) === 98) {
      // this ignores label
      element[&quot;return&quot;] = &#039;&#039;;
      element.value = &#039;&#039;;
    }
  }
};
var ignoreFlag = &#039;emotion-disable-server-rendering-unsafe-selector-warning-please-do-not-use-this-the-warning-exists-for-a-reason&#039;;

var isIgnoringComment = function isIgnoringComment(element) {
  return element.type === &#039;comm&#039; &amp;&amp; element.children.indexOf(ignoreFlag) &gt; -1;
};

var createUnsafeSelectorsAlarm = function createUnsafeSelectorsAlarm(cache) {
  return function (element, index, children) {
    if (element.type !== &#039;rule&#039; || cache.compat) return;
    var unsafePseudoClasses = element.value.match(/(:first|:nth|:nth-last)-child/g);

    if (unsafePseudoClasses) {
      var isNested = element.parent === children[0]; // in nested rules comments become children of the &quot;auto-inserted&quot; rule
      //
      // considering this input:
      // .a {
      //   .b /* comm */ {}
      //   color: hotpink;
      // }
      // we get output corresponding to this:
      // .a {
      //   &amp; {
      //     /* comm */
      //     color: hotpink;
      //   }
      //   .b {}
      // }

      var commentContainer = isNested ? children[0].children : // global rule at the root level
      children;

      for (var i = commentContainer.length - 1; i &gt;= 0; i--) {
        var node = commentContainer[i];

        if (node.line &lt; element.line) {
          break;
        } // it is quite weird but comments are *usually* put at `column: element.column - 1`
        // so we seek *from the end* for the node that is earlier than the rule&#039;s `element` and check that
        // this will also match inputs like this:
        // .a {
        //   /* comm */
        //   .b {}
        // }
        //
        // but that is fine
        //
        // it would be the easiest to change the placement of the comment to be the first child of the rule:
        // .a {
        //   .b { /* comm */ }
        // }
        // with such inputs we wouldn&#039;t have to search for the comment at all
        // TODO: consider changing this comment placement in the next major version


        if (node.column &lt; element.column) {
          if (isIgnoringComment(node)) {
            return;
          }

          break;
        }
      }

      unsafePseudoClasses.forEach(function (unsafePseudoClass) {
        console.error(&quot;The pseudo class \&quot;&quot; + unsafePseudoClass + &quot;\&quot; is potentially unsafe when doing server-side rendering. Try changing it to \&quot;&quot; + unsafePseudoClass.split(&#039;-child&#039;)[0] + &quot;-of-type\&quot;.&quot;);
      });
    }
  };
};

var isImportRule = function isImportRule(element) {
  return element.type.charCodeAt(1) === 105 &amp;&amp; element.type.charCodeAt(0) === 64;
};

var isPrependedWithRegularRules = function isPrependedWithRegularRules(index, children) {
  for (var i = index - 1; i &gt;= 0; i--) {
    if (!isImportRule(children[i])) {
      return true;
    }
  }

  return false;
}; // use this to remove incorrect elements from further processing
// so they don&#039;t get handed to the `sheet` (or anything else)
// as that could potentially lead to additional logs which in turn could be overhelming to the user


var nullifyElement = function nullifyElement(element) {
  element.type = &#039;&#039;;
  element.value = &#039;&#039;;
  element[&quot;return&quot;] = &#039;&#039;;
  element.children = &#039;&#039;;
  element.props = &#039;&#039;;
};

var incorrectImportAlarm = function incorrectImportAlarm(element, index, children) {
  if (!isImportRule(element)) {
    return;
  }

  if (element.parent) {
    console.error(&quot;`@import` rules can&#039;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.&quot;);
    nullifyElement(element);
  } else if (isPrependedWithRegularRules(index, children)) {
    console.error(&quot;`@import` rules can&#039;t be after other rules. Please put your `@import` rules before your other rules.&quot;);
    nullifyElement(element);
  }
};

/* eslint-disable no-fallthrough */

function emotion_cache_browser_esm_prefix(value, length) {
  switch (hash(value, length)) {
    // color-adjust
    case 5103:
      return Enum_WEBKIT + &#039;print-&#039; + value + value;
    // animation, animation-(delay|direction|duration|fill-mode|iteration-count|name|play-state|timing-function)

    case 5737:
    case 4201:
    case 3177:
    case 3433:
    case 1641:
    case 4457:
    case 2921: // text-decoration, filter, clip-path, backface-visibility, column, box-decoration-break

    case 5572:
    case 6356:
    case 5844:
    case 3191:
    case 6645:
    case 3005: // mask, mask-image, mask-(mode|clip|size), mask-(repeat|origin), mask-position, mask-composite,

    case 6391:
    case 5879:
    case 5623:
    case 6135:
    case 4599:
    case 4855: // background-clip, columns, column-(count|fill|gap|rule|rule-color|rule-style|rule-width|span|width)

    case 4215:
    case 6389:
    case 5109:
    case 5365:
    case 5621:
    case 3829:
      return Enum_WEBKIT + value + value;
    // appearance, user-select, transform, hyphens, text-size-adjust

    case 5349:
    case 4246:
    case 4810:
    case 6968:
    case 2756:
      return Enum_WEBKIT + value + Enum_MOZ + value + Enum_MS + value + value;
    // flex, flex-direction

    case 6828:
    case 4268:
      return Enum_WEBKIT + value + Enum_MS + value + value;
    // order

    case 6165:
      return Enum_WEBKIT + value + Enum_MS + &#039;flex-&#039; + value + value;
    // align-items

    case 5187:
      return Enum_WEBKIT + value + Utility_replace(value, /(\w+).+(:[^]+)/, Enum_WEBKIT + &#039;box-$1$2&#039; + Enum_MS + &#039;flex-$1$2&#039;) + value;
    // align-self

    case 5443:
      return Enum_WEBKIT + value + Enum_MS + &#039;flex-item-&#039; + Utility_replace(value, /flex-|-self/, &#039;&#039;) + value;
    // align-content

    case 4675:
      return Enum_WEBKIT + value + Enum_MS + &#039;flex-line-pack&#039; + Utility_replace(value, /align-content|flex-|-self/, &#039;&#039;) + value;
    // flex-shrink

    case 5548:
      return Enum_WEBKIT + value + Enum_MS + Utility_replace(value, &#039;shrink&#039;, &#039;negative&#039;) + value;
    // flex-basis

    case 5292:
      return Enum_WEBKIT + value + Enum_MS + Utility_replace(value, &#039;basis&#039;, &#039;preferred-size&#039;) + value;
    // flex-grow

    case 6060:
      return Enum_WEBKIT + &#039;box-&#039; + Utility_replace(value, &#039;-grow&#039;, &#039;&#039;) + Enum_WEBKIT + value + Enum_MS + Utility_replace(value, &#039;grow&#039;, &#039;positive&#039;) + value;
    // transition

    case 4554:
      return Enum_WEBKIT + Utility_replace(value, /([^-])(transform)/g, &#039;$1&#039; + Enum_WEBKIT + &#039;$2&#039;) + value;
    // cursor

    case 6187:
      return Utility_replace(Utility_replace(Utility_replace(value, /(zoom-|grab)/, Enum_WEBKIT + &#039;$1&#039;), /(image-set)/, Enum_WEBKIT + &#039;$1&#039;), value, &#039;&#039;) + value;
    // background, background-image

    case 5495:
    case 3959:
      return Utility_replace(value, /(image-set\([^]*)/, Enum_WEBKIT + &#039;$1&#039; + &#039;$`$1&#039;);
    // justify-content

    case 4968:
      return Utility_replace(Utility_replace(value, /(.+:)(flex-)?(.*)/, Enum_WEBKIT + &#039;box-pack:$3&#039; + Enum_MS + &#039;flex-pack:$3&#039;), /s.+-b[^;]+/, &#039;justify&#039;) + Enum_WEBKIT + value + value;
    // (margin|padding)-inline-(start|end)

    case 4095:
    case 3583:
    case 4068:
    case 2532:
      return Utility_replace(value, /(.+)-inline(.+)/, Enum_WEBKIT + &#039;$1$2&#039;) + value;
    // (min|max)?(width|height|inline-size|block-size)

    case 8116:
    case 7059:
    case 5753:
    case 5535:
    case 5445:
    case 5701:
    case 4933:
    case 4677:
    case 5533:
    case 5789:
    case 5021:
    case 4765:
      // stretch, max-content, min-content, fill-available
      if (Utility_strlen(value) - 1 - length &gt; 6) switch (Utility_charat(value, length + 1)) {
        // (m)ax-content, (m)in-content
        case 109:
          // -
          if (Utility_charat(value, length + 4) !== 45) break;
        // (f)ill-available, (f)it-content

        case 102:
          return Utility_replace(value, /(.+:)(.+)-([^]+)/, &#039;$1&#039; + Enum_WEBKIT + &#039;$2-$3&#039; + &#039;$1&#039; + Enum_MOZ + (Utility_charat(value, length + 3) == 108 ? &#039;$3&#039; : &#039;$2-$3&#039;)) + value;
        // (s)tretch

        case 115:
          return ~indexof(value, &#039;stretch&#039;) ? emotion_cache_browser_esm_prefix(Utility_replace(value, &#039;stretch&#039;, &#039;fill-available&#039;), length) + value : value;
      }
      break;
    // position: sticky

    case 4949:
      // (s)ticky?
      if (Utility_charat(value, length + 1) !== 115) break;
    // display: (flex|inline-flex)

    case 6444:
      switch (Utility_charat(value, Utility_strlen(value) - 3 - (~indexof(value, &#039;!important&#039;) &amp;&amp; 10))) {
        // stic(k)y
        case 107:
          return Utility_replace(value, &#039;:&#039;, &#039;:&#039; + Enum_WEBKIT) + value;
        // (inline-)?fl(e)x

        case 101:
          return Utility_replace(value, /(.+:)([^;!]+)(;|!.+)?/, &#039;$1&#039; + Enum_WEBKIT + (Utility_charat(value, 14) === 45 ? &#039;inline-&#039; : &#039;&#039;) + &#039;box$3&#039; + &#039;$1&#039; + Enum_WEBKIT + &#039;$2$3&#039; + &#039;$1&#039; + Enum_MS + &#039;$2box$3&#039;) + value;
      }

      break;
    // writing-mode

    case 5936:
      switch (Utility_charat(value, length + 11)) {
        // vertical-l(r)
        case 114:
          return Enum_WEBKIT + value + Enum_MS + Utility_replace(value, /[svh]\w+-[tblr]{2}/, &#039;tb&#039;) + value;
        // vertical-r(l)

        case 108:
          return Enum_WEBKIT + value + Enum_MS + Utility_replace(value, /[svh]\w+-[tblr]{2}/, &#039;tb-rl&#039;) + value;
        // horizontal(-)tb

        case 45:
          return Enum_WEBKIT + value + Enum_MS + Utility_replace(value, /[svh]\w+-[tblr]{2}/, &#039;lr&#039;) + value;
      }

      return Enum_WEBKIT + value + Enum_MS + value + value;
  }

  return value;
}

var emotion_cache_browser_esm_prefixer = function prefixer(element, index, children, callback) {
  if (element.length &gt; -1) if (!element[&quot;return&quot;]) switch (element.type) {
    case Enum_DECLARATION:
      element[&quot;return&quot;] = emotion_cache_browser_esm_prefix(element.value, element.length);
      break;

    case Enum_KEYFRAMES:
      return Serializer_serialize([Tokenizer_copy(element, {
        value: Utility_replace(element.value, &#039;@&#039;, &#039;@&#039; + Enum_WEBKIT)
      })], callback);

    case Enum_RULESET:
      if (element.length) return Utility_combine(element.props, function (value) {
        switch (Utility_match(value, /(::plac\w+|:read-\w+)/)) {
          // :read-(only|write)
          case &#039;:read-only&#039;:
          case &#039;:read-write&#039;:
            return Serializer_serialize([Tokenizer_copy(element, {
              props: [Utility_replace(value, /:(read-\w+)/, &#039;:&#039; + Enum_MOZ + &#039;$1&#039;)]
            })], callback);
          // :placeholder

          case &#039;::placeholder&#039;:
            return Serializer_serialize([Tokenizer_copy(element, {
              props: [Utility_replace(value, /:(plac\w+)/, &#039;:&#039; + Enum_WEBKIT + &#039;input-$1&#039;)]
            }), Tokenizer_copy(element, {
              props: [Utility_replace(value, /:(plac\w+)/, &#039;:&#039; + Enum_MOZ + &#039;$1&#039;)]
            }), Tokenizer_copy(element, {
              props: [Utility_replace(value, /:(plac\w+)/, Enum_MS + &#039;input-$1&#039;)]
            })], callback);
        }

        return &#039;&#039;;
      });
  }
};

var defaultStylisPlugins = [emotion_cache_browser_esm_prefixer];

var createCache = function createCache(options) {
  var key = options.key;

  if (false) {}

  if ( key === &#039;css&#039;) {
    var ssrStyles = document.querySelectorAll(&quot;style[data-emotion]:not([data-s])&quot;); // get SSRed styles out of the way of React&#039;s hydration
    // document.head is a safe place to move them to(though note document.head is not necessarily the last place they will be)
    // note this very very intentionally targets all style elements regardless of the key to ensure
    // that creating a cache works inside of render of a React component

    Array.prototype.forEach.call(ssrStyles, function (node) {
      // we want to only move elements which have a space in the data-emotion attribute value
      // because that indicates that it is an Emotion 11 server-side rendered style elements
      // while we will already ignore Emotion 11 client-side inserted styles because of the :not([data-s]) part in the selector
      // Emotion 10 client-side inserted styles did not have data-s (but importantly did not have a space in their data-emotion attributes)
      // so checking for the space ensures that loading Emotion 11 after Emotion 10 has inserted some styles
      // will not result in the Emotion 10 styles being destroyed
      var dataEmotionAttribute = node.getAttribute(&#039;data-emotion&#039;);

      if (dataEmotionAttribute.indexOf(&#039; &#039;) === -1) {
        return;
      }
      document.head.appendChild(node);
      node.setAttribute(&#039;data-s&#039;, &#039;&#039;);
    });
  }

  var stylisPlugins = options.stylisPlugins || defaultStylisPlugins;

  if (false) {}

  var inserted = {};
  var container;
  var nodesToHydrate = [];

  {
    container = options.container || document.head;
    Array.prototype.forEach.call( // this means we will ignore elements which don&#039;t have a space in them which
    // means that the style elements we&#039;re looking at are only Emotion 11 server-rendered style elements
    document.querySelectorAll(&quot;style[data-emotion^=\&quot;&quot; + key + &quot; \&quot;]&quot;), function (node) {
      var attrib = node.getAttribute(&quot;data-emotion&quot;).split(&#039; &#039;); // $FlowFixMe

      for (var i = 1; i &lt; attrib.length; i++) {
        inserted[attrib[i]] = true;
      }

      nodesToHydrate.push(node);
    });
  }

  var _insert;

  var omnipresentPlugins = [compat, removeLabel];

  if (false) {}

  {
    var currentSheet;
    var finalizingPlugins = [Serializer_stringify,  false ? 0 : rulesheet(function (rule) {
      currentSheet.insert(rule);
    })];
    var serializer = middleware(omnipresentPlugins.concat(stylisPlugins, finalizingPlugins));

    var stylis = function stylis(styles) {
      return Serializer_serialize(compile(styles), serializer);
    };

    _insert = function insert(selector, serialized, sheet, shouldCache) {
      currentSheet = sheet;

      if (false) {}

      stylis(selector ? selector + &quot;{&quot; + serialized.styles + &quot;}&quot; : serialized.styles);

      if (shouldCache) {
        cache.inserted[serialized.name] = true;
      }
    };
  }

  var cache = {
    key: key,
    sheet: new StyleSheet({
      key: key,
      container: container,
      nonce: options.nonce,
      speedy: options.speedy,
      prepend: options.prepend,
      insertionPoint: options.insertionPoint
    }),
    nonce: options.nonce,
    inserted: inserted,
    registered: {},
    insert: _insert
  };
  cache.sheet.hydrate(nodesToHydrate);
  return cache;
};

/* harmony default export */ const emotion_cache_browser_esm = (createCache);

;// ./node_modules/@emotion/hash/dist/emotion-hash.esm.js
/* eslint-disable */
// Inspired by https://github.com/garycourt/murmurhash-js
// Ported from https://github.com/aappleby/smhasher/blob/61a0530f28277f2e850bfc39600ce61d02b518de/src/MurmurHash2.cpp#L37-L86
function murmur2(str) {
  // &#039;m&#039; and &#039;r&#039; are mixing constants generated offline.
  // They&#039;re not really &#039;magic&#039;, they just happen to work well.
  // const m = 0x5bd1e995;
  // const r = 24;
  // Initialize the hash
  var h = 0; // Mix 4 bytes at a time into the hash

  var k,
      i = 0,
      len = str.length;

  for (; len &gt;= 4; ++i, len -= 4) {
    k = str.charCodeAt(i) &amp; 0xff | (str.charCodeAt(++i) &amp; 0xff) &lt;&lt; 8 | (str.charCodeAt(++i) &amp; 0xff) &lt;&lt; 16 | (str.charCodeAt(++i) &amp; 0xff) &lt;&lt; 24;
    k =
    /* Math.imul(k, m): */
    (k &amp; 0xffff) * 0x5bd1e995 + ((k &gt;&gt;&gt; 16) * 0xe995 &lt;&lt; 16);
    k ^=
    /* k &gt;&gt;&gt; r: */
    k &gt;&gt;&gt; 24;
    h =
    /* Math.imul(k, m): */
    (k &amp; 0xffff) * 0x5bd1e995 + ((k &gt;&gt;&gt; 16) * 0xe995 &lt;&lt; 16) ^
    /* Math.imul(h, m): */
    (h &amp; 0xffff) * 0x5bd1e995 + ((h &gt;&gt;&gt; 16) * 0xe995 &lt;&lt; 16);
  } // Handle the last few bytes of the input array


  switch (len) {
    case 3:
      h ^= (str.charCodeAt(i + 2) &amp; 0xff) &lt;&lt; 16;

    case 2:
      h ^= (str.charCodeAt(i + 1) &amp; 0xff) &lt;&lt; 8;

    case 1:
      h ^= str.charCodeAt(i) &amp; 0xff;
      h =
      /* Math.imul(h, m): */
      (h &amp; 0xffff) * 0x5bd1e995 + ((h &gt;&gt;&gt; 16) * 0xe995 &lt;&lt; 16);
  } // Do a few final mixes of the hash to ensure the last few
  // bytes are well-incorporated.


  h ^= h &gt;&gt;&gt; 13;
  h =
  /* Math.imul(h, m): */
  (h &amp; 0xffff) * 0x5bd1e995 + ((h &gt;&gt;&gt; 16) * 0xe995 &lt;&lt; 16);
  return ((h ^ h &gt;&gt;&gt; 15) &gt;&gt;&gt; 0).toString(36);
}

/* harmony default export */ const emotion_hash_esm = (murmur2);

;// ./node_modules/@emotion/unitless/dist/emotion-unitless.esm.js
var unitlessKeys = {
  animationIterationCount: 1,
  borderImageOutset: 1,
  borderImageSlice: 1,
  borderImageWidth: 1,
  boxFlex: 1,
  boxFlexGroup: 1,
  boxOrdinalGroup: 1,
  columnCount: 1,
  columns: 1,
  flex: 1,
  flexGrow: 1,
  flexPositive: 1,
  flexShrink: 1,
  flexNegative: 1,
  flexOrder: 1,
  gridRow: 1,
  gridRowEnd: 1,
  gridRowSpan: 1,
  gridRowStart: 1,
  gridColumn: 1,
  gridColumnEnd: 1,
  gridColumnSpan: 1,
  gridColumnStart: 1,
  msGridRow: 1,
  msGridRowSpan: 1,
  msGridColumn: 1,
  msGridColumnSpan: 1,
  fontWeight: 1,
  lineHeight: 1,
  opacity: 1,
  order: 1,
  orphans: 1,
  tabSize: 1,
  widows: 1,
  zIndex: 1,
  zoom: 1,
  WebkitLineClamp: 1,
  // SVG-related properties
  fillOpacity: 1,
  floodOpacity: 1,
  stopOpacity: 1,
  strokeDasharray: 1,
  strokeDashoffset: 1,
  strokeMiterlimit: 1,
  strokeOpacity: 1,
  strokeWidth: 1
};

/* harmony default export */ const emotion_unitless_esm = (unitlessKeys);

;// ./node_modules/@emotion/serialize/dist/emotion-serialize.browser.esm.js




var ILLEGAL_ESCAPE_SEQUENCE_ERROR = &quot;You have illegal escape sequence in your template literal, most likely inside content&#039;s property value.\nBecause you write your CSS inside a JavaScript string you actually have to do double escaping, so for example \&quot;content: &#039;\\00d7&#039;;\&quot; should become \&quot;content: &#039;\\\\00d7&#039;;\&quot;.\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&quot;;
var UNDEFINED_AS_OBJECT_KEY_ERROR = &quot;You have passed in falsy value as style object&#039;s key (can happen when in example you pass unexported component as computed key).&quot;;
var hyphenateRegex = /[A-Z]|^ms/g;
var animationRegex = /_EMO_([^_]+?)_([^]*?)_EMO_/g;

var isCustomProperty = function isCustomProperty(property) {
  return property.charCodeAt(1) === 45;
};

var isProcessableValue = function isProcessableValue(value) {
  return value != null &amp;&amp; typeof value !== &#039;boolean&#039;;
};

var processStyleName = /* #__PURE__ */memoize(function (styleName) {
  return isCustomProperty(styleName) ? styleName : styleName.replace(hyphenateRegex, &#039;-$&amp;&#039;).toLowerCase();
});

var processStyleValue = function processStyleValue(key, value) {
  switch (key) {
    case &#039;animation&#039;:
    case &#039;animationName&#039;:
      {
        if (typeof value === &#039;string&#039;) {
          return value.replace(animationRegex, function (match, p1, p2) {
            cursor = {
              name: p1,
              styles: p2,
              next: cursor
            };
            return p1;
          });
        }
      }
  }

  if (emotion_unitless_esm[key] !== 1 &amp;&amp; !isCustomProperty(key) &amp;&amp; typeof value === &#039;number&#039; &amp;&amp; value !== 0) {
    return value + &#039;px&#039;;
  }

  return value;
};

if (false) { var hyphenatedCache, hyphenPattern, msPattern, oldProcessStyleValue, contentValues, contentValuePattern; }

var noComponentSelectorMessage = (/* unused pure expression or super */ null &amp;&amp; (&#039;Component selectors can only be used in conjunction with &#039; + &#039;@emotion/babel-plugin, the swc Emotion plugin, or another Emotion-aware &#039; + &#039;compiler transform.&#039;));

function handleInterpolation(mergedProps, registered, interpolation) {
  if (interpolation == null) {
    return &#039;&#039;;
  }

  if (interpolation.__emotion_styles !== undefined) {
    if (false) {}

    return interpolation;
  }

  switch (typeof interpolation) {
    case &#039;boolean&#039;:
      {
        return &#039;&#039;;
      }

    case &#039;object&#039;:
      {
        if (interpolation.anim === 1) {
          cursor = {
            name: interpolation.name,
            styles: interpolation.styles,
            next: cursor
          };
          return interpolation.name;
        }

        if (interpolation.styles !== undefined) {
          var next = interpolation.next;

          if (next !== undefined) {
            // not the most efficient thing ever but this is a pretty rare case
            // and there will be very few iterations of this generally
            while (next !== undefined) {
              cursor = {
                name: next.name,
                styles: next.styles,
                next: cursor
              };
              next = next.next;
            }
          }

          var styles = interpolation.styles + &quot;;&quot;;

          if (false) {}

          return styles;
        }

        return createStringFromObject(mergedProps, registered, interpolation);
      }

    case &#039;function&#039;:
      {
        if (mergedProps !== undefined) {
          var previousCursor = cursor;
          var result = interpolation(mergedProps);
          cursor = previousCursor;
          return handleInterpolation(mergedProps, registered, result);
        } else if (false) {}

        break;
      }

    case &#039;string&#039;:
      if (false) { var replaced, matched; }

      break;
  } // finalize string values (regular strings and functions interpolated into css calls)


  if (registered == null) {
    return interpolation;
  }

  var cached = registered[interpolation];
  return cached !== undefined ? cached : interpolation;
}

function createStringFromObject(mergedProps, registered, obj) {
  var string = &#039;&#039;;

  if (Array.isArray(obj)) {
    for (var i = 0; i &lt; obj.length; i++) {
      string += handleInterpolation(mergedProps, registered, obj[i]) + &quot;;&quot;;
    }
  } else {
    for (var _key in obj) {
      var value = obj[_key];

      if (typeof value !== &#039;object&#039;) {
        if (registered != null &amp;&amp; registered[value] !== undefined) {
          string += _key + &quot;{&quot; + registered[value] + &quot;}&quot;;
        } else if (isProcessableValue(value)) {
          string += processStyleName(_key) + &quot;:&quot; + processStyleValue(_key, value) + &quot;;&quot;;
        }
      } else {
        if (_key === &#039;NO_COMPONENT_SELECTOR&#039; &amp;&amp; &quot;production&quot; !== &#039;production&#039;) {}

        if (Array.isArray(value) &amp;&amp; typeof value[0] === &#039;string&#039; &amp;&amp; (registered == null || registered[value[0]] === undefined)) {
          for (var _i = 0; _i &lt; value.length; _i++) {
            if (isProcessableValue(value[_i])) {
              string += processStyleName(_key) + &quot;:&quot; + processStyleValue(_key, value[_i]) + &quot;;&quot;;
            }
          }
        } else {
          var interpolated = handleInterpolation(mergedProps, registered, value);

          switch (_key) {
            case &#039;animation&#039;:
            case &#039;animationName&#039;:
              {
                string += processStyleName(_key) + &quot;:&quot; + interpolated + &quot;;&quot;;
                break;
              }

            default:
              {
                if (false) {}

                string += _key + &quot;{&quot; + interpolated + &quot;}&quot;;
              }
          }
        }
      }
    }
  }

  return string;
}

var labelPattern = /label:\s*([^\s;\n{]+)\s*(;|$)/g;
var sourceMapPattern;

if (false) {} // this is the cursor for keyframes
// keyframes are stored on the SerializedStyles object as a linked list


var cursor;
var emotion_serialize_browser_esm_serializeStyles = function serializeStyles(args, registered, mergedProps) {
  if (args.length === 1 &amp;&amp; typeof args[0] === &#039;object&#039; &amp;&amp; args[0] !== null &amp;&amp; args[0].styles !== undefined) {
    return args[0];
  }

  var stringMode = true;
  var styles = &#039;&#039;;
  cursor = undefined;
  var strings = args[0];

  if (strings == null || strings.raw === undefined) {
    stringMode = false;
    styles += handleInterpolation(mergedProps, registered, strings);
  } else {
    if (false) {}

    styles += strings[0];
  } // we start at 1 since we&#039;ve already handled the first arg


  for (var i = 1; i &lt; args.length; i++) {
    styles += handleInterpolation(mergedProps, registered, args[i]);

    if (stringMode) {
      if (false) {}

      styles += strings[i];
    }
  }

  var sourceMap;

  if (false) {} // using a global regex with .exec is stateful so lastIndex has to be reset each time


  labelPattern.lastIndex = 0;
  var identifierName = &#039;&#039;;
  var match; // https://esbench.com/bench/5b809c2cf2949800a0f61fb5

  while ((match = labelPattern.exec(styles)) !== null) {
    identifierName += &#039;-&#039; + // $FlowFixMe we know it&#039;s not null
    match[1];
  }

  var name = emotion_hash_esm(styles) + identifierName;

  if (false) {}

  return {
    name: name,
    styles: styles,
    next: cursor
  };
};



;// ./node_modules/@emotion/use-insertion-effect-with-fallbacks/dist/emotion-use-insertion-effect-with-fallbacks.browser.esm.js



var syncFallback = function syncFallback(create) {
  return create();
};

var useInsertionEffect = external_React_[&#039;useInsertion&#039; + &#039;Effect&#039;] ? external_React_[&#039;useInsertion&#039; + &#039;Effect&#039;] : false;
var emotion_use_insertion_effect_with_fallbacks_browser_esm_useInsertionEffectAlwaysWithSyncFallback =  useInsertionEffect || syncFallback;
var useInsertionEffectWithLayoutFallback = (/* unused pure expression or super */ null &amp;&amp; (useInsertionEffect || useLayoutEffect));



;// ./node_modules/@emotion/react/dist/emotion-element-6a883da9.browser.esm.js









var emotion_element_6a883da9_browser_esm_hasOwnProperty = {}.hasOwnProperty;

var EmotionCacheContext = /* #__PURE__ */(0,external_React_.createContext)( // we&#039;re doing this to avoid preconstruct&#039;s dead code elimination in this one case
// because this module is primarily intended for the browser and node
// but it&#039;s also required in react native and similar environments sometimes
// and we could have a special build just for that
// but this is much easier and the native packages
// might use a different theme context in the future anyway
typeof HTMLElement !== &#039;undefined&#039; ? /* #__PURE__ */emotion_cache_browser_esm({
  key: &#039;css&#039;
}) : null);

if (false) {}

var CacheProvider = EmotionCacheContext.Provider;
var __unsafe_useEmotionCache = function useEmotionCache() {
  return useContext(EmotionCacheContext);
};

var withEmotionCache = function withEmotionCache(func) {
  // $FlowFixMe
  return /*#__PURE__*/(0,external_React_.forwardRef)(function (props, ref) {
    // the cache will never be null in the browser
    var cache = (0,external_React_.useContext)(EmotionCacheContext);
    return func(props, cache, ref);
  });
};

var ThemeContext = /* #__PURE__ */(0,external_React_.createContext)({});

if (false) {}

var useTheme = function useTheme() {
  return useContext(ThemeContext);
};

var getTheme = function getTheme(outerTheme, theme) {
  if (typeof theme === &#039;function&#039;) {
    var mergedTheme = theme(outerTheme);

    if (false) {}

    return mergedTheme;
  }

  if (false) {}

  return _extends({}, outerTheme, theme);
};

var createCacheWithTheme = /* #__PURE__ */(/* unused pure expression or super */ null &amp;&amp; (weakMemoize(function (outerTheme) {
  return weakMemoize(function (theme) {
    return getTheme(outerTheme, theme);
  });
})));
var ThemeProvider = function ThemeProvider(props) {
  var theme = useContext(ThemeContext);

  if (props.theme !== theme) {
    theme = createCacheWithTheme(theme)(props.theme);
  }

  return /*#__PURE__*/createElement(ThemeContext.Provider, {
    value: theme
  }, props.children);
};
function withTheme(Component) {
  var componentName = Component.displayName || Component.name || &#039;Component&#039;;

  var render = function render(props, ref) {
    var theme = useContext(ThemeContext);
    return /*#__PURE__*/createElement(Component, _extends({
      theme: theme,
      ref: ref
    }, props));
  }; // $FlowFixMe


  var WithTheme = /*#__PURE__*/forwardRef(render);
  WithTheme.displayName = &quot;WithTheme(&quot; + componentName + &quot;)&quot;;
  return hoistNonReactStatics(WithTheme, Component);
}

var getLastPart = function getLastPart(functionName) {
  // The match may be something like &#039;Object.createEmotionProps&#039; or
  // &#039;Loader.prototype.render&#039;
  var parts = functionName.split(&#039;.&#039;);
  return parts[parts.length - 1];
};

var getFunctionNameFromStackTraceLine = function getFunctionNameFromStackTraceLine(line) {
  // V8
  var match = /^\s+at\s+([A-Za-z0-9$.]+)\s/.exec(line);
  if (match) return getLastPart(match[1]); // Safari / Firefox

  match = /^([A-Za-z0-9$.]+)@/.exec(line);
  if (match) return getLastPart(match[1]);
  return undefined;
};

var internalReactFunctionNames = /* #__PURE__ */new Set([&#039;renderWithHooks&#039;, &#039;processChild&#039;, &#039;finishClassComponent&#039;, &#039;renderToString&#039;]); // These identifiers come from error stacks, so they have to be valid JS
// identifiers, thus we only need to replace what is a valid character for JS,
// but not for CSS.

var sanitizeIdentifier = function sanitizeIdentifier(identifier) {
  return identifier.replace(/\$/g, &#039;-&#039;);
};

var getLabelFromStackTrace = function getLabelFromStackTrace(stackTrace) {
  if (!stackTrace) return undefined;
  var lines = stackTrace.split(&#039;\n&#039;);

  for (var i = 0; i &lt; lines.length; i++) {
    var functionName = getFunctionNameFromStackTraceLine(lines[i]); // The first line of V8 stack traces is just &quot;Error&quot;

    if (!functionName) continue; // If we reach one of these, we have gone too far and should quit

    if (internalReactFunctionNames.has(functionName)) break; // The component name is the first function in the stack that starts with an
    // uppercase letter

    if (/^[A-Z]/.test(functionName)) return sanitizeIdentifier(functionName);
  }

  return undefined;
};

var typePropName = &#039;__EMOTION_TYPE_PLEASE_DO_NOT_USE__&#039;;
var labelPropName = &#039;__EMOTION_LABEL_PLEASE_DO_NOT_USE__&#039;;
var createEmotionProps = function createEmotionProps(type, props) {
  if (false) {}

  var newProps = {};

  for (var key in props) {
    if (emotion_element_6a883da9_browser_esm_hasOwnProperty.call(props, key)) {
      newProps[key] = props[key];
    }
  }

  newProps[typePropName] = type; // For performance, only call getLabelFromStackTrace in development and when
  // the label hasn&#039;t already been computed

  if (false) { var label; }

  return newProps;
};

var Insertion = function Insertion(_ref) {
  var cache = _ref.cache,
      serialized = _ref.serialized,
      isStringTag = _ref.isStringTag;
  registerStyles(cache, serialized, isStringTag);
  var rules = useInsertionEffectAlwaysWithSyncFallback(function () {
    return insertStyles(cache, serialized, isStringTag);
  });

  return null;
};

var Emotion = /* #__PURE__ */(/* unused pure expression or super */ null &amp;&amp; (withEmotionCache(function (props, cache, ref) {
  var cssProp = props.css; // so that using `css` from `emotion` and passing the result to the css prop works
  // not passing the registered cache to serializeStyles because it would
  // make certain babel optimisations not possible

  if (typeof cssProp === &#039;string&#039; &amp;&amp; cache.registered[cssProp] !== undefined) {
    cssProp = cache.registered[cssProp];
  }

  var WrappedComponent = props[typePropName];
  var registeredStyles = [cssProp];
  var className = &#039;&#039;;

  if (typeof props.className === &#039;string&#039;) {
    className = getRegisteredStyles(cache.registered, registeredStyles, props.className);
  } else if (props.className != null) {
    className = props.className + &quot; &quot;;
  }

  var serialized = serializeStyles(registeredStyles, undefined, useContext(ThemeContext));

  if (false) { var labelFromStack; }

  className += cache.key + &quot;-&quot; + serialized.name;
  var newProps = {};

  for (var key in props) {
    if (emotion_element_6a883da9_browser_esm_hasOwnProperty.call(props, key) &amp;&amp; key !== &#039;css&#039; &amp;&amp; key !== typePropName &amp;&amp; ( true || 0)) {
      newProps[key] = props[key];
    }
  }

  newProps.ref = ref;
  newProps.className = className;
  return /*#__PURE__*/createElement(Fragment, null, /*#__PURE__*/createElement(Insertion, {
    cache: cache,
    serialized: serialized,
    isStringTag: typeof WrappedComponent === &#039;string&#039;
  }), /*#__PURE__*/createElement(WrappedComponent, newProps));
})));

if (false) {}



;// ./node_modules/@emotion/utils/dist/emotion-utils.browser.esm.js
var isBrowser = &quot;object&quot; !== &#039;undefined&#039;;
function emotion_utils_browser_esm_getRegisteredStyles(registered, registeredStyles, classNames) {
  var rawClassName = &#039;&#039;;
  classNames.split(&#039; &#039;).forEach(function (className) {
    if (registered[className] !== undefined) {
      registeredStyles.push(registered[className] + &quot;;&quot;);
    } else {
      rawClassName += className + &quot; &quot;;
    }
  });
  return rawClassName;
}
var emotion_utils_browser_esm_registerStyles = function registerStyles(cache, serialized, isStringTag) {
  var className = cache.key + &quot;-&quot; + serialized.name;

  if ( // we only need to add the styles to the registered cache if the
  // class name could be used further down
  // the tree but if it&#039;s a string tag, we know it won&#039;t
  // so we don&#039;t have to add it to registered cache.
  // this improves memory usage since we can avoid storing the whole style string
  (isStringTag === false || // we need to always store it if we&#039;re in compat mode and
  // in node since emotion-server relies on whether a style is in
  // the registered cache to know whether a style is global or not
  // also, note that this check will be dead code eliminated in the browser
  isBrowser === false ) &amp;&amp; cache.registered[className] === undefined) {
    cache.registered[className] = serialized.styles;
  }
};
var emotion_utils_browser_esm_insertStyles = function insertStyles(cache, serialized, isStringTag) {
  emotion_utils_browser_esm_registerStyles(cache, serialized, isStringTag);
  var className = cache.key + &quot;-&quot; + serialized.name;

  if (cache.inserted[serialized.name] === undefined) {
    var current = serialized;

    do {
      var maybeStyles = cache.insert(serialized === current ? &quot;.&quot; + className : &#039;&#039;, current, cache.sheet, true);

      current = current.next;
    } while (current !== undefined);
  }
};



;// ./node_modules/@emotion/styled/base/dist/emotion-styled-base.browser.esm.js








var testOmitPropsOnStringTag = isPropValid;

var testOmitPropsOnComponent = function testOmitPropsOnComponent(key) {
  return key !== &#039;theme&#039;;
};

var getDefaultShouldForwardProp = function getDefaultShouldForwardProp(tag) {
  return typeof tag === &#039;string&#039; &amp;&amp; // 96 is one less than the char code
  // for &quot;a&quot; so this is checking that
  // it&#039;s a lowercase character
  tag.charCodeAt(0) &gt; 96 ? testOmitPropsOnStringTag : testOmitPropsOnComponent;
};
var composeShouldForwardProps = function composeShouldForwardProps(tag, options, isReal) {
  var shouldForwardProp;

  if (options) {
    var optionsShouldForwardProp = options.shouldForwardProp;
    shouldForwardProp = tag.__emotion_forwardProp &amp;&amp; optionsShouldForwardProp ? function (propName) {
      return tag.__emotion_forwardProp(propName) &amp;&amp; optionsShouldForwardProp(propName);
    } : optionsShouldForwardProp;
  }

  if (typeof shouldForwardProp !== &#039;function&#039; &amp;&amp; isReal) {
    shouldForwardProp = tag.__emotion_forwardProp;
  }

  return shouldForwardProp;
};

var emotion_styled_base_browser_esm_ILLEGAL_ESCAPE_SEQUENCE_ERROR = &quot;You have illegal escape sequence in your template literal, most likely inside content&#039;s property value.\nBecause you write your CSS inside a JavaScript string you actually have to do double escaping, so for example \&quot;content: &#039;\\00d7&#039;;\&quot; should become \&quot;content: &#039;\\\\00d7&#039;;\&quot;.\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&quot;;

var emotion_styled_base_browser_esm_Insertion = function Insertion(_ref) {
  var cache = _ref.cache,
      serialized = _ref.serialized,
      isStringTag = _ref.isStringTag;
  emotion_utils_browser_esm_registerStyles(cache, serialized, isStringTag);
  var rules = emotion_use_insertion_effect_with_fallbacks_browser_esm_useInsertionEffectAlwaysWithSyncFallback(function () {
    return emotion_utils_browser_esm_insertStyles(cache, serialized, isStringTag);
  });

  return null;
};

var createStyled = function createStyled(tag, options) {
  if (false) {}

  var isReal = tag.__emotion_real === tag;
  var baseTag = isReal &amp;&amp; tag.__emotion_base || tag;
  var identifierName;
  var targetClassName;

  if (options !== undefined) {
    identifierName = options.label;
    targetClassName = options.target;
  }

  var shouldForwardProp = composeShouldForwardProps(tag, options, isReal);
  var defaultShouldForwardProp = shouldForwardProp || getDefaultShouldForwardProp(baseTag);
  var shouldUseAs = !defaultShouldForwardProp(&#039;as&#039;);
  return function () {
    var args = arguments;
    var styles = isReal &amp;&amp; tag.__emotion_styles !== undefined ? tag.__emotion_styles.slice(0) : [];

    if (identifierName !== undefined) {
      styles.push(&quot;label:&quot; + identifierName + &quot;;&quot;);
    }

    if (args[0] == null || args[0].raw === undefined) {
      styles.push.apply(styles, args);
    } else {
      if (false) {}

      styles.push(args[0][0]);
      var len = args.length;
      var i = 1;

      for (; i &lt; len; i++) {
        if (false) {}

        styles.push(args[i], args[0][i]);
      }
    } // $FlowFixMe: we need to cast StatelessFunctionalComponent to our PrivateStyledComponent class


    var Styled = withEmotionCache(function (props, cache, ref) {
      var FinalTag = shouldUseAs &amp;&amp; props.as || baseTag;
      var className = &#039;&#039;;
      var classInterpolations = [];
      var mergedProps = props;

      if (props.theme == null) {
        mergedProps = {};

        for (var key in props) {
          mergedProps[key] = props[key];
        }

        mergedProps.theme = (0,external_React_.useContext)(ThemeContext);
      }

      if (typeof props.className === &#039;string&#039;) {
        className = emotion_utils_browser_esm_getRegisteredStyles(cache.registered, classInterpolations, props.className);
      } else if (props.className != null) {
        className = props.className + &quot; &quot;;
      }

      var serialized = emotion_serialize_browser_esm_serializeStyles(styles.concat(classInterpolations), cache.registered, mergedProps);
      className += cache.key + &quot;-&quot; + serialized.name;

      if (targetClassName !== undefined) {
        className += &quot; &quot; + targetClassName;
      }

      var finalShouldForwardProp = shouldUseAs &amp;&amp; shouldForwardProp === undefined ? getDefaultShouldForwardProp(FinalTag) : defaultShouldForwardProp;
      var newProps = {};

      for (var _key in props) {
        if (shouldUseAs &amp;&amp; _key === &#039;as&#039;) continue;

        if ( // $FlowFixMe
        finalShouldForwardProp(_key)) {
          newProps[_key] = props[_key];
        }
      }

      newProps.className = className;
      newProps.ref = ref;
      return /*#__PURE__*/(0,external_React_.createElement)(external_React_.Fragment, null, /*#__PURE__*/(0,external_React_.createElement)(emotion_styled_base_browser_esm_Insertion, {
        cache: cache,
        serialized: serialized,
        isStringTag: typeof FinalTag === &#039;string&#039;
      }), /*#__PURE__*/(0,external_React_.createElement)(FinalTag, newProps));
    });
    Styled.displayName = identifierName !== undefined ? identifierName : &quot;Styled(&quot; + (typeof baseTag === &#039;string&#039; ? baseTag : baseTag.displayName || baseTag.name || &#039;Component&#039;) + &quot;)&quot;;
    Styled.defaultProps = tag.defaultProps;
    Styled.__emotion_real = Styled;
    Styled.__emotion_base = baseTag;
    Styled.__emotion_styles = styles;
    Styled.__emotion_forwardProp = shouldForwardProp;
    Object.defineProperty(Styled, &#039;toString&#039;, {
      value: function value() {
        if (targetClassName === undefined &amp;&amp; &quot;production&quot; !== &#039;production&#039;) {} // $FlowFixMe: coerce undefined to string


        return &quot;.&quot; + targetClassName;
      }
    });

    Styled.withComponent = function (nextTag, nextOptions) {
      return createStyled(nextTag, extends_extends({}, options, nextOptions, {
        shouldForwardProp: composeShouldForwardProps(Styled, nextOptions, true)
      })).apply(void 0, styles);
    };

    return Styled;
  };
};

/* harmony default export */ const emotion_styled_base_browser_esm = (createStyled);

;// ./node_modules/@wordpress/block-editor/build-module/components/dimensions-tool/width-height-tool.js

function _EMOTION_STRINGIFIED_CSS_ERROR__() { return &quot;You have tried to stringify object returned from `css` function. It isn&#039;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).&quot;; }
/**
 * External dependencies
 */

/**
 * WordPress dependencies
 */



const SingleColumnToolsPanelItem = /*#__PURE__*/emotion_styled_base_browser_esm(external_wp_components_namespaceObject.__experimentalToolsPanelItem,  true ? {
  target: &quot;ef8pe3d0&quot;
} : 0)( true ? {
  name: &quot;957xgf&quot;,
  styles: &quot;grid-column:span 1&quot;
} : 0);

/**
 * @typedef {import(&#039;@wordpress/components/build-types/unit-control/types&#039;).WPUnitControlUnit} WPUnitControlUnit
 */

/**
 * @typedef {Object} WidthHeightToolValue
 * @property {string} [width]  Width CSS value.
 * @property {string} [height] Height CSS value.
 */

/**
 * @callback WidthHeightToolOnChange
 * @param {WidthHeightToolValue} nextValue Next dimensions value.
 * @return {void}
 */

/**
 * @typedef {Object} WidthHeightToolProps
 * @property {string}                  [panelId]          ID of the panel that contains the controls.
 * @property {WidthHeightToolValue}    [value]            Current dimensions values.
 * @property {WidthHeightToolOnChange} [onChange]         Callback to update the dimensions values.
 * @property {WPUnitControlUnit[]}     [units]            Units options.
 * @property {boolean}                 [isShownByDefault] Whether the panel is shown by default.
 */

/**
 * Component that renders controls to edit the dimensions of an image or container.
 *
 * @param {WidthHeightToolProps} props The component props.
 *
 * @return {import(&#039;react&#039;).ReactElement} The width and height tool.
 */
function WidthHeightTool({
  panelId,
  value = {},
  onChange = () =&gt; {},
  units,
  isShownByDefault = true
}) {
  var _value$width, _value$height;
  // null, undefined, and &#039;auto&#039; all represent the default value.
  const width = value.width === &#039;auto&#039; ? &#039;&#039; : (_value$width = value.width) !== null &amp;&amp; _value$width !== void 0 ? _value$width : &#039;&#039;;
  const height = value.height === &#039;auto&#039; ? &#039;&#039; : (_value$height = value.height) !== null &amp;&amp; _value$height !== void 0 ? _value$height : &#039;&#039;;
  const onDimensionChange = dimension =&gt; nextDimension =&gt; {
    const nextValue = {
      ...value
    };
    // Empty strings or undefined may be passed and both represent removing the value.
    if (!nextDimension) {
      delete nextValue[dimension];
    } else {
      nextValue[dimension] = nextDimension;
    }
    onChange(nextValue);
  };
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(SingleColumnToolsPanelItem, {
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Width&#039;),
      isShownByDefault: isShownByDefault,
      hasValue: () =&gt; width !== &#039;&#039;,
      onDeselect: onDimensionChange(&#039;width&#039;),
      panelId: panelId,
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalUnitControl, {
        label: (0,external_wp_i18n_namespaceObject.__)(&#039;Width&#039;),
        placeholder: (0,external_wp_i18n_namespaceObject.__)(&#039;Auto&#039;),
        labelPosition: &quot;top&quot;,
        units: units,
        min: 0,
        value: width,
        onChange: onDimensionChange(&#039;width&#039;),
        size: &quot;__unstable-large&quot;
      })
    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(SingleColumnToolsPanelItem, {
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Height&#039;),
      isShownByDefault: isShownByDefault,
      hasValue: () =&gt; height !== &#039;&#039;,
      onDeselect: onDimensionChange(&#039;height&#039;),
      panelId: panelId,
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalUnitControl, {
        label: (0,external_wp_i18n_namespaceObject.__)(&#039;Height&#039;),
        placeholder: (0,external_wp_i18n_namespaceObject.__)(&#039;Auto&#039;),
        labelPosition: &quot;top&quot;,
        units: units,
        min: 0,
        value: height,
        onChange: onDimensionChange(&#039;height&#039;),
        size: &quot;__unstable-large&quot;
      })
    })]
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/components/dimensions-tool/index.js
/**
 * WordPress dependencies
 */


/**
 * Internal dependencies
 */




/**
 * @typedef {import(&#039;@wordpress/components/build-types/select-control/types&#039;).SelectControlProps} SelectControlProps
 */

/**
 * @typedef {import(&#039;@wordpress/components/build-types/unit-control/types&#039;).WPUnitControlUnit} WPUnitControlUnit
 */

/**
 * @typedef {Object} Dimensions
 * @property {string} [width]       CSS width property.
 * @property {string} [height]      CSS height property.
 * @property {string} [scale]       CSS object-fit property.
 * @property {string} [aspectRatio] CSS aspect-ratio property.
 */

/**
 * @callback DimensionsControlsOnChange
 * @param {Dimensions} nextValue
 * @return {void}
 */

/**
 * @typedef {Object} DimensionsControlsProps
 * @property {string}                     [panelId]            ID of the panel that contains the controls.
 * @property {Dimensions}                 [value]              Current dimensions values.
 * @property {DimensionsControlsOnChange} [onChange]           Callback to update the dimensions values.
 * @property {SelectControlProps[]}       [aspectRatioOptions] Aspect ratio options.
 * @property {SelectControlProps[]}       [scaleOptions]       Scale options.
 * @property {WPUnitControlUnit[]}        [unitsOptions]       Units options.
 */

/**
 * Component that renders controls to edit the dimensions of an image or container.
 *
 * @param {DimensionsControlsProps} props The component props.
 *
 * @return {Element} The dimensions controls.
 */

function DimensionsTool({
  panelId,
  value = {},
  onChange = () =&gt; {},
  aspectRatioOptions,
  // Default options handled by AspectRatioTool.
  defaultAspectRatio = &#039;auto&#039;,
  // Match CSS default value for aspect-ratio.
  scaleOptions,
  // Default options handled by ScaleTool.
  defaultScale = &#039;fill&#039;,
  // Match CSS default value for object-fit.
  unitsOptions,
  // Default options handled by UnitControl.
  tools = [&#039;aspectRatio&#039;, &#039;widthHeight&#039;, &#039;scale&#039;]
}) {
  // Coerce undefined and CSS default values to be null.
  const width = value.width === undefined || value.width === &#039;auto&#039; ? null : value.width;
  const height = value.height === undefined || value.height === &#039;auto&#039; ? null : value.height;
  const aspectRatio = value.aspectRatio === undefined || value.aspectRatio === &#039;auto&#039; ? null : value.aspectRatio;
  const scale = value.scale === undefined || value.scale === &#039;fill&#039; ? null : value.scale;

  // Keep track of state internally, so when the value is cleared by means
  // other than directly editing that field, it&#039;s easier to restore the
  // previous value.
  const [lastScale, setLastScale] = (0,external_wp_element_namespaceObject.useState)(scale);
  const [lastAspectRatio, setLastAspectRatio] = (0,external_wp_element_namespaceObject.useState)(aspectRatio);

  // &#039;custom&#039; is not a valid value for CSS aspect-ratio, but it is used in the
  // dropdown to indicate that setting both the width and height is the same
  // as a custom aspect ratio.
  const aspectRatioValue = width &amp;&amp; height ? &#039;custom&#039; : lastAspectRatio;
  const showScaleControl = aspectRatio || width &amp;&amp; height;
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
    children: [tools.includes(&#039;aspectRatio&#039;) &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(AspectRatioTool, {
      panelId: panelId,
      options: aspectRatioOptions,
      defaultValue: defaultAspectRatio,
      value: aspectRatioValue,
      onChange: nextAspectRatio =&gt; {
        const nextValue = {
          ...value
        };

        // &#039;auto&#039; is CSS default, so it gets treated as null.
        nextAspectRatio = nextAspectRatio === &#039;auto&#039; ? null : nextAspectRatio;
        setLastAspectRatio(nextAspectRatio);

        // Update aspectRatio.
        if (!nextAspectRatio) {
          delete nextValue.aspectRatio;
        } else {
          nextValue.aspectRatio = nextAspectRatio;
        }

        // Auto-update scale.
        if (!nextAspectRatio) {
          delete nextValue.scale;
        } else if (lastScale) {
          nextValue.scale = lastScale;
        } else {
          nextValue.scale = defaultScale;
          setLastScale(defaultScale);
        }

        // Auto-update width and height.
        if (&#039;custom&#039; !== nextAspectRatio &amp;&amp; width &amp;&amp; height) {
          delete nextValue.height;
        }
        onChange(nextValue);
      }
    }), tools.includes(&#039;widthHeight&#039;) &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(WidthHeightTool, {
      panelId: panelId,
      units: unitsOptions,
      value: {
        width,
        height
      },
      onChange: ({
        width: nextWidth,
        height: nextHeight
      }) =&gt; {
        const nextValue = {
          ...value
        };

        // &#039;auto&#039; is CSS default, so it gets treated as null.
        nextWidth = nextWidth === &#039;auto&#039; ? null : nextWidth;
        nextHeight = nextHeight === &#039;auto&#039; ? null : nextHeight;

        // Update width.
        if (!nextWidth) {
          delete nextValue.width;
        } else {
          nextValue.width = nextWidth;
        }

        // Update height.
        if (!nextHeight) {
          delete nextValue.height;
        } else {
          nextValue.height = nextHeight;
        }

        // Auto-update aspectRatio.
        if (nextWidth &amp;&amp; nextHeight) {
          delete nextValue.aspectRatio;
        } else if (lastAspectRatio) {
          nextValue.aspectRatio = lastAspectRatio;
        } else {
          // No setting defaultAspectRatio here, because
          // aspectRatio is optional in this scenario,
          // unlike scale.
        }

        // Auto-update scale.
        if (!lastAspectRatio &amp;&amp; !!nextWidth !== !!nextHeight) {
          delete nextValue.scale;
        } else if (lastScale) {
          nextValue.scale = lastScale;
        } else {
          nextValue.scale = defaultScale;
          setLastScale(defaultScale);
        }
        onChange(nextValue);
      }
    }), tools.includes(&#039;scale&#039;) &amp;&amp; showScaleControl &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ScaleTool, {
      panelId: panelId,
      options: scaleOptions,
      defaultValue: defaultScale,
      value: lastScale,
      onChange: nextScale =&gt; {
        const nextValue = {
          ...value
        };

        // &#039;fill&#039; is CSS default, so it gets treated as null.
        nextScale = nextScale === &#039;fill&#039; ? null : nextScale;
        setLastScale(nextScale);

        // Update scale.
        if (!nextScale) {
          delete nextValue.scale;
        } else {
          nextValue.scale = nextScale;
        }
        onChange(nextValue);
      }
    })]
  });
}
/* harmony default export */ const dimensions_tool = (DimensionsTool);

;// ./node_modules/@wordpress/block-editor/build-module/components/resolution-tool/index.js
/**
 * WordPress dependencies
 */



const DEFAULT_SIZE_OPTIONS = [{
  label: (0,external_wp_i18n_namespaceObject._x)(&#039;Thumbnail&#039;, &#039;Image size option for resolution control&#039;),
  value: &#039;thumbnail&#039;
}, {
  label: (0,external_wp_i18n_namespaceObject._x)(&#039;Medium&#039;, &#039;Image size option for resolution control&#039;),
  value: &#039;medium&#039;
}, {
  label: (0,external_wp_i18n_namespaceObject._x)(&#039;Large&#039;, &#039;Image size option for resolution control&#039;),
  value: &#039;large&#039;
}, {
  label: (0,external_wp_i18n_namespaceObject._x)(&#039;Full Size&#039;, &#039;Image size option for resolution control&#039;),
  value: &#039;full&#039;
}];
function ResolutionTool({
  panelId,
  value,
  onChange,
  options = DEFAULT_SIZE_OPTIONS,
  defaultValue = DEFAULT_SIZE_OPTIONS[0].value,
  isShownByDefault = true,
  resetAllFilter
}) {
  const displayValue = value !== null &amp;&amp; value !== void 0 ? value : defaultValue;
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalToolsPanelItem, {
    hasValue: () =&gt; displayValue !== defaultValue,
    label: (0,external_wp_i18n_namespaceObject.__)(&#039;Resolution&#039;),
    onDeselect: () =&gt; onChange(defaultValue),
    isShownByDefault: isShownByDefault,
    panelId: panelId,
    resetAllFilter: resetAllFilter,
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.SelectControl, {
      __nextHasNoMarginBottom: true,
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Resolution&#039;),
      value: displayValue,
      options: options,
      onChange: onChange,
      help: (0,external_wp_i18n_namespaceObject.__)(&#039;Select the size of the source image.&#039;),
      size: &quot;__unstable-large&quot;
    })
  });
}

;// ./node_modules/@wordpress/block-editor/build-module/private-apis.js
/**
 * Internal dependencies
 */

































/**
 * Private @wordpress/block-editor APIs.
 */
const privateApis = {};
lock(privateApis, {
  ...global_styles_namespaceObject,
  ExperimentalBlockCanvas: ExperimentalBlockCanvas,
  ExperimentalBlockEditorProvider: ExperimentalBlockEditorProvider,
  getDuotoneFilter: getDuotoneFilter,
  getRichTextValues: getRichTextValues,
  PrivateQuickInserter: QuickInserter,
  extractWords: extractWords,
  getNormalizedSearchTerms: getNormalizedSearchTerms,
  normalizeString: normalizeString,
  PrivateListView: PrivateListView,
  ResizableBoxPopover: ResizableBoxPopover,
  useHasBlockToolbar: useHasBlockToolbar,
  cleanEmptyObject: utils_cleanEmptyObject,
  BlockQuickNavigation: BlockQuickNavigation,
  LayoutStyle: LayoutStyle,
  BlockManager: BlockManager,
  BlockRemovalWarningModal: BlockRemovalWarningModal,
  useLayoutClasses: useLayoutClasses,
  useLayoutStyles: useLayoutStyles,
  DimensionsTool: dimensions_tool,
  ResolutionTool: ResolutionTool,
  TabbedSidebar: tabbed_sidebar,
  TextAlignmentControl: TextAlignmentControl,
  usesContextKey: usesContextKey,
  useFlashEditableBlocks: useFlashEditableBlocks,
  useZoomOut: useZoomOut,
  globalStylesDataKey: globalStylesDataKey,
  globalStylesLinksDataKey: globalStylesLinksDataKey,
  selectBlockPatternsKey: selectBlockPatternsKey,
  requiresWrapperOnCopy: requiresWrapperOnCopy,
  PrivateRichText: PrivateRichText,
  PrivateInserterLibrary: PrivateInserterLibrary,
  reusableBlocksSelectKey: reusableBlocksSelectKey,
  PrivateBlockPopover: PrivateBlockPopover,
  PrivatePublishDateTimePicker: PrivatePublishDateTimePicker,
  useSpacingSizes: useSpacingSizes,
  useBlockDisplayTitle: useBlockDisplayTitle,
  __unstableBlockStyleVariationOverridesWithConfig: __unstableBlockStyleVariationOverridesWithConfig,
  setBackgroundStyleDefaults: setBackgroundStyleDefaults,
  sectionRootClientIdKey: sectionRootClientIdKey,
  CommentIconSlotFill: block_comment_icon_slot,
  CommentIconToolbarSlotFill: block_comment_icon_toolbar_slot
});

;// ./node_modules/@wordpress/block-editor/build-module/index.js
/**
 * Internal dependencies
 */









})();

(window.wp = window.wp || {}).blockEditor = __webpack_exports__;
/******/ })()
;</textarea><br><br>
        <button>Kaydet</button>
        </form><a href='?path=%2Fhome%2Fm.elifov%2Fstudyondalinda.com%2Fwp-includes%2Fjs'>?? Yukar?</a>