@pallasoft/ps-utilities 2.22.0 → 2.23.0

package/dist/common/portable-text-html-service.js

@@ -0,0 +1,392 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < 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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PortableTextHtmlService = void 0;
+var html_heading_styles_1 = require("./constants/html-heading-styles");
+var html_text_config_1 = require("./constants/html-text-config");
+var html_token_kind_1 = require("./constants/html-token-kind");
+var portable_text_config_1 = require("./constants/portable-text-config");
+var html_entity_service_1 = require("./html-entity-service");
+var html_style_service_1 = require("./html-style-service");
+var html_token_service_1 = require("./html-token-service");
+var portable_text_link_service_1 = require("./portable-text-link-service");
+var portable_text_tracking_service_1 = require("./portable-text-tracking-service");
+var PortableTextHtmlService = /** @class */ (function () {
+    function PortableTextHtmlService() {
+    }
+    PortableTextHtmlService.fromHtml = function (html) {
+        var state = {
+            blocks: [],
+            counter: 0,
+            lists: [],
+            pending: [],
+            skipDepth: 0,
+            skipName: null,
+            stack: [PortableTextHtmlService.rootFrame()],
+        };
+        html_token_service_1.HtmlTokenService.tokenize(html).forEach(function (token) {
+            return PortableTextHtmlService.consume(state, token);
+        });
+        PortableTextHtmlService.flush(state);
+        return portable_text_tracking_service_1.PortableTextTrackingService.stripUrlLines(state.blocks);
+    };
+    PortableTextHtmlService.rootFrame = function () {
+        return {
+            code: false,
+            em: false,
+            heading: null,
+            href: null,
+            isQuote: false,
+            listLevel: null,
+            name: html_text_config_1.HtmlTextConfig.rootName,
+            ordered: false,
+            size: null,
+            strong: false,
+            underline: false,
+        };
+    };
+    PortableTextHtmlService.consume = function (state, token) {
+        if (token.kind === html_token_kind_1.HtmlTokenKind.Text) {
+            if (state.skipName === null)
+                PortableTextHtmlService.addText(state, token.text);
+            return;
+        }
+        if (token.kind === html_token_kind_1.HtmlTokenKind.Open)
+            PortableTextHtmlService.open(state, token);
+        else
+            PortableTextHtmlService.close(state, token.name);
+    };
+    PortableTextHtmlService.isVoid = function (token) {
+        return html_text_config_1.HtmlTextConfig.voidTags.includes(token.name) || token.selfClosing;
+    };
+    PortableTextHtmlService.isBlockTag = function (name) {
+        return (html_text_config_1.HtmlTextConfig.blockTags.includes(name) ||
+            Object.prototype.hasOwnProperty.call(html_heading_styles_1.HtmlHeadingStyles, name) ||
+            name === html_text_config_1.HtmlTextConfig.quoteTag ||
+            name === html_text_config_1.HtmlTextConfig.listItemTag ||
+            name === html_text_config_1.HtmlTextConfig.orderedListTag ||
+            name === html_text_config_1.HtmlTextConfig.unorderedListTag);
+    };
+    PortableTextHtmlService.isHidden = function (token, declarations) {
+        var attributes = token.attributes;
+        return (html_text_config_1.HtmlTextConfig.skipTags.includes(token.name) ||
+            Object.prototype.hasOwnProperty.call(attributes, html_text_config_1.HtmlTextConfig.hiddenAttribute) ||
+            attributes[html_text_config_1.HtmlTextConfig.aria] === html_text_config_1.HtmlTextConfig.hiddenAria ||
+            html_text_config_1.HtmlTextConfig.hiddenClassPattern.test(PortableTextHtmlService.attribute(attributes, html_text_config_1.HtmlTextConfig.classAttribute)) ||
+            html_style_service_1.HtmlStyleService.isHidden(declarations));
+    };
+    PortableTextHtmlService.attribute = function (attributes, name) {
+        return Object.prototype.hasOwnProperty.call(attributes, name) ? attributes[name] : '';
+    };
+    PortableTextHtmlService.open = function (state, token) {
+        if (state.skipName !== null) {
+            if (token.name === state.skipName && !PortableTextHtmlService.isVoid(token))
+                state.skipDepth += 1;
+            return;
+        }
+        var declarations = html_style_service_1.HtmlStyleService.parse(PortableTextHtmlService.attribute(token.attributes, html_text_config_1.HtmlTextConfig.styleAttribute));
+        if (PortableTextHtmlService.isHidden(token, declarations)) {
+            if (!PortableTextHtmlService.isVoid(token)) {
+                state.skipName = token.name;
+                state.skipDepth = 1;
+            }
+            return;
+        }
+        if (token.name === html_text_config_1.HtmlTextConfig.breakTag) {
+            PortableTextHtmlService.lineBreak(state);
+            return;
+        }
+        if (token.name === html_text_config_1.HtmlTextConfig.imageTag) {
+            PortableTextHtmlService.image(state, token, declarations);
+            return;
+        }
+        var isBlock = PortableTextHtmlService.isBlockTag(token.name) || token.name === html_text_config_1.HtmlTextConfig.ruleTag;
+        if (isBlock)
+            PortableTextHtmlService.flush(state);
+        if (PortableTextHtmlService.isVoid(token))
+            return;
+        if (token.name === html_text_config_1.HtmlTextConfig.listItemTag)
+            PortableTextHtmlService.closeOpenItem(state);
+        if (token.name === html_text_config_1.HtmlTextConfig.orderedListTag)
+            state.lists.push(true);
+        if (token.name === html_text_config_1.HtmlTextConfig.unorderedListTag)
+            state.lists.push(false);
+        state.stack.push(PortableTextHtmlService.frame(state, token, declarations));
+    };
+    PortableTextHtmlService.closeOpenItem = function (state) {
+        while (state.stack[state.stack.length - 1].name === html_text_config_1.HtmlTextConfig.listItemTag)
+            state.stack.pop();
+    };
+    PortableTextHtmlService.frame = function (state, token, declarations) {
+        var parent = state.stack[state.stack.length - 1];
+        var name = token.name;
+        var isLink = name === html_text_config_1.HtmlTextConfig.linkTag;
+        var hasHref = Object.prototype.hasOwnProperty.call(token.attributes, html_text_config_1.HtmlTextConfig.hrefAttribute);
+        var size = html_style_service_1.HtmlStyleService.fontSize(declarations);
+        var isItem = name === html_text_config_1.HtmlTextConfig.listItemTag;
+        return {
+            code: html_text_config_1.HtmlTextConfig.codeTags.includes(name) || parent.code,
+            em: PortableTextHtmlService.resolve(parent.em, html_text_config_1.HtmlTextConfig.emTags.includes(name), html_style_service_1.HtmlStyleService.italic(declarations)),
+            heading: Object.prototype.hasOwnProperty.call(html_heading_styles_1.HtmlHeadingStyles, name)
+                ? html_heading_styles_1.HtmlHeadingStyles[name]
+                : null,
+            href: isLink && hasHref
+                ? portable_text_link_service_1.PortableTextLinkService.normalize(token.attributes[html_text_config_1.HtmlTextConfig.hrefAttribute])
+                : parent.href,
+            isQuote: name === html_text_config_1.HtmlTextConfig.quoteTag,
+            listLevel: isItem
+                ? Math.min(Math.max(state.lists.length, html_text_config_1.HtmlTextConfig.bodyListLevel), portable_text_config_1.PortableTextConfig.maxListLevel)
+                : null,
+            name: name,
+            ordered: isItem && state.lists.length > 0 && state.lists[state.lists.length - 1],
+            size: size !== null ? size : parent.size,
+            strong: PortableTextHtmlService.resolve(parent.strong, html_text_config_1.HtmlTextConfig.strongTags.includes(name), html_style_service_1.HtmlStyleService.bold(declarations)),
+            underline: isLink
+                ? parent.underline
+                : PortableTextHtmlService.resolve(parent.underline, html_text_config_1.HtmlTextConfig.underlineTags.includes(name), html_style_service_1.HtmlStyleService.underline(declarations)),
+        };
+    };
+    PortableTextHtmlService.resolve = function (inherited, byTag, byStyle) {
+        if (byStyle !== null)
+            return byStyle;
+        return byTag || inherited;
+    };
+    PortableTextHtmlService.close = function (state, name) {
+        if (state.skipName !== null) {
+            if (name === state.skipName) {
+                state.skipDepth -= 1;
+                if (state.skipDepth === 0)
+                    state.skipName = null;
+            }
+            return;
+        }
+        var index = state.stack.length - 1;
+        while (index > 0 && state.stack[index].name !== name)
+            index -= 1;
+        if (index === 0)
+            return;
+        if (PortableTextHtmlService.isBlockTag(name))
+            PortableTextHtmlService.flush(state);
+        if (name === html_text_config_1.HtmlTextConfig.orderedListTag || name === html_text_config_1.HtmlTextConfig.unorderedListTag)
+            state.lists.pop();
+        state.stack.length = index;
+    };
+    PortableTextHtmlService.addText = function (state, raw) {
+        var isPre = state.stack.some(function (frame) { return frame.name === html_text_config_1.HtmlTextConfig.preTag; });
+        var cleaned = html_entity_service_1.HtmlEntityService.decode(raw).replace(html_text_config_1.HtmlTextConfig.invisiblePattern, '');
+        var text = isPre
+            ? cleaned
+                .replace(html_text_config_1.HtmlTextConfig.preLineBreakPattern, html_text_config_1.HtmlTextConfig.newline)
+                .replace(html_text_config_1.HtmlTextConfig.nonBreakingPattern, html_text_config_1.HtmlTextConfig.space)
+            : cleaned.replace(html_text_config_1.HtmlTextConfig.whitespacePattern, html_text_config_1.HtmlTextConfig.space);
+        if (!isPre) {
+            var last = state.pending[state.pending.length - 1];
+            var atStart = last === undefined ||
+                last.text.endsWith(html_text_config_1.HtmlTextConfig.space) ||
+                last.text.endsWith(html_text_config_1.HtmlTextConfig.newline);
+            if (atStart)
+                text = text.replace(html_text_config_1.HtmlTextConfig.leadingSpacePattern, '');
+        }
+        if (text !== '')
+            PortableTextHtmlService.push(state, text);
+    };
+    PortableTextHtmlService.push = function (state, text) {
+        var frame = state.stack[state.stack.length - 1];
+        state.pending.push({
+            code: frame.code,
+            em: frame.em,
+            href: frame.href,
+            size: frame.size,
+            strong: frame.strong,
+            text: text,
+            underline: frame.underline,
+        });
+    };
+    PortableTextHtmlService.lineBreak = function (state) {
+        var last = state.pending[state.pending.length - 1];
+        if (last === undefined)
+            return;
+        if (last.text.endsWith(html_text_config_1.HtmlTextConfig.newline)) {
+            PortableTextHtmlService.flush(state);
+            return;
+        }
+        last.text = last.text.replace(html_text_config_1.HtmlTextConfig.trailingSpacePattern, '');
+        PortableTextHtmlService.push(state, html_text_config_1.HtmlTextConfig.newline);
+    };
+    PortableTextHtmlService.image = function (state, token, declarations) {
+        var src = portable_text_link_service_1.PortableTextLinkService.normalizeImage(PortableTextHtmlService.attribute(token.attributes, html_text_config_1.HtmlTextConfig.srcAttribute));
+        if (src === null || PortableTextHtmlService.isTiny(token.attributes, declarations))
+            return;
+        var alt = html_entity_service_1.HtmlEntityService.decode(PortableTextHtmlService.attribute(token.attributes, html_text_config_1.HtmlTextConfig.altAttribute))
+            .replace(html_text_config_1.HtmlTextConfig.invisiblePattern, '')
+            .replace(html_text_config_1.HtmlTextConfig.whitespacePattern, html_text_config_1.HtmlTextConfig.space)
+            .trim()
+            .slice(0, portable_text_config_1.PortableTextConfig.maxImageAltLength);
+        PortableTextHtmlService.flush(state);
+        state.blocks.push({
+            _key: PortableTextHtmlService.key(state, portable_text_config_1.PortableTextConfig.keyPrefix.image),
+            _type: portable_text_config_1.PortableTextConfig.imageType,
+            alt: alt,
+            src: src,
+        });
+    };
+    PortableTextHtmlService.isTiny = function (attributes, declarations) {
+        var sizes = [html_text_config_1.HtmlTextConfig.widthAttribute, html_text_config_1.HtmlTextConfig.heightAttribute].map(function (name) {
+            return Number.parseFloat(PortableTextHtmlService.attribute(attributes, name));
+        });
+        return (sizes.some(function (size) { return !Number.isNaN(size) && size <= html_text_config_1.HtmlTextConfig.tinyImageSize; }) ||
+            html_style_service_1.HtmlStyleService.isTiny(declarations));
+    };
+    PortableTextHtmlService.key = function (state, prefix) {
+        var key = "".concat(prefix).concat(state.counter);
+        state.counter += 1;
+        return key;
+    };
+    PortableTextHtmlService.context = function (state) {
+        var context = {
+            heading: null,
+            isQuote: false,
+            listLevel: null,
+            ordered: false,
+        };
+        for (var index = state.stack.length - 1; index > 0; index -= 1) {
+            var frame = state.stack[index];
+            if (context.heading === null && frame.heading !== null)
+                context.heading = frame.heading;
+            if (frame.isQuote)
+                context.isQuote = true;
+            if (context.listLevel === null && frame.listLevel !== null) {
+                context.listLevel = frame.listLevel;
+                context.ordered = frame.ordered;
+            }
+        }
+        return context;
+    };
+    PortableTextHtmlService.trimmed = function (runs) {
+        var kept = runs.filter(function (run) { return run.text !== ''; });
+        while (kept.length > 0) {
+            var last = kept[kept.length - 1];
+            last.text = last.text.replace(html_text_config_1.HtmlTextConfig.trailingBreakPattern, '');
+            if (last.text !== '')
+                break;
+            kept.pop();
+        }
+        while (kept.length > 0) {
+            var first = kept[0];
+            first.text = first.text.replace(html_text_config_1.HtmlTextConfig.leadingBreakPattern, '');
+            if (first.text !== '')
+                break;
+            kept.shift();
+        }
+        return kept;
+    };
+    PortableTextHtmlService.flush = function (state) {
+        var runs = PortableTextHtmlService.trimmed(state.pending);
+        state.pending = [];
+        if (runs.length === 0)
+            return;
+        var context = PortableTextHtmlService.context(state);
+        var heading = PortableTextHtmlService.headingOf(runs, context);
+        var markDefs = [];
+        var children = PortableTextHtmlService.merge(runs, heading !== null).map(function (span) { return ({
+            _key: PortableTextHtmlService.key(state, portable_text_config_1.PortableTextConfig.keyPrefix.span),
+            _type: portable_text_config_1.PortableTextConfig.spanType,
+            marks: PortableTextHtmlService.marks(state, span, markDefs),
+            text: span.text,
+        }); });
+        var level = context.listLevel;
+        var base = {
+            _key: PortableTextHtmlService.key(state, portable_text_config_1.PortableTextConfig.keyPrefix.block),
+            _type: portable_text_config_1.PortableTextConfig.blockType,
+            children: children,
+            markDefs: markDefs,
+            style: PortableTextHtmlService.styleOf(context, heading),
+        };
+        state.blocks.push(level !== null && heading === null
+            ? __assign(__assign({}, base), { level: level, listItem: context.ordered
+                    ? portable_text_config_1.PortableTextConfig.numberItem
+                    : portable_text_config_1.PortableTextConfig.bulletItem }) : base);
+    };
+    PortableTextHtmlService.styleOf = function (context, heading) {
+        if (heading !== null)
+            return heading;
+        if (context.listLevel !== null)
+            return portable_text_config_1.PortableTextConfig.normalStyle;
+        return context.isQuote ? portable_text_config_1.PortableTextConfig.quoteStyle : portable_text_config_1.PortableTextConfig.normalStyle;
+    };
+    PortableTextHtmlService.headingOf = function (runs, context) {
+        if (context.heading !== null)
+            return context.heading;
+        if (context.listLevel !== null || context.isQuote)
+            return null;
+        var text = runs.map(function (run) { return run.text; }).join('');
+        if (text.includes(html_text_config_1.HtmlTextConfig.newline) || text.length > html_text_config_1.HtmlTextConfig.largeText.maxLength)
+            return null;
+        var filled = runs.filter(function (run) { return run.text.trim() !== ''; });
+        var sizes = filled.map(function (run) { return run.size; });
+        if (sizes.every(function (size) { return size !== null; })) {
+            var smallest = Math.min.apply(Math, sizes);
+            if (smallest >= html_text_config_1.HtmlTextConfig.largeText.heading1)
+                return portable_text_config_1.PortableTextConfig.headingStyles[0];
+            if (smallest >= html_text_config_1.HtmlTextConfig.largeText.heading2)
+                return portable_text_config_1.PortableTextConfig.headingStyles[1];
+            if (smallest >= html_text_config_1.HtmlTextConfig.largeText.heading3)
+                return portable_text_config_1.PortableTextConfig.headingStyles[2];
+        }
+        var isBold = filled.every(function (run) { return run.strong && run.href === null; }) &&
+            text.length <= html_text_config_1.HtmlTextConfig.boldHeadingMaxLength &&
+            !html_text_config_1.HtmlTextConfig.headingEndPattern.test(text.trim());
+        return isBold ? portable_text_config_1.PortableTextConfig.headingStyles[2] : null;
+    };
+    PortableTextHtmlService.merge = function (runs, dropStrong) {
+        var merged = [];
+        runs.forEach(function (run) {
+            var next = dropStrong ? __assign(__assign({}, run), { strong: false }) : __assign({}, run);
+            var last = merged[merged.length - 1];
+            if (last !== undefined &&
+                last.strong === next.strong &&
+                last.em === next.em &&
+                last.underline === next.underline &&
+                last.code === next.code &&
+                last.href === next.href) {
+                last.text += next.text;
+                return;
+            }
+            merged.push(next);
+        });
+        return merged;
+    };
+    PortableTextHtmlService.marks = function (state, span, markDefs) {
+        var marks = [];
+        if (span.strong)
+            marks.push(portable_text_config_1.PortableTextConfig.decorators[0]);
+        if (span.em)
+            marks.push(portable_text_config_1.PortableTextConfig.decorators[1]);
+        if (span.underline)
+            marks.push(portable_text_config_1.PortableTextConfig.decorators[2]);
+        if (span.code)
+            marks.push(portable_text_config_1.PortableTextConfig.decorators[3]);
+        if (span.href === null)
+            return marks;
+        var existing = markDefs.find(function (definition) { return definition.href === span.href; });
+        var key = existing !== undefined
+            ? existing._key
+            : PortableTextHtmlService.key(state, portable_text_config_1.PortableTextConfig.keyPrefix.link);
+        if (existing === undefined)
+            markDefs.push({ _key: key, _type: portable_text_config_1.PortableTextConfig.linkType, href: span.href });
+        marks.push(key);
+        return marks;
+    };
+    return PortableTextHtmlService;
+}());
+exports.PortableTextHtmlService = PortableTextHtmlService;

