@wix/editor-react-components 1.2153.0

package/dist/site/components/WRichText/sdk.js

@@ -0,0 +1,581 @@
+import { c as createA11ySdk } from "../chunks/a11ySdk.js";
+import { s as sanitizeHTML } from "../chunks/sanitizeHTML.js";
+import { r as requireDefinition } from "../chunks/index.js";
+import { w as wixCodeName, a as wixGuard, e as endBlockTagRegex, b as endTagRegex, s as startTagRegex } from "../chunks/constants.js";
+import { i as isNil } from "../chunks/assert.js";
+import { c as createElementPropsSDKFactory } from "../chunks/elementPropsSDKFactory.js";
+import { c as composeSDKFactories } from "../chunks/composeSDKFactories.js";
+var definitionExports = /* @__PURE__ */ requireDefinition();
+function flow(...fns) {
+  return (value) => fns.reduce((output, fn) => fn(output), value);
+}
+const HTML_END = "HTML_END";
+const OPEN_TAG_START = "<";
+const TAG_END = ">";
+const SELF_CLOSING = "/>";
+const CLOSING_TAG_START = "</";
+const SPACE = " ";
+const selfClosingTags = [
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr"
+];
+const selfClosingTagsSet = new Set(selfClosingTags);
+const bracketsSet = /* @__PURE__ */ new Set([
+  OPEN_TAG_START,
+  TAG_END,
+  SELF_CLOSING,
+  CLOSING_TAG_START
+]);
+function parseTagName(html, lastBracketTokenEnd, currentTokenIndex, indexOfFirstSpaceAfterOpenBracket) {
+  const indexOfTagNameEnd = indexOfFirstSpaceAfterOpenBracket || currentTokenIndex;
+  return html.slice(lastBracketTokenEnd + 1, indexOfTagNameEnd).toLowerCase();
+}
+function parseProps(html, lastBracketTokenEnd, currentTokenIndex, indexOfFirstSpaceAfterOpenBracket) {
+  const indexOfTagNameEnd = indexOfFirstSpaceAfterOpenBracket || currentTokenIndex;
+  return html.slice(indexOfTagNameEnd + 1, currentTokenIndex);
+}
+function processTagEnd(html, lastBracketToken, lastBracketTokenEnd, currentTokenIndex, indexOfFirstSpaceAfterOpenBracket, callbacks) {
+  const tagName = parseTagName(
+    html,
+    lastBracketTokenEnd,
+    currentTokenIndex,
+    indexOfFirstSpaceAfterOpenBracket
+  );
+  if (lastBracketToken === OPEN_TAG_START) {
+    const props = parseProps(
+      html,
+      lastBracketTokenEnd,
+      currentTokenIndex,
+      indexOfFirstSpaceAfterOpenBracket
+    );
+    if (selfClosingTagsSet.has(tagName)) {
+      callbacks.onSelfClosingTag && callbacks.onSelfClosingTag({ tagName, props });
+    } else {
+      callbacks.onOpenTag && callbacks.onOpenTag({ tagName, props });
+    }
+  } else {
+    callbacks.onClosingTag && callbacks.onClosingTag({ tagName, props: "" });
+  }
+}
+function detectToken(html, i) {
+  let currentToken;
+  switch (html[i]) {
+    case "<":
+      if (html[i + 1] === "/") {
+        currentToken = CLOSING_TAG_START;
+        i++;
+        break;
+      }
+      currentToken = OPEN_TAG_START;
+      break;
+    case ">":
+      currentToken = TAG_END;
+      break;
+    case "/":
+      if (html[i + 1] === ">") {
+        currentToken = SELF_CLOSING;
+        i++;
+        break;
+      }
+    // eslint-disable-next-line no-fallthrough
+    case " ":
+      currentToken = SPACE;
+      break;
+    default:
+      currentToken = html[i];
+  }
+  if (i === html.length) {
+    currentToken = HTML_END;
+  }
+  return currentToken;
+}
+function parseFragment(html, callbacks = {}) {
+  let currentToken;
+  let currentTokenStart;
+  let currentTokenEnd;
+  let lastBracketToken;
+  let lastBracketTokenEnd = -1;
+  let indexOfFirstSpaceAfterOpenBracket = null;
+  const htmlLength = html.length;
+  let i = 0;
+  while (i <= htmlLength) {
+    currentTokenStart = i;
+    currentToken = detectToken(html, i);
+    i = currentTokenEnd = currentTokenStart + currentToken.length - 1;
+    switch (currentToken) {
+      case OPEN_TAG_START:
+      case CLOSING_TAG_START: {
+        const text = html.slice(lastBracketTokenEnd + 1, currentTokenStart);
+        if (text && callbacks.onText) {
+          callbacks.onText(text);
+        }
+        indexOfFirstSpaceAfterOpenBracket = null;
+        break;
+      }
+      case TAG_END:
+        processTagEnd(
+          html,
+          lastBracketToken,
+          lastBracketTokenEnd,
+          i,
+          indexOfFirstSpaceAfterOpenBracket,
+          callbacks
+        );
+        break;
+      case SELF_CLOSING: {
+        if (!callbacks.onSelfClosingTag) {
+          break;
+        }
+        callbacks.onSelfClosingTag({
+          tagName: parseTagName(
+            html,
+            lastBracketTokenEnd,
+            currentTokenStart,
+            indexOfFirstSpaceAfterOpenBracket
+          ),
+          props: parseProps(
+            html,
+            lastBracketTokenEnd,
+            currentTokenStart,
+            indexOfFirstSpaceAfterOpenBracket
+          )
+        });
+        break;
+      }
+      case SPACE:
+        if (!indexOfFirstSpaceAfterOpenBracket && (lastBracketToken === OPEN_TAG_START || lastBracketToken === CLOSING_TAG_START)) {
+          indexOfFirstSpaceAfterOpenBracket = i;
+        }
+        break;
+      case HTML_END:
+        if (!callbacks.onText) {
+          break;
+        }
+        if (!lastBracketToken) {
+          callbacks.onText(html);
+          return;
+        }
+        if (lastBracketTokenEnd !== htmlLength - 1) {
+          callbacks.onText(html.slice(lastBracketTokenEnd + 1, htmlLength));
+        }
+        break;
+    }
+    if (bracketsSet.has(currentToken)) {
+      lastBracketToken = currentToken;
+      lastBracketTokenEnd = currentTokenEnd;
+    }
+    i++;
+  }
+}
+const parser = { parseFragment };
+const styleMap = {
+  p: "font_8",
+  h1: "font_0",
+  h2: "font_2",
+  h3: "font_3",
+  h4: "font_4",
+  h5: "font_5",
+  h6: "font_6",
+  ol: "font_8",
+  ul: "font_8"
+};
+const startBlockRegexp = /<(ol|ul|h[1-6]|p)(.*?)>/g;
+const p1p2regexp = /(class\s*=['"][^'"]*?)\bfont_([79])\b/;
+function applyTransformationForGetHtml(data = "") {
+  return data.replace(startBlockRegexp, (match, tag, attributes = "") => {
+    const defaultClass = styleMap[tag];
+    const defaultClassForTagRegexp = new RegExp(
+      `(class\\s*=['"].*?)${defaultClass}`
+    );
+    if (defaultClassForTagRegexp.test(attributes)) {
+      match = match.replace(defaultClassForTagRegexp, "$1");
+    } else if (tag === "p" && p1p2regexp.test(attributes)) {
+      match = match.replace(
+        p1p2regexp,
+        (matcho, prefix, p1p2) => `${prefix}${p1p2 === "7" ? "p1" : "p3"}`
+      );
+    }
+    return match.replace(/class\s*=(['"])\s*\1/, "").replace(
+      /class\s*=(['"])\s*(.*?)\s*\1/,
+      (_match, quote, classes) => `class=${quote}${classes}${quote}`
+    ).replace(/(.+)\s{2,}/g, "$1 ").replace(/\s+>/, ">");
+  });
+}
+const regexp = /<(ol|ul|h[1-6]|p)(.*?)>/g;
+const classRegexp = /class\s*?=\s*["'](.*?)['"]/;
+const g2ClassRegexp = /(class\s*?=\s*["'])(.*?)(['"])/;
+const applyTransformationForSetHtml = (htmlString = "", { addDefaultClasses } = {}) => {
+  if (!htmlString) {
+    return htmlString;
+  }
+  return htmlString.replace(regexp, (match, g1, g2) => {
+    const matchedClassArray = g2.match(classRegexp);
+    if (!matchedClassArray) {
+      return addDefaultClasses ? `<${g1}${g2} class="${styleMap[g1]}">` : `<${g1}${g2}>`;
+    }
+    const matchedClass = matchedClassArray[1];
+    if (/(^|\s)font_[0-9]($|\s)/.test(matchedClass)) {
+      return match;
+    } else if (g1 === "p" && /\bp[13]\b/i.test(matchedClass)) {
+      return match.replace(
+        /(.*?\bclass\s*?=.*?)\bp([13])\b(.*)/,
+        (matcho, _g1, _g2, g3) => {
+          const _class = _g2 === "1" ? "font_7" : "font_9";
+          return `${_g1}${_class}${g3}`;
+        }
+      );
+    }
+    return `<${g1}${g2.replace(
+      g2ClassRegexp,
+      (_match, _g1, _g2, _g3) => `${_g1}${styleMap[g1]} ${_g2}${_g3}`
+    )}>`;
+  });
+};
+const removeWixGuard = (htmlStr) => {
+  return htmlStr.replace(
+    /<span class="wixGuard">([^<]*)<\/span>/g,
+    (_full, group1 = "") => {
+      if (group1.trim() === "&#8203;") {
+        return "";
+      }
+      return group1;
+    }
+  );
+};
+const htmlEntitiesMap = {
+  ldquo: "“",
+  lsquo: "‘",
+  rsquo: "’",
+  laquo: "«",
+  raquo: "»",
+  lsaquo: "‹",
+  rsaquo: "›",
+  lt: "<",
+  gt: ">",
+  amp: "&",
+  bull: "•",
+  deg: "°",
+  hellip: "…",
+  trade: "™",
+  copy: "©",
+  reg: "®",
+  mdash: "—",
+  ndash: "–",
+  nbsp: " ",
+  emsp: " ",
+  ensp: " ",
+  sup2: "²",
+  sup3: "³",
+  frac14: "¼",
+  frac12: "½",
+  frac34: "¾"
+};
+const namedReferences = Object.keys(htmlEntitiesMap).sort(
+  (a, b) => b.length - a.length
+);
+const namedReferenceRegex = new RegExp(
+  `&(${namedReferences.join("|")});|&#([0-9]+);|&#[xX]([a-fA-F0-9]+);`,
+  "g"
+);
+const numericEntitiesMap = {
+  "0": "�",
+  "128": "€",
+  "130": "‚",
+  "131": "ƒ",
+  "132": "„",
+  "133": "…",
+  "134": "†",
+  "135": "‡",
+  "136": "ˆ",
+  "137": "‰",
+  "138": "Š",
+  "139": "‹",
+  "140": "Œ",
+  "142": "Ž",
+  "145": "‘",
+  "146": "’",
+  "147": "“",
+  "148": "”",
+  "149": "•",
+  "150": "–",
+  "151": "—",
+  "152": "˜",
+  "153": "™",
+  "154": "š",
+  "155": "›",
+  "156": "œ",
+  "158": "ž",
+  "159": "Ÿ"
+};
+const HE_URL = "https://static.parastorage.com/unpkg/he@1.2.0/he.js";
+const ENTITY_START = "&";
+const ENTITY_END = ";";
+function codePointToSymbol(codePoint) {
+  let output = "";
+  const numericEntities = numericEntitiesMap;
+  if (codePoint in numericEntitiesMap) {
+    return numericEntities[codePoint];
+  }
+  if (codePoint > 65535) {
+    codePoint -= 65536;
+    output += String.fromCharCode(codePoint >>> 10 & 1023 | 55296);
+    codePoint = 56320 | codePoint & 1023;
+  }
+  return output + String.fromCharCode(codePoint);
+}
+function getEntities(str) {
+  const result = [];
+  let buffer = [];
+  let include = false;
+  for (const char of str) {
+    if (include && char !== ENTITY_END) {
+      buffer.push(char);
+    }
+    if (char === ENTITY_START) {
+      include = true;
+    }
+    if (char === ENTITY_END) {
+      result.push(buffer.join(""));
+      include = false;
+      buffer = [];
+    }
+  }
+  return result;
+}
+const decode = (rawText) => {
+  if (!rawText) {
+    return rawText;
+  }
+  const { he } = self;
+  if (he) {
+    return he.decode(rawText);
+  }
+  const entities = getEntities(rawText);
+  const canConvert = entities.every(
+    (entity) => entity in htmlEntitiesMap || entity[0] === "#"
+  );
+  if (canConvert) {
+    return rawText.replace(namedReferenceRegex, ($0, $1, $2, $3) => {
+      const htmlEntities = htmlEntitiesMap;
+      if ($1) {
+        return htmlEntities[$1];
+      }
+      if ($2) {
+        return codePointToSymbol(parseInt($2, 10));
+      }
+      if ($3) {
+        return codePointToSymbol(parseInt($3, 16));
+      }
+      return $0;
+    });
+  }
+  self.importScripts(HE_URL);
+  return decode(rawText);
+};
+function buildHtmlFromTagStack(tagStack, textInTheMiddle) {
+  let openTags = "";
+  let closingTags = "";
+  for (const { tagName, props } of tagStack) {
+    openTags += props ? `<${tagName} ${props}>` : `<${tagName}>`;
+    closingTags = `</${tagName}>${closingTags}`;
+  }
+  return openTags + textInTheMiddle + closingTags;
+}
+function insertContentInHtml(html, content) {
+  const tagStack = [];
+  let stop = false;
+  parser.parseFragment(html, {
+    onText: () => {
+      stop = true;
+    },
+    onOpenTag: (tag) => {
+      if (tag.tagName === "span" && tag.props === 'class="wixGuard"') {
+        stop = true;
+      }
+      if (!stop) {
+        tagStack.push(tag);
+      }
+    },
+    onClosingTag: () => {
+      if (!stop) {
+        tagStack.pop();
+      }
+    }
+  });
+  return buildHtmlFromTagStack(tagStack, content);
+}
+const regexHref = /(?:<a.*?href=(["']))(.*?)(?:\1)/i;
+const regexTarget = /<a(.*?((target=["']([^"]+)["']).*?)?)>/i;
+const regexLink = /<a.*?>/gi;
+const addTarget = (htmlPart, target = "_blank") => {
+  const match = regexTarget.exec(htmlPart);
+  if (match) {
+    const [fullMatch, replacedMatch, _, targetAttribute, targetName] = match;
+    if (targetName === "_blank" || targetName === "_self") {
+      return htmlPart;
+    }
+    let linkWithTarget;
+    if (targetAttribute) {
+      linkWithTarget = replacedMatch.replace(
+        targetAttribute,
+        `target="${target}"`
+      );
+      linkWithTarget = fullMatch.replace(replacedMatch, linkWithTarget);
+    } else {
+      linkWithTarget = fullMatch.replace(
+        replacedMatch,
+        `${replacedMatch} target="${target}"`
+      );
+    }
+    return htmlPart.replace(fullMatch, linkWithTarget);
+  }
+  return htmlPart;
+};
+const convertLink = (htmlPart, getLinkProps, resolveHref) => {
+  const match = regexHref.exec(htmlPart);
+  if (match) {
+    const fullMatch = match[0];
+    const groupMatch = match[2];
+    const props = getLinkProps(groupMatch);
+    const replacedMatch = fullMatch.replace(groupMatch, resolveHref(props));
+    return addTarget(htmlPart.replace(fullMatch, replacedMatch), props.target);
+  }
+  return htmlPart;
+};
+const convertLinkProperties = (html, getLinkProps, resolveHref = (props) => props.href || "") => {
+  const replaces = [];
+  let match;
+  do {
+    match = regexLink.exec(html);
+    if (match) {
+      const [fullMatch] = match;
+      const link = convertLink(fullMatch, getLinkProps, resolveHref);
+      replaces.push([fullMatch, link]);
+    }
+  } while (match);
+  return replaces.reduce(
+    (a, [matcho, replace]) => a.replace(matcho, replace),
+    html
+  );
+};
+const htmlEscapes = {
+  "&": "&amp;",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;",
+  "'": "&#39;"
+};
+const reUnescapedHtml = /[&<>"']/g;
+const reHasUnescapedHtml = RegExp(reUnescapedHtml.source);
+function escape(string) {
+  return string && reHasUnescapedHtml.test(string) ? string.replace(reUnescapedHtml, (chr) => htmlEscapes[chr]) : string || "";
+}
+const htmlUnescapes = {
+  "&amp;": "&",
+  "&lt;": "<",
+  "&gt;": ">",
+  "&quot;": '"',
+  "&#39;": "'"
+};
+const reEscapedHtml = /&(?:amp|lt|gt|quot|#(0+)?39);/g;
+const reHasEscapedHtml = RegExp(reEscapedHtml.source);
+function unescape(string) {
+  return string && reHasEscapedHtml.test(string) ? string.replace(reEscapedHtml, (entity) => htmlUnescapes[entity] || "'") : string || "";
+}
+const IMPLIED_LINKS_PATTERN = /(?:<object.*?>)?<a data-auto-recognition="true".*?>(.*?)<\/a>(?:<\/object>)?/g;
+const stripImpliedLinks = (text) => text.replace(IMPLIED_LINKS_PATTERN, (_fullMatch, innerText) => innerText);
+const isUndefined = (str) => isNil(str) ? "" : str;
+const endBlockTagPattern = new RegExp(endBlockTagRegex, "mg");
+const endTagPattern = new RegExp(endTagRegex, "mg");
+const startTagPattern = new RegExp(startTagRegex, "mg");
+const getText = (html) => html ? decode(
+  unescape(
+    stripImpliedLinks(removeWixGuard(html)).replace(/\n/g, "").replace(/<br>/g, "\n").replace(/<br><\/br>/g, "\n").replace(/<br\s*\/?>/g, "\n").replace(endBlockTagPattern, "\n").replace(endTagPattern, "").replace(startTagPattern, "").trim()
+  )
+) : "";
+const WRICHTEXT_SDK_TYPE = wixCodeName;
+const createWRichTextSdk = (api) => {
+  const { props, setProps, getService } = api;
+  const linkUtils = getService(definitionExports.LinkUtilsDefinition);
+  const convertLinksForSetter = (str) => convertLinkProperties(str, linkUtils.getLinkProps);
+  const convertLinksForGetter = (str) => {
+    convertLinkProperties(str, linkUtils.getLinkProps, linkUtils.getLink);
+    return str;
+  };
+  const getHtml = (html) => flow(
+    removeWixGuard,
+    stripImpliedLinks,
+    applyTransformationForGetHtml,
+    convertLinksForGetter
+  )(html);
+  const getPreparedHTML = (html, config) => {
+    const flowParts = [
+      isUndefined,
+      (_html) => applyTransformationForSetHtml(_html, config),
+      convertLinksForSetter,
+      (_html) => (
+        // @ts-expect-error TODO: Fix service usage
+        linkUtils.getImpliedLinks(_html, false, { parseEscaped: true })
+      ),
+      sanitizeHTML
+    ];
+    return flow(...flowParts)(html);
+  };
+  return {
+    get type() {
+      return wixCodeName;
+    },
+    get html() {
+      var _a;
+      return getHtml(((_a = props.richText) == null ? void 0 : _a.html) || "");
+    },
+    set html(value) {
+      setProps({
+        richText: {
+          html: getPreparedHTML(value, { addDefaultClasses: false })
+        }
+      });
+    },
+    get text() {
+      return getText(props.richText.html);
+    },
+    set text(value) {
+      const escapedHTML = value ? escape(value).replace(/\n/g, "<br>") : wixGuard;
+      const html = linkUtils.getImpliedLinks(
+        insertContentInHtml(
+          stripImpliedLinks(props.richText.html),
+          escapedHTML
+        ),
+        false,
+        // @ts-expect-error TODO: Fix service usage
+        { parseEscaped: true }
+      );
+      setProps({
+        richText: { html }
+      });
+    }
+  };
+};
+const elementPropsSDKFactory = createElementPropsSDKFactory();
+const sdk = composeSDKFactories([
+  createWRichTextSdk,
+  elementPropsSDKFactory,
+  createA11ySdk({ a11yProperty: "a11y" })
+]);
+export {
+  WRICHTEXT_SDK_TYPE,
+  createWRichTextSdk,
+  sdk as default
+};

package/dist/site/components/WRichText/utils/applyTransformationForGetHtml.d.ts

@@ -0,0 +1,8 @@
+export declare function applyTransformationForGetHtml(data?: string): string;
+export type SetHTMLTransformConfig = {
+    addDefaultClasses?: boolean;
+};
+export declare const applyTransformationForSetHtml: (htmlString?: string, { addDefaultClasses }?: SetHTMLTransformConfig) => string;
+export declare const getAllTagsFromHtml: (html: string) => string[];
+export declare const isTagWrapper: (htmlTags: Array<string>, tagToSearch: string) => boolean;
+export declare function replaceFirstTagWith(html: string, firstTag: string, replaceWith: string): string;

package/dist/site/components/WRichText/utils/convertLinkProperties.d.ts

@@ -0,0 +1,2 @@
+import { LinkProps } from '../../../../types/vendored/editor-elements-definitions';
+export declare const convertLinkProperties: (html: string, getLinkProps: (href: string) => LinkProps, resolveHref?: (properties: LinkProps) => string) => string;

package/dist/site/components/WRichText/utils/decodeHtmlEntities.d.ts

@@ -0,0 +1,2 @@
+/// <reference lib="webworker" />
+export declare const decode: (rawText: string) => string;

package/dist/site/components/WRichText/utils/escape.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Converts the characters "&", "<", ">", '"', and "'" in `string` to their
+ * corresponding HTML entities.
+ *
+ * **Note:** No other characters are escaped. To escape additional
+ * characters use a third-party library like [_he_](https://mths.be/he).
+ *
+ * Though the ">" character is escaped for symmetry, characters like
+ * ">" and "/" don't need escaping in HTML and have no special meaning
+ * unless they're part of a tag or unquoted attribute value. See
+ * [Mathias Bynens's article](https://mathiasbynens.be/notes/ambiguous-ampersands)
+ * (under "semi-related fun fact") for more details.
+ *
+ * When working with HTML you should always
+ * [quote attribute values](http://wonko.com/post/html-escaping) to reduce
+ * XSS vectors.
+ *
+ * @since 0.1.0
+ * @category String
+ * @param {string} [string=''] The string to escape.
+ * @returns {string} Returns the escaped string.
+ * @see escapeRegExp, unescape
+ * @example
+ *
+ * escape('fred, barney, & pebbles')
+ * // => 'fred, barney, &amp; pebbles'
+ */
+export declare function escape(string: string): string;

package/dist/site/components/WRichText/utils/flow.d.ts

@@ -0,0 +1 @@
+export declare function flow<T>(...fns: Array<(value: T) => T>): (value: T) => T;

package/dist/site/components/WRichText/utils/htmlEntitiesMap.d.ts

@@ -0,0 +1,29 @@
+declare const _default: {
+    ldquo: string;
+    lsquo: string;
+    rsquo: string;
+    laquo: string;
+    raquo: string;
+    lsaquo: string;
+    rsaquo: string;
+    lt: string;
+    gt: string;
+    amp: string;
+    bull: string;
+    deg: string;
+    hellip: string;
+    trade: string;
+    copy: string;
+    reg: string;
+    mdash: string;
+    ndash: string;
+    nbsp: string;
+    emsp: string;
+    ensp: string;
+    sup2: string;
+    sup3: string;
+    frac14: string;
+    frac12: string;
+    frac34: string;
+};
+export default _default;

package/dist/site/components/WRichText/utils/htmlParser.d.ts

@@ -0,0 +1,15 @@
+export type Tag = {
+    tagName: string;
+    props: string;
+};
+export type ParseFragmentCallbacks = {
+    onText?: (text: string) => void;
+    onOpenTag?: (tag: Tag) => void;
+    onClosingTag?: (tag: Tag) => void;
+    onSelfClosingTag?: (tag: Tag) => void;
+};
+export declare function parseFragment(html: string, callbacks?: ParseFragmentCallbacks): void;
+declare const _default: {
+    parseFragment: typeof parseFragment;
+};
+export default _default;

package/dist/site/components/WRichText/utils/index.d.ts

@@ -0,0 +1,9 @@
+export * from './flow';
+export * from './applyTransformationForGetHtml';
+export * from './removeWixGuard';
+export * from './decodeHtmlEntities';
+export * from './insertIntoDOMNode';
+export * from './convertLinkProperties';
+export * from './escape';
+export * from './unescape';
+export * from './stripImpliedLinks';

package/dist/site/components/WRichText/utils/insertIntoDOMNode.d.ts

@@ -0,0 +1,11 @@
+export declare function insertContentInHtml(html: string, content: string): string;
+export declare function wrapWithRichTextMarker(html: string): string;
+export declare function hasRichTextMarker(html: string): boolean;
+export declare function insertContentInMarker(html: string, content: string): string;
+export declare function getMarkerContent(html: string): string;
+export declare function parseRichTextMarker(html: string): {
+    before: string;
+    marker: string;
+    after: string;
+    withMarker: boolean;
+};

package/dist/site/components/WRichText/utils/namedReferenceRegex.d.ts

@@ -0,0 +1,2 @@
+declare const _default: RegExp;
+export default _default;