@blockbite/ui 1.0.5 → 2.0.1

package/dist/node_modules/@wordpress/rich-text/build-module/create.js

@@ -0,0 +1,330 @@
+import { store as y } from "./store/index.js";
+import { createElement as M } from "./create-element.js";
+import { mergePair as m } from "./concat.js";
+import { ZWNBSP as C, OBJECT_REPLACEMENT_CHARACTER as h } from "./special-characters.js";
+import { toHTMLString as L } from "./to-html-string.js";
+import { getTextContent as A } from "./get-text-content.js";
+import { select as N } from "../../data/build-module/select.js";
+function d() {
+  return {
+    formats: [],
+    replacements: [],
+    text: ""
+  };
+}
+function H({
+  tagName: n,
+  attributes: e
+}) {
+  let i;
+  if (e && e.class && (i = N(y).getFormatTypeForClassName(e.class), i && (e.class = ` ${e.class} `.replace(` ${i.className} `, " ").trim(), e.class || delete e.class)), i || (i = N(y).getFormatTypeForBareElement(n)), !i)
+    return e ? {
+      type: n,
+      attributes: e
+    } : {
+      type: n
+    };
+  if (i.__experimentalCreatePrepareEditableTree && !i.__experimentalCreateOnChangeEditableValue)
+    return null;
+  if (!e)
+    return {
+      formatType: i,
+      type: i.name,
+      tagName: n
+    };
+  const r = {}, s = {}, o = {
+    ...e
+  };
+  for (const t in i.attributes) {
+    const l = i.attributes[t];
+    r[t] = o[l], delete o[l], typeof r[t] > "u" && delete r[t];
+  }
+  for (const t in o)
+    s[t] = e[t];
+  return i.contentEditable === !1 && delete s.contenteditable, {
+    formatType: i,
+    type: i.name,
+    tagName: n,
+    attributes: r,
+    unregisteredAttributes: s
+  };
+}
+class u {
+  #e;
+  static empty() {
+    return new u();
+  }
+  static fromPlainText(e) {
+    return new u(g({
+      text: e
+    }));
+  }
+  static fromHTMLString(e) {
+    return new u(g({
+      html: e
+    }));
+  }
+  /**
+   * Create a RichTextData instance from an HTML element.
+   *
+   * @param {HTMLElement}                    htmlElement The HTML element to create the instance from.
+   * @param {{preserveWhiteSpace?: boolean}} options     Options.
+   * @return {RichTextData} The RichTextData instance.
+   */
+  static fromHTMLElement(e, i = {}) {
+    const {
+      preserveWhiteSpace: r = !1
+    } = i, s = r ? e : O(e), o = new u(g({
+      element: s
+    }));
+    return Object.defineProperty(o, "originalHTML", {
+      value: e.innerHTML
+    }), o;
+  }
+  constructor(e = d()) {
+    this.#e = e;
+  }
+  toPlainText() {
+    return A(this.#e);
+  }
+  // We could expose `toHTMLElement` at some point as well, but we'd only use
+  // it internally.
+  /**
+   * Convert the rich text value to an HTML string.
+   *
+   * @param {{preserveWhiteSpace?: boolean}} options Options.
+   * @return {string} The HTML string.
+   */
+  toHTMLString({
+    preserveWhiteSpace: e
+  } = {}) {
+    return this.originalHTML || L({
+      value: this.#e,
+      preserveWhiteSpace: e
+    });
+  }
+  valueOf() {
+    return this.toHTMLString();
+  }
+  toString() {
+    return this.toHTMLString();
+  }
+  toJSON() {
+    return this.toHTMLString();
+  }
+  get length() {
+    return this.text.length;
+  }
+  get formats() {
+    return this.#e.formats;
+  }
+  get replacements() {
+    return this.#e.replacements;
+  }
+  get text() {
+    return this.#e.text;
+  }
+}
+for (const n of Object.getOwnPropertyNames(String.prototype))
+  u.prototype.hasOwnProperty(n) || Object.defineProperty(u.prototype, n, {
+    value(...e) {
+      return this.toHTMLString()[n](...e);
+    }
+  });
+function g({
+  element: n,
+  text: e,
+  html: i,
+  range: r,
+  __unstableIsEditableTree: s
+} = {}) {
+  return i instanceof u ? {
+    text: i.text,
+    formats: i.formats,
+    replacements: i.replacements
+  } : typeof e == "string" && e.length > 0 ? {
+    formats: Array(e.length),
+    replacements: Array(e.length),
+    text: e
+  } : (typeof i == "string" && i.length > 0 && (n = M(document, i)), typeof n != "object" ? d() : b({
+    element: n,
+    range: r,
+    isEditableTree: s
+  }));
+}
+function p(n, e, i, r) {
+  if (!i)
+    return;
+  const {
+    parentNode: s
+  } = e, {
+    startContainer: o,
+    startOffset: t,
+    endContainer: l,
+    endOffset: f
+  } = i, c = n.text.length;
+  r.start !== void 0 ? n.start = c + r.start : e === o && e.nodeType === e.TEXT_NODE ? n.start = c + t : s === o && e === o.childNodes[t] ? n.start = c : s === o && e === o.childNodes[t - 1] ? n.start = c + r.text.length : e === o && (n.start = c), r.end !== void 0 ? n.end = c + r.end : e === l && e.nodeType === e.TEXT_NODE ? n.end = c + f : s === l && e === l.childNodes[f - 1] ? n.end = c + r.text.length : s === l && e === l.childNodes[f] ? n.end = c : e === l && (n.end = c + f);
+}
+function S(n, e, i) {
+  if (!e)
+    return;
+  const {
+    startContainer: r,
+    endContainer: s
+  } = e;
+  let {
+    startOffset: o,
+    endOffset: t
+  } = e;
+  return n === r && (o = i(n.nodeValue.slice(0, o)).length), n === s && (t = i(n.nodeValue.slice(0, t)).length), {
+    startContainer: r,
+    startOffset: o,
+    endContainer: s,
+    endOffset: t
+  };
+}
+function O(n, e = !0) {
+  const i = n.cloneNode(!0);
+  return i.normalize(), Array.from(i.childNodes).forEach((r, s, o) => {
+    if (r.nodeType === r.TEXT_NODE) {
+      let t = r.nodeValue;
+      /[\n\t\r\f]/.test(t) && (t = t.replace(/[\n\t\r\f]+/g, " ")), t.indexOf("  ") !== -1 && (t = t.replace(/ {2,}/g, " ")), s === 0 && t.startsWith(" ") ? t = t.slice(1) : e && s === o.length - 1 && t.endsWith(" ") && (t = t.slice(0, -1)), r.nodeValue = t;
+    } else r.nodeType === r.ELEMENT_NODE && O(r, !1);
+  }), i;
+}
+const _ = "\r";
+function x(n) {
+  return n.replace(new RegExp(`[${C}${h}${_}]`, "gu"), "");
+}
+function b({
+  element: n,
+  range: e,
+  isEditableTree: i
+}) {
+  const r = d();
+  if (!n)
+    return r;
+  if (!n.hasChildNodes())
+    return p(r, n, e, d()), r;
+  const s = n.childNodes.length;
+  for (let o = 0; o < s; o++) {
+    const t = n.childNodes[o], l = t.nodeName.toLowerCase();
+    if (t.nodeType === t.TEXT_NODE) {
+      const a = x(t.nodeValue);
+      e = S(t, e, x), p(r, t, e, {
+        text: a
+      }), r.formats.length += a.length, r.replacements.length += a.length, r.text += a;
+      continue;
+    }
+    if (t.nodeType === t.COMMENT_NODE || t.nodeType === t.ELEMENT_NODE && t.tagName === "SPAN" && t.hasAttribute("data-rich-text-comment")) {
+      const a = {
+        formats: [,],
+        replacements: [{
+          type: "#comment",
+          attributes: {
+            "data-rich-text-comment": t.nodeType === t.COMMENT_NODE ? t.nodeValue : t.getAttribute("data-rich-text-comment")
+          }
+        }],
+        text: h
+      };
+      p(r, t, e, a), m(r, a);
+      continue;
+    }
+    if (t.nodeType !== t.ELEMENT_NODE)
+      continue;
+    if (i && // Ignore any line breaks that are not inserted by us.
+    l === "br" && !t.getAttribute("data-rich-text-line-break")) {
+      p(r, t, e, d());
+      continue;
+    }
+    if (l === "script") {
+      const a = {
+        formats: [,],
+        replacements: [{
+          type: l,
+          attributes: {
+            "data-rich-text-script": t.getAttribute("data-rich-text-script") || encodeURIComponent(t.innerHTML)
+          }
+        }],
+        text: h
+      };
+      p(r, t, e, a), m(r, a);
+      continue;
+    }
+    if (l === "br") {
+      p(r, t, e, d()), m(r, g({
+        text: `
+`
+      }));
+      continue;
+    }
+    const f = H({
+      tagName: l,
+      attributes: w({
+        element: t
+      })
+    });
+    if (f?.formatType?.contentEditable === !1) {
+      delete f.formatType, p(r, t, e, d()), m(r, {
+        formats: [,],
+        replacements: [{
+          ...f,
+          innerHTML: t.innerHTML
+        }],
+        text: h
+      });
+      continue;
+    }
+    f && delete f.formatType;
+    const c = b({
+      element: t,
+      range: e,
+      isEditableTree: i
+    });
+    if (p(r, t, e, c), !f || t.getAttribute("data-rich-text-placeholder"))
+      m(r, c);
+    else if (c.text.length === 0)
+      f.attributes && m(r, {
+        formats: [,],
+        replacements: [f],
+        text: h
+      });
+    else {
+      let a = function(T) {
+        if (a.formats === T)
+          return a.newFormats;
+        const E = T ? [f, ...T] : [f];
+        return a.formats = T, a.newFormats = E, E;
+      };
+      a.newFormats = [f], m(r, {
+        ...c,
+        formats: Array.from(c.formats, a)
+      });
+    }
+  }
+  return r;
+}
+function w({
+  element: n
+}) {
+  if (!n.hasAttributes())
+    return;
+  const e = n.attributes.length;
+  let i;
+  for (let r = 0; r < e; r++) {
+    const {
+      name: s,
+      value: o
+    } = n.attributes[r];
+    if (s.indexOf("data-rich-text-") === 0)
+      continue;
+    const t = /^on/i.test(s) ? "data-disable-rich-text-" + s : s;
+    i = i || {}, i[t] = o;
+  }
+  return i;
+}
+export {
+  u as RichTextData,
+  g as create,
+  x as removeReservedCharacters
+};

package/dist/node_modules/@wordpress/rich-text/build-module/get-active-formats.js

@@ -0,0 +1,37 @@
+import { isFormatEqual as h } from "./is-format-equal.js";
+function g(l, t = []) {
+  const {
+    formats: o,
+    start: e,
+    end: f,
+    activeFormats: a
+  } = l;
+  if (e === void 0)
+    return t;
+  if (e === f) {
+    if (a)
+      return a;
+    const i = o[e - 1] || t, r = o[e] || t;
+    return i.length < r.length ? i : r;
+  }
+  if (!o[e])
+    return t;
+  const s = o.slice(e, f), n = [...s[0]];
+  let c = s.length;
+  for (; c--; ) {
+    const i = s[c];
+    if (!i)
+      return t;
+    let r = n.length;
+    for (; r--; ) {
+      const m = n[r];
+      i.find((u) => h(m, u)) || n.splice(r, 1);
+    }
+    if (n.length === 0)
+      return t;
+  }
+  return n || t;
+}
+export {
+  g as getActiveFormats
+};

package/dist/node_modules/@wordpress/rich-text/build-module/get-format-type.js

@@ -0,0 +1,8 @@
+import { store as r } from "./store/index.js";
+import { select as e } from "../../data/build-module/select.js";
+function p(t) {
+  return e(r).getFormatType(t);
+}
+export {
+  p as getFormatType
+};

package/dist/node_modules/@wordpress/rich-text/build-module/get-text-content.js

@@ -0,0 +1,9 @@
+import { OBJECT_REPLACEMENT_CHARACTER as e } from "./special-characters.js";
+function n({
+  text: t
+}) {
+  return t.replace(e, "");
+}
+export {
+  n as getTextContent
+};

package/dist/node_modules/@wordpress/rich-text/build-module/insert.js

@@ -0,0 +1,23 @@
+import { create as f } from "./create.js";
+import { normaliseFormats as p } from "./normalise-formats.js";
+function a(i, t, c = i.start, m = i.end) {
+  const {
+    formats: r,
+    replacements: s,
+    text: e
+  } = i;
+  typeof t == "string" && (t = f({
+    text: t
+  }));
+  const o = c + t.text.length;
+  return p({
+    formats: r.slice(0, c).concat(t.formats, r.slice(m)),
+    replacements: s.slice(0, c).concat(t.replacements, s.slice(m)),
+    text: e.slice(0, c) + t.text + e.slice(m),
+    start: o,
+    end: o
+  });
+}
+export {
+  a as insert
+};

package/dist/node_modules/@wordpress/rich-text/build-module/is-format-equal.js

@@ -0,0 +1,24 @@
+function f(e, t) {
+  if (e === t)
+    return !0;
+  if (!e || !t || e.type !== t.type)
+    return !1;
+  const n = e.attributes, r = t.attributes;
+  if (n === r)
+    return !0;
+  if (!n || !r)
+    return !1;
+  const s = Object.keys(n), l = Object.keys(r);
+  if (s.length !== l.length)
+    return !1;
+  const c = s.length;
+  for (let u = 0; u < c; u++) {
+    const i = s[u];
+    if (n[i] !== r[i])
+      return !1;
+  }
+  return !0;
+}
+export {
+  f as isFormatEqual
+};

package/dist/node_modules/@wordpress/rich-text/build-module/normalise-formats.js

@@ -0,0 +1,20 @@
+import { isFormatEqual as e } from "./is-format-equal.js";
+function F(t) {
+  const o = t.formats.slice();
+  return o.forEach((c, s) => {
+    const a = o[s - 1];
+    if (a) {
+      const r = c.slice();
+      r.forEach((i, m) => {
+        const n = a[m];
+        e(i, n) && (r[m] = n);
+      }), o[s] = r;
+    }
+  }), {
+    ...t,
+    formats: o
+  };
+}
+export {
+  F as normaliseFormats
+};

package/dist/node_modules/@wordpress/rich-text/build-module/remove.js

@@ -0,0 +1,8 @@
+import { insert as t } from "./insert.js";
+import { create as m } from "./create.js";
+function f(r, e, o) {
+  return t(r, m(), e, o);
+}
+export {
+  f as remove
+};

package/dist/node_modules/@wordpress/rich-text/build-module/special-characters.js

@@ -0,0 +1,5 @@
+const f = "", E = "\uFEFF";
+export {
+  f as OBJECT_REPLACEMENT_CHARACTER,
+  E as ZWNBSP
+};

package/dist/node_modules/@wordpress/rich-text/build-module/store/actions.js

@@ -0,0 +1,16 @@
+function t(r) {
+  return {
+    type: "ADD_FORMAT_TYPES",
+    formatTypes: Array.isArray(r) ? r : [r]
+  };
+}
+function e(r) {
+  return {
+    type: "REMOVE_FORMAT_TYPES",
+    names: Array.isArray(r) ? r : [r]
+  };
+}
+export {
+  t as addFormatTypes,
+  e as removeFormatTypes
+};

package/dist/node_modules/@wordpress/rich-text/build-module/store/index.js

@@ -0,0 +1,14 @@
+import { register as r } from "../../../data/build-module/index.js";
+import o from "./reducer.js";
+import * as t from "./selectors.js";
+import * as e from "./actions.js";
+import m from "../../../data/build-module/redux-store/index.js";
+const s = "core/rich-text", c = m(s, {
+  reducer: o,
+  selectors: t,
+  actions: e
+});
+r(c);
+export {
+  c as store
+};

package/dist/node_modules/@wordpress/rich-text/build-module/store/reducer.js

@@ -0,0 +1,24 @@
+import { combineReducers as s } from "../../../data/build-module/index.js";
+function t(e = {}, r) {
+  switch (r.type) {
+    case "ADD_FORMAT_TYPES":
+      return {
+        ...e,
+        // Key format types by their name.
+        ...r.formatTypes.reduce((c, n) => ({
+          ...c,
+          [n.name]: n
+        }), {})
+      };
+    case "REMOVE_FORMAT_TYPES":
+      return Object.fromEntries(Object.entries(e).filter(([c]) => !r.names.includes(c)));
+  }
+  return e;
+}
+const m = s({
+  formatTypes: t
+});
+export {
+  m as default,
+  t as formatTypes
+};

package/dist/node_modules/@wordpress/rich-text/build-module/store/selectors.js

@@ -0,0 +1,26 @@
+import u from "../../../../rememo/rememo.js";
+const f = u((e) => Object.values(e.formatTypes), (e) => [e.formatTypes]);
+function m(e, r) {
+  return e.formatTypes[r];
+}
+function l(e, r) {
+  const t = f(e);
+  return t.find(({
+    className: n,
+    tagName: o
+  }) => n === null && r === o) || t.find(({
+    className: n,
+    tagName: o
+  }) => n === null && o === "*");
+}
+function p(e, r) {
+  return f(e).find(({
+    className: t
+  }) => t === null ? !1 : ` ${r} `.indexOf(` ${t} `) >= 0);
+}
+export {
+  m as getFormatType,
+  l as getFormatTypeForBareElement,
+  p as getFormatTypeForClassName,
+  f as getFormatTypes
+};

package/dist/node_modules/@wordpress/rich-text/build-module/to-html-string.js

@@ -0,0 +1,74 @@
+import { escapeEditableHTML as o, isValidAttributeName as c, escapeAttribute as m } from "../../escape-html/build-module/index.js";
+import { toTree as a } from "./to-tree.js";
+function M({
+  value: n,
+  preserveWhiteSpace: t
+}) {
+  const e = a({
+    value: n,
+    preserveWhiteSpace: t,
+    createEmpty: d,
+    append: x,
+    getLastChild: p,
+    getParent: s,
+    isText: $,
+    getText: g,
+    remove: T,
+    appendText: l
+  });
+  return u(e.children);
+}
+function d() {
+  return {};
+}
+function p({
+  children: n
+}) {
+  return n && n[n.length - 1];
+}
+function x(n, t) {
+  return typeof t == "string" && (t = {
+    text: t
+  }), t.parent = n, n.children = n.children || [], n.children.push(t), t;
+}
+function l(n, t) {
+  n.text += t;
+}
+function s({
+  parent: n
+}) {
+  return n;
+}
+function $({
+  text: n
+}) {
+  return typeof n == "string";
+}
+function g({
+  text: n
+}) {
+  return n;
+}
+function T(n) {
+  const t = n.parent.children.indexOf(n);
+  return t !== -1 && n.parent.children.splice(t, 1), n;
+}
+function h({
+  type: n,
+  attributes: t,
+  object: e,
+  children: f
+}) {
+  if (n === "#comment")
+    return `<!--${t["data-rich-text-comment"]}-->`;
+  let r = "";
+  for (const i in t)
+    c(i) && (r += ` ${i}="${m(t[i])}"`);
+  return e ? `<${n}${r}>` : `<${n}${r}>${u(f)}</${n}>`;
+}
+function u(n = []) {
+  return n.map((t) => t.html !== void 0 ? t.html : t.text === void 0 ? h(t) : o(t.text)).join("");
+}
+export {
+  M as toHTMLString
+};