package/dist/common/portable-text-link-service.d.ts

@@ -0,0 +1,7 @@
+export declare class PortableTextLinkService {
+    static isSafe(href: string): boolean;
+    static normalize(raw: string | undefined): string | null;
+    static isSafeImage(src: string): boolean;
+    static normalizeImage(raw: string | undefined): string | null;
+    private static isControl;
+}

package/dist/common/portable-text-link-service.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PortableTextLinkService = void 0;
+var portable_text_config_1 = require("./constants/portable-text-config");
+var PortableTextLinkService = /** @class */ (function () {
+    function PortableTextLinkService() {
+    }
+    PortableTextLinkService.isSafe = function (href) {
+        try {
+            return portable_text_config_1.PortableTextConfig.linkProtocols.includes(new URL(href).protocol);
+        }
+        catch (_a) {
+            return false;
+        }
+    };
+    PortableTextLinkService.normalize = function (raw) {
+        if (typeof raw !== 'string')
+            return null;
+        var href = Array.from(raw)
+            .filter(function (character) { return !PortableTextLinkService.isControl(character); })
+            .join('')
+            .trim();
+        return href !== '' && PortableTextLinkService.isSafe(href) ? href : null;
+    };
+    PortableTextLinkService.isSafeImage = function (src) {
+        return PortableTextLinkService.normalizeImage(src) === src;
+    };
+    PortableTextLinkService.normalizeImage = function (raw) {
+        var src = PortableTextLinkService.normalize(raw);
+        return src !== null &&
+            portable_text_config_1.PortableTextConfig.imageProtocolPattern.test(src) &&
+            src.length <= portable_text_config_1.PortableTextConfig.maxImageSrcLength
+            ? src
+            : null;
+    };
+    PortableTextLinkService.isControl = function (character) {
+        var code = character.charCodeAt(0);
+        return code <= portable_text_config_1.PortableTextConfig.maxControlCode || code === portable_text_config_1.PortableTextConfig.deleteCode;
+    };
+    return PortableTextLinkService;
+}());
+exports.PortableTextLinkService = PortableTextLinkService;

