@rowsncolumns/utils 9.3.0 → 9.5.0

package/dist/cjs/rich-text-html.js

@@ -0,0 +1,601 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clipboardHtmlToRichText = exports.findSingleClipboardCell = exports.htmlElementToRichText = exports.cssFontSizeToPt = exports.cssColorToHex = exports.mountClipboardHtml = void 0;
+var tslib_1 = require("tslib");
+var color_1 = require("./color");
+var dom_1 = require("./dom");
+var BLOCK_TAGS = new Set([
+    "p",
+    "div",
+    "li",
+    "ul",
+    "ol",
+    "h1",
+    "h2",
+    "h3",
+    "h4",
+    "h5",
+    "h6",
+    "pre",
+    "tr",
+    "blockquote",
+]);
+var SKIPPED_TAGS = new Set([
+    "style",
+    "script",
+    "meta",
+    "head",
+    "title",
+    "link",
+    "col",
+    "colgroup",
+    "template",
+    "noscript",
+]);
+// `<font size="N">` → points (HTML 4 size keywords).
+var FONT_SIZE_KEYWORDS = {
+    1: 8,
+    2: 10,
+    3: 12,
+    4: 14,
+    5: 18,
+    6: 24,
+    7: 36,
+};
+// CSS named colors Excel / Word actually emit (`color:red`, `<font color=red>`).
+// `getComputedStyle` in a browser already resolves names to `rgb()`, this
+// table covers inline keywords and jsdom (which reports the declared value).
+var NAMED_COLORS = {
+    black: "#000000",
+    white: "#FFFFFF",
+    red: "#FF0000",
+    green: "#008000",
+    lime: "#00FF00",
+    blue: "#0000FF",
+    yellow: "#FFFF00",
+    orange: "#FFA500",
+    purple: "#800080",
+    gray: "#808080",
+    grey: "#808080",
+    silver: "#C0C0C0",
+    maroon: "#800000",
+    navy: "#000080",
+    teal: "#008080",
+    olive: "#808000",
+    aqua: "#00FFFF",
+    cyan: "#00FFFF",
+    fuchsia: "#FF00FF",
+    magenta: "#FF00FF",
+    brown: "#A52A2A",
+    pink: "#FFC0CB",
+    gold: "#FFD700",
+    indigo: "#4B0082",
+    violet: "#EE82EE",
+    darkred: "#8B0000",
+    darkgreen: "#006400",
+    darkblue: "#00008B",
+};
+// Values that mean "no explicit color" — Excel's `windowtext`, CSS keywords.
+var NON_COLORS = new Set([
+    "windowtext",
+    "inherit",
+    "initial",
+    "unset",
+    "currentcolor",
+    "transparent",
+    "auto",
+    "",
+]);
+/**
+ * Parse an HTML clipboard payload into a hidden, mounted sandbox so
+ * `getComputedStyle` resolves the payload's own `<style>` rules (Excel's
+ * `.fontN` / `.xlNN` classes). Callers must `cleanup()` when done.
+ */
+var mountClipboardHtml = function (clipboardValue) {
+    var _a, _b, _c, _d;
+    var parser = new DOMParser();
+    var doc = parser.parseFromString(clipboardValue, "text/html");
+    var sandbox = document.createElement("div");
+    sandbox.style.cssText =
+        "position:fixed;left:-10000px;top:-10000px;width:0;height:0;overflow:hidden;opacity:0;pointer-events:none;font-size:10pt;";
+    sandbox.innerHTML = (_b = (_a = doc.body) === null || _a === void 0 ? void 0 : _a.innerHTML) !== null && _b !== void 0 ? _b : "";
+    var styles = (_d = (_c = doc.head) === null || _c === void 0 ? void 0 : _c.querySelectorAll("style")) !== null && _d !== void 0 ? _d : [];
+    styles.forEach(function (style) { return sandbox.appendChild(style.cloneNode(true)); });
+    document.body.appendChild(sandbox);
+    return {
+        root: sandbox,
+        cleanup: function () { return sandbox.remove(); },
+    };
+};
+exports.mountClipboardHtml = mountClipboardHtml;
+var cssColorToHex = function (value) {
+    if (!value) {
+        return undefined;
+    }
+    var trimmed = value.trim();
+    var lower = trimmed.toLowerCase();
+    if (NON_COLORS.has(lower)) {
+        return undefined;
+    }
+    // `rgba(0, 0, 0, 0)` is the transparent default many engines report.
+    if (/^rgba\(\s*0\s*,\s*0\s*,\s*0\s*,\s*0\s*\)$/.test(lower)) {
+        return undefined;
+    }
+    var hex = (0, color_1.colorStringToHex)(trimmed);
+    if (hex) {
+        return hex.toUpperCase();
+    }
+    return NAMED_COLORS[lower];
+};
+exports.cssColorToHex = cssColorToHex;
+/** CSS font-size → points. `pt` verbatim, `px` at 96dpi, `em`/`rem` on a 16px base. */
+var cssFontSizeToPt = function (value) {
+    var _a;
+    if (!value) {
+        return undefined;
+    }
+    var match = value.trim().match(/^(\d+(?:\.\d+)?)\s*(pt|px|rem|em)?$/i);
+    if (!match) {
+        return undefined;
+    }
+    var numeric = parseFloat(match[1]);
+    if (!Number.isFinite(numeric) || numeric <= 0) {
+        return undefined;
+    }
+    var unit = ((_a = match[2]) !== null && _a !== void 0 ? _a : "px").toLowerCase();
+    var pt = unit === "pt"
+        ? numeric
+        : unit === "px"
+            ? numeric * 0.75
+            : numeric * 16 * 0.75;
+    return Number(pt.toFixed(1));
+};
+exports.cssFontSizeToPt = cssFontSizeToPt;
+var firstFontFamily = function (value) {
+    if (!value) {
+        return undefined;
+    }
+    var family = value
+        .split(",")[0]
+        .trim()
+        .replace(/^["']|["']$/g, "")
+        .trim();
+    if (!family || /^(inherit|initial|unset)$/i.test(family)) {
+        return undefined;
+    }
+    return family;
+};
+var safeComputedStyle = function (element) {
+    if (!dom_1.canUseDOM || typeof getComputedStyle !== "function") {
+        return null;
+    }
+    try {
+        return getComputedStyle(element);
+    }
+    catch (_a) {
+        return null;
+    }
+};
+var readWeight = function (value) {
+    if (!value) {
+        return undefined;
+    }
+    var lower = value.trim().toLowerCase();
+    if (lower === "bold" || lower === "bolder") {
+        return true;
+    }
+    if (lower === "normal" || lower === "lighter") {
+        return false;
+    }
+    var numeric = Number(lower);
+    if (Number.isFinite(numeric)) {
+        return numeric >= 600;
+    }
+    return undefined;
+};
+var normalizeWhitespace = function (text) {
+    return text.replace(/[\n\r]+/g, " ").replace(/\s{2,}/g, " ");
+};
+/**
+ * The formatting an element applies on top of `inherited`: tag semantics
+ * (`<b>`, `<font color>`, `<a href>`, …) + inline `style` + (except for
+ * anchors) the cascaded computed style.
+ */
+var readElementFormat = function (element, inherited) {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    var format = tslib_1.__assign({}, inherited);
+    var tag = element.tagName.toLowerCase();
+    var attrColor;
+    var attrFace;
+    var attrSize;
+    switch (tag) {
+        case "b":
+        case "strong":
+            format.bold = true;
+            break;
+        case "i":
+        case "em":
+            format.italic = true;
+            break;
+        case "u":
+            format.underline = true;
+            break;
+        case "s":
+        case "strike":
+        case "del":
+            format.strikethrough = true;
+            break;
+        case "sup":
+            format.baselineOffset = "superscript";
+            break;
+        case "sub":
+            format.baselineOffset = "subscript";
+            break;
+        case "font": {
+            // Presentational attributes. They rank between the inline style and
+            // the cascaded computed style below: a browser folds them into the
+            // computed value, jsdom reports the inherited one instead.
+            attrColor = (0, exports.cssColorToHex)(element.getAttribute("color"));
+            attrFace = firstFontFamily(element.getAttribute("face"));
+            var size = parseInt((_a = element.getAttribute("size")) !== null && _a !== void 0 ? _a : "", 10);
+            if (!Number.isNaN(size) && FONT_SIZE_KEYWORDS[size]) {
+                attrSize = FONT_SIZE_KEYWORDS[size];
+            }
+            break;
+        }
+        case "a": {
+            var href = element.getAttribute("href");
+            if (href && href.trim()) {
+                format.link = { uri: href.trim() };
+            }
+            break;
+        }
+    }
+    var inline = element.style;
+    var computed = tag === "a" ? null : safeComputedStyle(element);
+    var pick = function (inlineValue, computedValue) { return (inlineValue && inlineValue.trim() ? inlineValue : computedValue); };
+    var weight = readWeight(pick(inline.fontWeight, computed === null || computed === void 0 ? void 0 : computed.fontWeight));
+    if (weight !== undefined) {
+        format.bold = weight;
+    }
+    var fontStyle = pick(inline.fontStyle, computed === null || computed === void 0 ? void 0 : computed.fontStyle);
+    if (fontStyle) {
+        var lower = fontStyle.trim().toLowerCase();
+        if (lower === "italic" || lower === "oblique") {
+            format.italic = true;
+        }
+        else if (lower === "normal") {
+            format.italic = false;
+        }
+    }
+    // `text-decoration` is not inherited in CSS but propagates visually, so a
+    // parent's underline stays on (inherited state) unless a child says `none`.
+    var decoration = pick(inline.textDecoration || inline.textDecorationLine, (computed === null || computed === void 0 ? void 0 : computed.textDecorationLine) || (computed === null || computed === void 0 ? void 0 : computed.textDecoration));
+    if (decoration) {
+        var lower = decoration.toLowerCase();
+        if (lower.includes("underline")) {
+            format.underline = true;
+        }
+        if (lower.includes("line-through")) {
+            format.strikethrough = true;
+        }
+        if (/^\s*none\s*$/.test(lower)) {
+            format.underline = false;
+            format.strikethrough = false;
+        }
+    }
+    var verticalAlign = (_b = pick(inline.verticalAlign, computed === null || computed === void 0 ? void 0 : computed.verticalAlign)) === null || _b === void 0 ? void 0 : _b.toLowerCase();
+    if (verticalAlign === "super") {
+        format.baselineOffset = "superscript";
+    }
+    else if (verticalAlign === "sub") {
+        format.baselineOffset = "subscript";
+    }
+    else if (verticalAlign === "baseline" && tag !== "sup" && tag !== "sub") {
+        format.baselineOffset = null;
+    }
+    var color = (_d = (_c = (0, exports.cssColorToHex)(inline.color)) !== null && _c !== void 0 ? _c : attrColor) !== null && _d !== void 0 ? _d : (0, exports.cssColorToHex)(computed === null || computed === void 0 ? void 0 : computed.color);
+    if (color) {
+        format.color = color;
+    }
+    var fontSize = (_f = (_e = (0, exports.cssFontSizeToPt)(inline.fontSize)) !== null && _e !== void 0 ? _e : attrSize) !== null && _f !== void 0 ? _f : (0, exports.cssFontSizeToPt)(computed === null || computed === void 0 ? void 0 : computed.fontSize);
+    if (fontSize !== undefined) {
+        format.fontSize = fontSize;
+    }
+    var fontFamily = (_h = (_g = firstFontFamily(inline.fontFamily)) !== null && _g !== void 0 ? _g : attrFace) !== null && _h !== void 0 ? _h : firstFontFamily(computed === null || computed === void 0 ? void 0 : computed.fontFamily);
+    if (fontFamily) {
+        format.fontFamily = fontFamily;
+    }
+    return format;
+};
+var isBlockElement = function (element) {
+    var _a;
+    var tag = element.tagName.toLowerCase();
+    if (BLOCK_TAGS.has(tag)) {
+        return true;
+    }
+    var display = (_a = element.style.display) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+    return display === "block" || display === "list-item";
+};
+var collectSegments = function (node, inherited, segments) {
+    var e_1, _a;
+    var _b;
+    if (node.nodeType === Node.TEXT_NODE) {
+        var text = normalizeWhitespace((_b = node.textContent) !== null && _b !== void 0 ? _b : "");
+        if (text) {
+            segments.push({ text: text, format: inherited });
+        }
+        return;
+    }
+    if (node.nodeType !== Node.ELEMENT_NODE) {
+        return;
+    }
+    var element = node;
+    var tag = element.tagName.toLowerCase();
+    if (SKIPPED_TAGS.has(tag)) {
+        return;
+    }
+    if (tag === "br") {
+        segments.push({ text: "\n", format: inherited });
+        return;
+    }
+    var block = isBlockElement(element);
+    if (block && segments.length && !endsWithNewline(segments)) {
+        segments.push({ text: "\n", format: inherited });
+    }
+    var format = readElementFormat(element, inherited);
+    try {
+        for (var _c = tslib_1.__values(Array.from(element.childNodes)), _d = _c.next(); !_d.done; _d = _c.next()) {
+            var child = _d.value;
+            collectSegments(child, format, segments);
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    if (block && segments.length && !endsWithNewline(segments)) {
+        segments.push({ text: "\n", format: inherited });
+    }
+};
+var endsWithNewline = function (segments) {
+    var last = segments[segments.length - 1];
+    return !!last && last.text.endsWith("\n");
+};
+var TEXT_KEYS = [
+    "bold",
+    "italic",
+    "underline",
+    "strikethrough",
+    "baselineOffset",
+    "color",
+    "fontSize",
+    "fontFamily",
+];
+/** The properties of `format` that differ from `base` (the run's own contribution). */
+var diffFormat = function (format, base) {
+    var e_2, _a;
+    var diff = {};
+    try {
+        for (var TEXT_KEYS_1 = tslib_1.__values(TEXT_KEYS), TEXT_KEYS_1_1 = TEXT_KEYS_1.next(); !TEXT_KEYS_1_1.done; TEXT_KEYS_1_1 = TEXT_KEYS_1.next()) {
+            var key = TEXT_KEYS_1_1.value;
+            var value = format[key];
+            var baseValue = base[key];
+            var normalizedValue = value !== null && value !== void 0 ? value : undefined;
+            var normalizedBase = baseValue !== null && baseValue !== void 0 ? baseValue : undefined;
+            if (normalizedValue === normalizedBase) {
+                continue;
+            }
+            if (normalizedValue === undefined || normalizedValue === false) {
+                // A run switching OFF a base property (bold cell, normal run).
+                if (normalizedBase) {
+                    diff[key] =
+                        key === "baselineOffset" ? null : false;
+                }
+                continue;
+            }
+            // Black on an unstyled base is the default text color, not a run color.
+            if (key === "color" &&
+                normalizedBase === undefined &&
+                typeof normalizedValue === "string" &&
+                normalizedValue.toUpperCase() === "#000000") {
+                continue;
+            }
+            diff[key] = normalizedValue;
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (TEXT_KEYS_1_1 && !TEXT_KEYS_1_1.done && (_a = TEXT_KEYS_1.return)) _a.call(TEXT_KEYS_1);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    return diff;
+};
+var sameFormat = function (a, b) {
+    var e_3, _a;
+    var keys = new Set(tslib_1.__spreadArray(tslib_1.__spreadArray([], tslib_1.__read(Object.keys(a)), false), tslib_1.__read(Object.keys(b)), false));
+    try {
+        for (var keys_1 = tslib_1.__values(keys), keys_1_1 = keys_1.next(); !keys_1_1.done; keys_1_1 = keys_1.next()) {
+            var key = keys_1_1.value;
+            var av = a[key];
+            var bv = b[key];
+            if (key === "link") {
+                if ((av === null || av === void 0 ? void 0 : av.uri) !== (bv === null || bv === void 0 ? void 0 : bv.uri)) {
+                    return false;
+                }
+                continue;
+            }
+            if (av !== bv) {
+                return false;
+            }
+        }
+    }
+    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+    finally {
+        try {
+            if (keys_1_1 && !keys_1_1.done && (_a = keys_1.return)) _a.call(keys_1);
+        }
+        finally { if (e_3) throw e_3.error; }
+    }
+    return true;
+};
+var isEmptyFormat = function (format) {
+    return Object.keys(format).length === 0;
+};
+/**
+ * Convert a mounted element (a clipboard `<td>`, or the sandbox wrapper for
+ * table-less HTML) into the engine's rich-text shape. See the module doc.
+ */
+var htmlElementToRichText = function (root) {
+    var e_4, _a, e_5, _b;
+    var _c, _d, _e;
+    var baseFormat = normalizeBase(readElementFormat(root, {}));
+    var segments = [];
+    try {
+        for (var _f = tslib_1.__values(Array.from(root.childNodes)), _g = _f.next(); !_g.done; _g = _f.next()) {
+            var child = _g.value;
+            collectSegments(child, baseFormat, segments);
+        }
+    }
+    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+    finally {
+        try {
+            if (_g && !_g.done && (_a = _f.return)) _a.call(_f);
+        }
+        finally { if (e_4) throw e_4.error; }
+    }
+    // Trim outer whitespace (leading/trailing spaces and line breaks) so the
+    // text matches `extractTextContent`, shifting the segments with it.
+    var joined = segments.map(function (s) { return s.text; }).join("");
+    var leading = joined.length - joined.trimStart().length;
+    var text = joined.trim();
+    var runs = [];
+    var links = [];
+    var cursor = -leading;
+    try {
+        for (var segments_1 = tslib_1.__values(segments), segments_1_1 = segments_1.next(); !segments_1_1.done; segments_1_1 = segments_1.next()) {
+            var segment = segments_1_1.value;
+            var start = Math.max(0, cursor);
+            var end = Math.min(text.length, cursor + segment.text.length);
+            cursor += segment.text.length;
+            if (end <= start) {
+                continue;
+            }
+            var format = diffFormat(segment.format, baseFormat);
+            var uri = (_c = segment.format.link) === null || _c === void 0 ? void 0 : _c.uri;
+            if (uri) {
+                format.link = { uri: uri };
+                var previous_1 = links[links.length - 1];
+                if (previous_1 && previous_1.uri === uri && previous_1.endIndex === start) {
+                    previous_1.endIndex = end;
+                }
+                else {
+                    links.push({ startIndex: start, endIndex: end, uri: uri });
+                }
+            }
+            if (isEmptyFormat(format)) {
+                continue;
+            }
+            var previous = runs[runs.length - 1];
+            if (previous &&
+                previous.nodeType === "text" &&
+                previous.endIndex === start &&
+                sameFormat(previous.format, format)) {
+                previous.endIndex = end;
+                continue;
+            }
+            runs.push({ startIndex: start, endIndex: end, format: format, nodeType: "text" });
+        }
+    }
+    catch (e_5_1) { e_5 = { error: e_5_1 }; }
+    finally {
+        try {
+            if (segments_1_1 && !segments_1_1.done && (_b = segments_1.return)) _b.call(segments_1);
+        }
+        finally { if (e_5) throw e_5.error; }
+    }
+    var wholeTextLink = links.find(function (link) { return link.startIndex === 0 && link.endIndex === text.length; });
+    var hyperlink = (_d = wholeTextLink === null || wholeTextLink === void 0 ? void 0 : wholeTextLink.uri) !== null && _d !== void 0 ? _d : (_e = links[0]) === null || _e === void 0 ? void 0 : _e.uri;
+    return {
+        text: text,
+        runs: runs.length ? runs : undefined,
+        links: links,
+        hyperlink: hyperlink,
+        baseFormat: baseFormat,
+        isRich: runs.length > 0 || links.length > 0,
+    };
+};
+exports.htmlElementToRichText = htmlElementToRichText;
+// The base drops the segment-only `link` key and `false`/`null` values — a
+// container can't be "not bold" more than the default already is.
+var normalizeBase = function (format) {
+    var e_6, _a;
+    var base = {};
+    try {
+        for (var TEXT_KEYS_2 = tslib_1.__values(TEXT_KEYS), TEXT_KEYS_2_1 = TEXT_KEYS_2.next(); !TEXT_KEYS_2_1.done; TEXT_KEYS_2_1 = TEXT_KEYS_2.next()) {
+            var key = TEXT_KEYS_2_1.value;
+            var value = format[key];
+            if (value === undefined || value === null || value === false) {
+                continue;
+            }
+            base[key] = value;
+        }
+    }
+    catch (e_6_1) { e_6 = { error: e_6_1 }; }
+    finally {
+        try {
+            if (TEXT_KEYS_2_1 && !TEXT_KEYS_2_1.done && (_a = TEXT_KEYS_2.return)) _a.call(TEXT_KEYS_2);
+        }
+        finally { if (e_6) throw e_6.error; }
+    }
+    return base;
+};
+/**
+ * The element a single-cell clipboard payload's text lives in: the lone
+ * `<td>`/`<th>` of a one-cell table (Excel / Google Sheets), or the mounted
+ * wrapper for table-less HTML. `undefined` for a multi-cell table — that is a
+ * grid paste, not a rich-text one.
+ */
+var findSingleClipboardCell = function (root) {
+    var cells = root.querySelectorAll("td,th");
+    if (cells.length > 1) {
+        return undefined;
+    }
+    if (cells.length === 1) {
+        return cells[0];
+    }
+    return root;
+};
+exports.findSingleClipboardCell = findSingleClipboardCell;
+/**
+ * One-shot helper for the editor targets: mount the clipboard HTML, convert
+ * the single cell it carries, clean up. `undefined` when the payload is a
+ * multi-cell table or carries no formatting/links worth keeping (the caller
+ * then falls back to its plain-text handling).
+ */
+var clipboardHtmlToRichText = function (html) {
+    if (!dom_1.canUseDOM || !(html === null || html === void 0 ? void 0 : html.trim())) {
+        return undefined;
+    }
+    var _a = (0, exports.mountClipboardHtml)(html), root = _a.root, cleanup = _a.cleanup;
+    try {
+        var cell = (0, exports.findSingleClipboardCell)(root);
+        if (!cell) {
+            return undefined;
+        }
+        var parsed = (0, exports.htmlElementToRichText)(cell);
+        if (!parsed.text || !parsed.isRich) {
+            return undefined;
+        }
+        return parsed;
+    }
+    finally {
+        cleanup();
+    }
+};
+exports.clipboardHtmlToRichText = clipboardHtmlToRichText;

package/dist/cjs/rich-text-links.d.ts

@@ -0,0 +1,23 @@
+import type { TextFormatRun } from "@rowsncolumns/common-types";
+/**
+ * Reconcile a committed string's run-level links (`TextFormatRun.format.link`)
+ * with the cell-level `hyperlink`. Excel keeps ONE link per cell, painted and
+ * followed at the cell level; Google Sheets keeps several inside the text.
+ * Both engines apply this on commit (`SheetCell.setStringValue`, rnc-store
+ * `apply_set_value_rich_text`) so a rich paste lands the same way whether it
+ * came through the grid, the formula bar or the in-cell editor:
+ *
+ * - a cell without a hyperlink takes the FIRST run link as its hyperlink;
+ * - a run link equal to the cell hyperlink that spans the WHOLE text is
+ *   redundant (that is exactly what the cell hyperlink says) and is stripped
+ *   — the run itself goes when nothing else is left on it;
+ * - every other run link stays as data (the multi-link cell keeps them all).
+ */
+export type ResolvedRunLinks = {
+    runs: TextFormatRun[] | undefined | null;
+    hyperlink: string | undefined;
+    /** True when `runs` or `hyperlink` differ from the input. */
+    changed: boolean;
+};
+export declare const promoteRunLinkToHyperlink: (text: string, runs: TextFormatRun[] | undefined | null, hyperlink: string | undefined | null) => ResolvedRunLinks;
+//# sourceMappingURL=rich-text-links.d.ts.map

package/dist/cjs/rich-text-links.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rich-text-links.d.ts","sourceRoot":"","sources":["../../rich-text-links.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAEhE;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAC7B,IAAI,EAAE,aAAa,EAAE,GAAG,SAAS,GAAG,IAAI,CAAC;IACzC,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B,6DAA6D;IAC7D,OAAO,EAAE,OAAO,CAAC;CAClB,CAAC;AAEF,eAAO,MAAM,yBAAyB,GACpC,MAAM,MAAM,EACZ,MAAM,aAAa,EAAE,GAAG,SAAS,GAAG,IAAI,EACxC,WAAW,MAAM,GAAG,SAAS,GAAG,IAAI,KACnC,gBAkCF,CAAC"}

package/dist/cjs/rich-text-links.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promoteRunLinkToHyperlink = void 0;
+var tslib_1 = require("tslib");
+var promoteRunLinkToHyperlink = function (text, runs, hyperlink) {
+    var e_1, _a;
+    var _b, _c;
+    if (!runs || runs.length === 0) {
+        return { runs: runs, hyperlink: hyperlink !== null && hyperlink !== void 0 ? hyperlink : undefined, changed: false };
+    }
+    var firstLink = runs.find(function (run) { var _a, _b; return run.nodeType !== "mention" && ((_b = (_a = run.format) === null || _a === void 0 ? void 0 : _a.link) === null || _b === void 0 ? void 0 : _b.uri); });
+    if (!firstLink || firstLink.nodeType === "mention") {
+        return { runs: runs, hyperlink: hyperlink !== null && hyperlink !== void 0 ? hyperlink : undefined, changed: false };
+    }
+    var resolvedHyperlink = hyperlink || firstLink.format.link.uri;
+    var changed = resolvedHyperlink !== (hyperlink !== null && hyperlink !== void 0 ? hyperlink : undefined);
+    var stripped = [];
+    try {
+        for (var runs_1 = tslib_1.__values(runs), runs_1_1 = runs_1.next(); !runs_1_1.done; runs_1_1 = runs_1.next()) {
+            var run = runs_1_1.value;
+            if (run.nodeType === "mention" ||
+                ((_c = (_b = run.format) === null || _b === void 0 ? void 0 : _b.link) === null || _c === void 0 ? void 0 : _c.uri) !== resolvedHyperlink ||
+                run.startIndex !== 0 ||
+                run.endIndex < text.length) {
+                stripped.push(run);
+                continue;
+            }
+            changed = true;
+            var _d = run.format, _link = _d.link, rest = tslib_1.__rest(_d, ["link"]);
+            if (Object.keys(rest).length > 0) {
+                stripped.push(tslib_1.__assign(tslib_1.__assign({}, run), { format: rest }));
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (runs_1_1 && !runs_1_1.done && (_a = runs_1.return)) _a.call(runs_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return {
+        runs: changed ? (stripped.length ? stripped : undefined) : runs,
+        hyperlink: resolvedHyperlink,
+        changed: changed,
+    };
+};
+exports.promoteRunLinkToHyperlink = promoteRunLinkToHyperlink;