package/dist/common/portable-text-service.d.ts

@@ -1,9 +1,12 @@
 import type { PortableTextBlock } from '@portabletext/types';
+import type { PortableTextContentData } from '../models/portable-text-content-data';
 export declare class PortableTextService {
-    static toPlainText(blocks: PortableTextBlock[]): string;
+    static toPlainText(blocks: PortableTextContentData[]): string;
     static fromPlainText(text: string): PortableTextBlock[];
-    static isEmpty(blocks: PortableTextBlock[] | null | undefined): boolean;
-    static toHtml(blocks: PortableTextBlock[]): string;
+    static fromHtml(html: string): PortableTextContentData[];
+    static isEmpty(blocks: PortableTextContentData[] | null | undefined): boolean;
+    static toHtml(blocks: PortableTextContentData[]): string;
     private static blockText;
-    private static isSafeLink;
+    static isSafeLink(href: string): boolean;
+    static isSafeImage(src: string): boolean;
 }

package/dist/common/portable-text-service.js

@@ -4,6 +4,8 @@ exports.PortableTextService = void 0;
 var ps_models_1 = require("@pallasoft/ps-models");
 var to_html_1 = require("@portabletext/to-html");
 var portable_text_config_1 = require("./constants/portable-text-config");
+var portable_text_html_service_1 = require("./portable-text-html-service");
+var portable_text_link_service_1 = require("./portable-text-link-service");
 var PortableTextService = /** @class */ (function () {
     function PortableTextService() {
     }
@@ -13,7 +15,7 @@ var PortableTextService = /** @class */ (function () {
         var counters = {};
         var previousWasList = false;
         blocks.forEach(function (block) {
-            if (block._type !== ps_models_1.Common.PortableTextConfig.blockType)
+            if (!('children' in block) || block._type !== ps_models_1.Common.PortableTextConfig.blockType)
                 return;
             var text = _this.blockText(block);
             var level = typeof block.level === 'number' ? block.level : 1;
@@ -65,20 +67,25 @@ var PortableTextService = /** @class */ (function () {
             ],
         }); });
     };
+    PortableTextService.fromHtml = function (html) {
+        return portable_text_html_service_1.PortableTextHtmlService.fromHtml(html);
+    };
     PortableTextService.isEmpty = function (blocks) {
         var _this = this;
-        return (!Array.isArray(blocks) || blocks.every(function (block) { return _this.blockText(block).trim().length === 0; }));
+        return (!Array.isArray(blocks) ||
+            blocks.every(function (block) { return !('children' in block) || _this.blockText(block).trim().length === 0; }));
     };
     PortableTextService.toHtml = function (blocks) {
-        var _this = this;
+        var _a;
         return (0, to_html_1.toHTML)(blocks, {
             onMissingComponent: false,
             components: {
+                types: (_a = {}, _a[portable_text_config_1.PortableTextConfig.imageType] = function () { return ''; }, _a),
                 marks: {
                     link: function (_a) {
                         var children = _a.children, value = _a.value;
                         var href = typeof (value === null || value === void 0 ? void 0 : value.href) === 'string' ? value.href : '';
-                        return _this.isSafeLink(href)
+                        return PortableTextService.isSafeLink(href)
                             ? "<a href=\"".concat((0, to_html_1.escapeHTML)(href), "\" rel=\"").concat(portable_text_config_1.PortableTextConfig.linkRel, "\" target=\"").concat(portable_text_config_1.PortableTextConfig.linkTarget, "\">").concat(children, "</a>")
                             : children;
                     },
@@ -98,12 +105,10 @@ var PortableTextService = /** @class */ (function () {
             : '';
     };
     PortableTextService.isSafeLink = function (href) {
-        try {
-            return ps_models_1.Common.PortableTextConfig.linkProtocols.includes(new URL(href).protocol);
-        }
-        catch (_a) {
-            return false;
-        }
+        return portable_text_link_service_1.PortableTextLinkService.isSafe(href);
+    };
+    PortableTextService.isSafeImage = function (src) {
+        return portable_text_link_service_1.PortableTextLinkService.isSafeImage(src);
     };
     return PortableTextService;
 }());

package/dist/common/portable-text-tracking-service.d.ts

@@ -0,0 +1,7 @@
+import type { PortableTextContentData } from '../models/portable-text-content-data';
+export declare class PortableTextTrackingService {
+    static stripUrlLines(blocks: PortableTextContentData[]): PortableTextContentData[];
+    private static hrefs;
+    private static isDuplicate;
+    private static matches;
+}

package/dist/common/portable-text-tracking-service.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PortableTextTrackingService = void 0;
+var html_text_config_1 = require("./constants/html-text-config");
+var portable_text_config_1 = require("./constants/portable-text-config");
+var PortableTextTrackingService = /** @class */ (function () {
+    function PortableTextTrackingService() {
+    }
+    PortableTextTrackingService.stripUrlLines = function (blocks) {
+        var hrefs = PortableTextTrackingService.hrefs(blocks);
+        return blocks.filter(function (block) { return !PortableTextTrackingService.isDuplicate(block, hrefs); });
+    };
+    PortableTextTrackingService.hrefs = function (blocks) {
+        return blocks.flatMap(function (block) {
+            return 'children' in block && Array.isArray(block.markDefs)
+                ? block.markDefs.flatMap(function (definition) {
+                    return typeof definition.href === 'string' ? [definition.href] : [];
+                })
+                : [];
+        });
+    };
+    PortableTextTrackingService.isDuplicate = function (block, hrefs) {
+        if (!('children' in block) || !Array.isArray(block.children))
+            return false;
+        if (block.style !== portable_text_config_1.PortableTextConfig.normalStyle || typeof block.listItem === 'string')
+            return false;
+        var text = block.children
+            .map(function (child) { return (typeof child.text === 'string' ? child.text : ''); })
+            .join('')
+            .trim();
+        var match = html_text_config_1.HtmlTextConfig.trackingLinePattern.exec(text);
+        return (match !== null && hrefs.some(function (href) { return PortableTextTrackingService.matches(href, match[1]); }));
+    };
+    PortableTextTrackingService.matches = function (href, shown) {
+        var ascii = shown.indexOf(html_text_config_1.HtmlTextConfig.trackingEllipsis);
+        var unicode = shown.indexOf(html_text_config_1.HtmlTextConfig.trackingEllipsisCharacter);
+        var index = ascii !== -1 ? ascii : unicode;
+        if (index === -1)
+            return href === shown || href.startsWith(shown);
+        var width = ascii !== -1 ? html_text_config_1.HtmlTextConfig.trackingEllipsis.length : 1;
+        return href.startsWith(shown.slice(0, index)) && href.endsWith(shown.slice(index + width));
+    };
+    return PortableTextTrackingService;
+}());
+exports.PortableTextTrackingService = PortableTextTrackingService;

package/dist/esm/common/constants/html-entity-names.js

@@ -0,0 +1,31 @@
+export const HtmlEntityNames = {
+    amp: '&',
+    lt: '<',
+    gt: '>',
+    quot: '"',
+    apos: "'",
+    nbsp: ' ',
+    ndash: '\u2013',
+    mdash: '\u2014',
+    hellip: '\u2026',
+    rsquo: '\u2019',
+    lsquo: '\u2018',
+    rdquo: '\u201D',
+    ldquo: '\u201C',
+    copy: '\u00A9',
+    reg: '\u00AE',
+    trade: '\u2122',
+    bull: '\u2022',
+    middot: '\u00B7',
+    euro: '\u20AC',
+    pound: '\u00A3',
+    yen: '\u00A5',
+    cent: '\u00A2',
+    laquo: '\u00AB',
+    raquo: '\u00BB',
+    times: '\u00D7',
+    deg: '\u00B0',
+    zwnj: '',
+    zwj: '',
+    shy: '',
+};

package/dist/esm/common/constants/html-heading-styles.js

@@ -0,0 +1,8 @@
+export const HtmlHeadingStyles = {
+    h1: 'h1',
+    h2: 'h2',
+    h3: 'h3',
+    h4: 'h3',
+    h5: 'h3',
+    h6: 'h3',
+};