@pallasoft/ps-utilities 2.22.0 → 2.23.0

package/dist/common/constants/html-entity-names.d.ts

@@ -0,0 +1 @@
+export declare const HtmlEntityNames: Record<string, string>;

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

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HtmlEntityNames = void 0;
+exports.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/common/constants/html-heading-styles.d.ts

@@ -0,0 +1 @@
+export declare const HtmlHeadingStyles: Record<string, string>;

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

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HtmlHeadingStyles = void 0;
+exports.HtmlHeadingStyles = {
+    h1: 'h1',
+    h2: 'h2',
+    h3: 'h3',
+    h4: 'h3',
+    h5: 'h3',
+    h6: 'h3',
+};

package/dist/common/constants/html-text-config.d.ts

@@ -0,0 +1,76 @@
+export declare const HtmlTextConfig: {
+    readonly skipTags: readonly ["head", "script", "style", "title", "noscript", "template", "svg", "iframe", "object", "embed", "video", "audio", "canvas", "select", "textarea"];
+    readonly rawTextTags: readonly ["script", "style", "title", "textarea"];
+    readonly voidTags: readonly ["area", "base", "br", "col", "embed", "hr", "img", "input", "link", "meta", "param", "source", "track", "wbr"];
+    readonly blockTags: readonly ["address", "article", "aside", "body", "center", "dd", "details", "div", "dl", "dt", "fieldset", "figcaption", "figure", "footer", "form", "header", "html", "main", "nav", "p", "pre", "section", "summary", "table", "tbody", "td", "tfoot", "th", "thead", "tr"];
+    readonly strongTags: readonly ["b", "strong"];
+    readonly emTags: readonly ["i", "em", "cite", "dfn"];
+    readonly underlineTags: readonly ["u", "ins"];
+    readonly codeTags: readonly ["code", "kbd", "samp", "tt"];
+    readonly linkTag: "a";
+    readonly imageTag: "img";
+    readonly breakTag: "br";
+    readonly ruleTag: "hr";
+    readonly preTag: "pre";
+    readonly quoteTag: "blockquote";
+    readonly listItemTag: "li";
+    readonly orderedListTag: "ol";
+    readonly unorderedListTag: "ul";
+    readonly hiddenClassPattern: RegExp;
+    readonly hiddenDisplay: "none";
+    readonly hiddenVisibility: "hidden";
+    readonly hiddenMso: "all";
+    readonly hiddenAttribute: "hidden";
+    readonly hiddenAria: "true";
+    readonly tinyImageSize: 2;
+    readonly importantPattern: RegExp;
+    readonly zeroPattern: RegExp;
+    readonly pixelPattern: RegExp;
+    readonly boldWeight: 600;
+    readonly largeText: {
+        readonly heading3: 20;
+        readonly heading2: 24;
+        readonly heading1: 30;
+        readonly maxLength: 100;
+    };
+    readonly boldHeadingMaxLength: 80;
+    readonly headingEndPattern: RegExp;
+    readonly pixelsPerPoint: 1.333;
+    readonly pixelsPerEm: 16;
+    readonly fontSizePattern: RegExp;
+    readonly commentStart: "<!--";
+    readonly commentEnd: "-->";
+    readonly declarationSeparator: ";";
+    readonly propertySeparator: ":";
+    readonly tagSource: "<(\\/?)([a-zA-Z][a-zA-Z0-9:-]*)((?:\"[^\"]*\"|'[^']*'|[^'\">])*)>";
+    readonly tagFlags: "y";
+    readonly attributePattern: RegExp;
+    readonly selfClosingPattern: RegExp;
+    readonly whitespacePattern: RegExp;
+    readonly preLineBreakPattern: RegExp;
+    readonly invisiblePattern: RegExp;
+    readonly entityPattern: RegExp;
+    readonly maxCodePoint: 1114111;
+    readonly numericEntityPrefix: "#";
+    readonly hexEntityPrefix: "#x";
+    readonly rootName: "root";
+    readonly bodyListLevel: 1;
+    readonly trailingBreakPattern: RegExp;
+    readonly leadingBreakPattern: RegExp;
+    readonly trailingSpacePattern: RegExp;
+    readonly leadingSpacePattern: RegExp;
+    readonly nonBreakingPattern: RegExp;
+    readonly srcAttribute: "src";
+    readonly altAttribute: "alt";
+    readonly hrefAttribute: "href";
+    readonly styleAttribute: "style";
+    readonly classAttribute: "class";
+    readonly widthAttribute: "width";
+    readonly heightAttribute: "height";
+    readonly aria: "aria-hidden";
+    readonly space: " ";
+    readonly newline: "\n";
+    readonly trackingLinePattern: RegExp;
+    readonly trackingEllipsis: "...";
+    readonly trackingEllipsisCharacter: "…";
+};

package/dist/common/constants/html-text-config.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HtmlTextConfig = void 0;
+exports.HtmlTextConfig = {
+    skipTags: [
+        'head',
+        'script',
+        'style',
+        'title',
+        'noscript',
+        'template',
+        'svg',
+        'iframe',
+        'object',
+        'embed',
+        'video',
+        'audio',
+        'canvas',
+        'select',
+        'textarea',
+    ],
+    rawTextTags: ['script', 'style', 'title', 'textarea'],
+    voidTags: [
+        'area',
+        'base',
+        'br',
+        'col',
+        'embed',
+        'hr',
+        'img',
+        'input',
+        'link',
+        'meta',
+        'param',
+        'source',
+        'track',
+        'wbr',
+    ],
+    blockTags: [
+        'address',
+        'article',
+        'aside',
+        'body',
+        'center',
+        'dd',
+        'details',
+        'div',
+        'dl',
+        'dt',
+        'fieldset',
+        'figcaption',
+        'figure',
+        'footer',
+        'form',
+        'header',
+        'html',
+        'main',
+        'nav',
+        'p',
+        'pre',
+        'section',
+        'summary',
+        'table',
+        'tbody',
+        'td',
+        'tfoot',
+        'th',
+        'thead',
+        'tr',
+    ],
+    strongTags: ['b', 'strong'],
+    emTags: ['i', 'em', 'cite', 'dfn'],
+    underlineTags: ['u', 'ins'],
+    codeTags: ['code', 'kbd', 'samp', 'tt'],
+    linkTag: 'a',
+    imageTag: 'img',
+    breakTag: 'br',
+    ruleTag: 'hr',
+    preTag: 'pre',
+    quoteTag: 'blockquote',
+    listItemTag: 'li',
+    orderedListTag: 'ol',
+    unorderedListTag: 'ul',
+    hiddenClassPattern: /(^|[\s_-])(preheader|pre-header|preview-text|previewtext)([\s_-]|$)/i,
+    hiddenDisplay: 'none',
+    hiddenVisibility: 'hidden',
+    hiddenMso: 'all',
+    hiddenAttribute: 'hidden',
+    hiddenAria: 'true',
+    tinyImageSize: 2,
+    importantPattern: /!important/i,
+    zeroPattern: /^0(\.0+)?(px|pt|em|rem|%)?$/,
+    pixelPattern: /^([0-9.]+)(px)?$/,
+    boldWeight: 600,
+    largeText: { heading3: 20, heading2: 24, heading1: 30, maxLength: 100 },
+    boldHeadingMaxLength: 80,
+    headingEndPattern: /[.,;:!?]$/,
+    pixelsPerPoint: 1.333,
+    pixelsPerEm: 16,
+    fontSizePattern: /^([0-9.]+)(px|pt|em|rem)$/,
+    commentStart: '<!--',
+    commentEnd: '-->',
+    declarationSeparator: ';',
+    propertySeparator: ':',
+    tagSource: '<(\\/?)([a-zA-Z][a-zA-Z0-9:-]*)((?:"[^"]*"|\'[^\']*\'|[^\'">])*)>',
+    tagFlags: 'y',
+    attributePattern: /([^\s"'<>/=]+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'=<>`]+)))?/g,
+    selfClosingPattern: /\/\s*$/,
+    whitespacePattern: /[ \t\r\n\f\u00A0\u2007\u202F]+/g,
+    preLineBreakPattern: /\r\n?/g,
+    invisiblePattern: /\u00AD|\u034F|[\u200B-\u200F\u2028\u2029\u2060\uFEFF]/g,
+    entityPattern: /&(#x[0-9a-fA-F]+|#[0-9]+|[a-zA-Z][a-zA-Z0-9]*);/g,
+    maxCodePoint: 0x10ffff,
+    numericEntityPrefix: '#',
+    hexEntityPrefix: '#x',
+    rootName: 'root',
+    bodyListLevel: 1,
+    trailingBreakPattern: /[ \n]+$/,
+    leadingBreakPattern: /^[ \n]+/,
+    trailingSpacePattern: / +$/,
+    leadingSpacePattern: /^ +/,
+    nonBreakingPattern: /[\u00A0\u2007\u202F]/g,
+    srcAttribute: 'src',
+    altAttribute: 'alt',
+    hrefAttribute: 'href',
+    styleAttribute: 'style',
+    classAttribute: 'class',
+    widthAttribute: 'width',
+    heightAttribute: 'height',
+    aria: 'aria-hidden',
+    space: ' ',
+    newline: '\n',
+    trackingLinePattern: /^\[\s*(?:<)?(https?:\/\/[^\s\]>]+?)(?:>)?\s*\]$/i,
+    trackingEllipsis: '...',
+    trackingEllipsisCharacter: '\u2026',
+};

package/dist/common/constants/html-token-kind.d.ts

@@ -0,0 +1,5 @@
+export declare const HtmlTokenKind: {
+    readonly Text: "text";
+    readonly Open: "open";
+    readonly Close: "close";
+};

package/dist/common/constants/html-token-kind.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HtmlTokenKind = void 0;
+exports.HtmlTokenKind = {
+    Text: 'text',
+    Open: 'open',
+    Close: 'close',
+};

package/dist/common/constants/portable-text-config.d.ts

@@ -11,7 +11,23 @@ export declare const PortableTextConfig: {
     readonly keyPrefix: {
         readonly block: "b";
         readonly span: "s";
+        readonly link: "l";
+        readonly image: "i";
     };
+    readonly blockType: "block";
+    readonly spanType: "span";
+    readonly linkType: "link";
+    readonly imageType: "image";
+    readonly decorators: readonly ["strong", "em", "underline", "code"];
+    readonly headingStyles: readonly ["h1", "h2", "h3"];
+    readonly messageStyles: readonly ["normal", "h1", "h2", "h3", "blockquote"];
+    readonly linkProtocols: readonly ["http:", "https:", "mailto:"];
+    readonly maxListLevel: 3;
+    readonly maxImageSrcLength: 2048;
+    readonly maxImageAltLength: 300;
+    readonly imageProtocolPattern: RegExp;
+    readonly maxControlCode: 31;
+    readonly deleteCode: 127;
     readonly normalStyle: "normal";
     readonly quoteStyle: "blockquote";
     readonly bulletItem: "bullet";

package/dist/common/constants/portable-text-config.js

@@ -12,7 +12,21 @@ exports.PortableTextConfig = {
     bulletPrefix: '- ',
     quotePrefix: '> ',
     numberSuffix: '. ',
-    keyPrefix: { block: 'b', span: 's' },
+    keyPrefix: { block: 'b', span: 's', link: 'l', image: 'i' },
+    blockType: ps_models_1.Common.PortableTextConfig.blockType,
+    spanType: ps_models_1.Common.PortableTextConfig.spanType,
+    linkType: ps_models_1.Common.PortableTextConfig.linkType,
+    imageType: ps_models_1.Common.PortableTextConfig.imageType,
+    decorators: ps_models_1.Common.PortableTextConfig.decorators,
+    headingStyles: ps_models_1.Common.PortableTextConfig.headingStyles,
+    messageStyles: ps_models_1.Common.PortableTextConfig.messageStyles,
+    linkProtocols: ps_models_1.Common.PortableTextConfig.linkProtocols,
+    maxListLevel: ps_models_1.Common.PortableTextConfig.maxListLevel,
+    maxImageSrcLength: ps_models_1.Common.PortableTextConfig.maxImageSrcLength,
+    maxImageAltLength: ps_models_1.Common.PortableTextConfig.maxImageAltLength,
+    imageProtocolPattern: ps_models_1.Common.PortableTextConfig.imageProtocolPattern,
+    maxControlCode: 31,
+    deleteCode: 127,
     normalStyle: ps_models_1.Common.PortableTextConfig.styles[0],
     quoteStyle: ps_models_1.Common.PortableTextConfig.styles[1],
     bulletItem: ps_models_1.Common.PortableTextConfig.listItems[0],

package/dist/common/html-entity-service.d.ts

@@ -0,0 +1,6 @@
+export declare class HtmlEntityService {
+    static decode(value: string): string;
+    private static resolve;
+    private static fromCode;
+    private static isNamed;
+}

package/dist/common/html-entity-service.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HtmlEntityService = void 0;
+var html_entity_names_1 = require("./constants/html-entity-names");
+var html_text_config_1 = require("./constants/html-text-config");
+var HtmlEntityService = /** @class */ (function () {
+    function HtmlEntityService() {
+    }
+    HtmlEntityService.decode = function (value) {
+        return value.replace(html_text_config_1.HtmlTextConfig.entityPattern, function (match, body) {
+            return HtmlEntityService.resolve(match, body);
+        });
+    };
+    HtmlEntityService.resolve = function (match, body) {
+        if (body.startsWith(html_text_config_1.HtmlTextConfig.hexEntityPrefix))
+            return HtmlEntityService.fromCode(match, Number.parseInt(body.slice(2), 16));
+        if (body.startsWith(html_text_config_1.HtmlTextConfig.numericEntityPrefix))
+            return HtmlEntityService.fromCode(match, Number.parseInt(body.slice(1), 10));
+        if (HtmlEntityService.isNamed(body))
+            return html_entity_names_1.HtmlEntityNames[body];
+        var lower = body.toLowerCase();
+        return HtmlEntityService.isNamed(lower) ? html_entity_names_1.HtmlEntityNames[lower] : match;
+    };
+    HtmlEntityService.fromCode = function (match, code) {
+        return Number.isInteger(code) && code > 0 && code <= html_text_config_1.HtmlTextConfig.maxCodePoint
+            ? String.fromCodePoint(code)
+            : match;
+    };
+    HtmlEntityService.isNamed = function (name) {
+        return Object.prototype.hasOwnProperty.call(html_entity_names_1.HtmlEntityNames, name);
+    };
+    return HtmlEntityService;
+}());
+exports.HtmlEntityService = HtmlEntityService;

package/dist/common/html-style-service.d.ts

@@ -0,0 +1,12 @@
+import type { HtmlDeclarationsData } from '../models/html-declarations-data';
+export declare class HtmlStyleService {
+    static parse(style: string | undefined): HtmlDeclarationsData;
+    static isHidden(declarations: HtmlDeclarationsData): boolean;
+    static isTiny(declarations: HtmlDeclarationsData): boolean;
+    static fontSize(declarations: HtmlDeclarationsData): number | null;
+    static bold(declarations: HtmlDeclarationsData): boolean | null;
+    static italic(declarations: HtmlDeclarationsData): boolean | null;
+    static underline(declarations: HtmlDeclarationsData): boolean | null;
+    private static isZero;
+    private static pixels;
+}

package/dist/common/html-style-service.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HtmlStyleService = void 0;
+var html_text_config_1 = require("./constants/html-text-config");
+var HtmlStyleService = /** @class */ (function () {
+    function HtmlStyleService() {
+    }
+    HtmlStyleService.parse = function (style) {
+        var declarations = {};
+        if (typeof style !== 'string')
+            return declarations;
+        style.split(html_text_config_1.HtmlTextConfig.declarationSeparator).forEach(function (entry) {
+            var index = entry.indexOf(html_text_config_1.HtmlTextConfig.propertySeparator);
+            if (index === -1)
+                return;
+            var property = entry.slice(0, index).trim().toLowerCase();
+            var value = entry
+                .slice(index + 1)
+                .replace(html_text_config_1.HtmlTextConfig.importantPattern, '')
+                .trim()
+                .toLowerCase();
+            if (property !== '' && value !== '')
+                declarations[property] = value;
+        });
+        return declarations;
+    };
+    HtmlStyleService.isHidden = function (declarations) {
+        return (declarations['display'] === html_text_config_1.HtmlTextConfig.hiddenDisplay ||
+            declarations['visibility'] === html_text_config_1.HtmlTextConfig.hiddenVisibility ||
+            declarations['mso-hide'] === html_text_config_1.HtmlTextConfig.hiddenMso ||
+            HtmlStyleService.isZero(declarations['max-height']) ||
+            HtmlStyleService.isZero(declarations['max-width']) ||
+            HtmlStyleService.isZero(declarations['font-size']) ||
+            HtmlStyleService.isZero(declarations['opacity']));
+    };
+    HtmlStyleService.isTiny = function (declarations) {
+        return (HtmlStyleService.pixels(declarations['width']) <= html_text_config_1.HtmlTextConfig.tinyImageSize ||
+            HtmlStyleService.pixels(declarations['height']) <= html_text_config_1.HtmlTextConfig.tinyImageSize);
+    };
+    HtmlStyleService.fontSize = function (declarations) {
+        var value = declarations['font-size'];
+        if (typeof value !== 'string')
+            return null;
+        var match = html_text_config_1.HtmlTextConfig.fontSizePattern.exec(value);
+        if (match === null)
+            return null;
+        var amount = Number.parseFloat(match[1]);
+        if (match[2] === 'pt')
+            return amount * html_text_config_1.HtmlTextConfig.pixelsPerPoint;
+        if (match[2] === 'em' || match[2] === 'rem')
+            return amount * html_text_config_1.HtmlTextConfig.pixelsPerEm;
+        return amount;
+    };
+    HtmlStyleService.bold = function (declarations) {
+        var value = declarations['font-weight'];
+        if (typeof value !== 'string')
+            return null;
+        if (value === 'bold' || value === 'bolder')
+            return true;
+        if (value === 'normal' || value === 'lighter')
+            return false;
+        var weight = Number.parseInt(value, 10);
+        return Number.isNaN(weight) ? null : weight >= html_text_config_1.HtmlTextConfig.boldWeight;
+    };
+    HtmlStyleService.italic = function (declarations) {
+        var value = declarations['font-style'];
+        if (typeof value !== 'string')
+            return null;
+        if (value === 'italic' || value === 'oblique')
+            return true;
+        return value === 'normal' ? false : null;
+    };
+    HtmlStyleService.underline = function (declarations) {
+        var value = declarations['text-decoration'];
+        if (typeof value !== 'string')
+            return null;
+        if (value.includes('underline'))
+            return true;
+        return value.includes('none') ? false : null;
+    };
+    HtmlStyleService.isZero = function (value) {
+        return typeof value === 'string' && html_text_config_1.HtmlTextConfig.zeroPattern.test(value);
+    };
+    HtmlStyleService.pixels = function (value) {
+        if (typeof value !== 'string')
+            return Number.POSITIVE_INFINITY;
+        var match = html_text_config_1.HtmlTextConfig.pixelPattern.exec(value);
+        return match === null ? Number.POSITIVE_INFINITY : Number.parseFloat(match[1]);
+    };
+    return HtmlStyleService;
+}());
+exports.HtmlStyleService = HtmlStyleService;

package/dist/common/html-token-service.d.ts

@@ -0,0 +1,8 @@
+import type { HtmlTokenData } from '../models/html-token-data';
+export declare class HtmlTokenService {
+    static tokenize(html: string): HtmlTokenData[];
+    private static consume;
+    private static skipRawText;
+    private static attributes;
+    private static pushText;
+}

package/dist/common/html-token-service.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HtmlTokenService = void 0;
+var html_text_config_1 = require("./constants/html-text-config");
+var html_token_kind_1 = require("./constants/html-token-kind");
+var html_entity_service_1 = require("./html-entity-service");
+var HtmlTokenService = /** @class */ (function () {
+    function HtmlTokenService() {
+    }
+    HtmlTokenService.tokenize = function (html) {
+        var tokens = [];
+        var cursor = 0;
+        while (cursor < html.length) {
+            var start = html.indexOf('<', cursor);
+            if (start === -1) {
+                HtmlTokenService.pushText(tokens, html.slice(cursor));
+                break;
+            }
+            HtmlTokenService.pushText(tokens, html.slice(cursor, start));
+            cursor = HtmlTokenService.consume(html, start, tokens);
+        }
+        return tokens;
+    };
+    HtmlTokenService.consume = function (html, start, tokens) {
+        if (html.startsWith(html_text_config_1.HtmlTextConfig.commentStart, start)) {
+            var end_1 = html.indexOf(html_text_config_1.HtmlTextConfig.commentEnd, start + html_text_config_1.HtmlTextConfig.commentStart.length);
+            return end_1 === -1 ? html.length : end_1 + html_text_config_1.HtmlTextConfig.commentEnd.length;
+        }
+        var next = html.charAt(start + 1);
+        if (next === '!' || next === '?') {
+            var end_2 = html.indexOf('>', start);
+            return end_2 === -1 ? html.length : end_2 + 1;
+        }
+        var pattern = new RegExp(html_text_config_1.HtmlTextConfig.tagSource, html_text_config_1.HtmlTextConfig.tagFlags);
+        pattern.lastIndex = start;
+        var match = pattern.exec(html);
+        if (match === null) {
+            HtmlTokenService.pushText(tokens, '<');
+            return start + 1;
+        }
+        var name = match[2].toLowerCase();
+        var end = start + match[0].length;
+        if (match[1] === '/') {
+            tokens.push({ kind: html_token_kind_1.HtmlTokenKind.Close, name: name });
+            return end;
+        }
+        tokens.push({
+            attributes: HtmlTokenService.attributes(match[3]),
+            kind: html_token_kind_1.HtmlTokenKind.Open,
+            name: name,
+            selfClosing: html_text_config_1.HtmlTextConfig.selfClosingPattern.test(match[3]),
+        });
+        return html_text_config_1.HtmlTextConfig.rawTextTags.includes(name)
+            ? HtmlTokenService.skipRawText(html, name, end, tokens)
+            : end;
+    };
+    HtmlTokenService.skipRawText = function (html, name, from, tokens) {
+        var closing = new RegExp("</".concat(name, "\\s*>"), 'gi');
+        closing.lastIndex = from;
+        var match = closing.exec(html);
+        if (match === null)
+            return html.length;
+        tokens.push({ kind: html_token_kind_1.HtmlTokenKind.Close, name: name });
+        return match.index + match[0].length;
+    };
+    HtmlTokenService.attributes = function (source) {
+        var attributes = {};
+        var pattern = new RegExp(html_text_config_1.HtmlTextConfig.attributePattern.source, html_text_config_1.HtmlTextConfig.attributePattern.flags);
+        var match = pattern.exec(source);
+        while (match !== null) {
+            var raw = [match[2], match[3], match[4]].find(function (value) { return typeof value === 'string'; });
+            var key = match[1].toLowerCase();
+            if (!Object.prototype.hasOwnProperty.call(attributes, key))
+                attributes[key] = html_entity_service_1.HtmlEntityService.decode(typeof raw === 'string' ? raw : '');
+            match = pattern.exec(source);
+        }
+        return attributes;
+    };
+    HtmlTokenService.pushText = function (tokens, text) {
+        if (text === '')
+            return;
+        var last = tokens[tokens.length - 1];
+        if (last !== undefined && last.kind === html_token_kind_1.HtmlTokenKind.Text)
+            last.text += text;
+        else
+            tokens.push({ kind: html_token_kind_1.HtmlTokenKind.Text, text: text });
+    };
+    return HtmlTokenService;
+}());
+exports.HtmlTokenService = HtmlTokenService;

package/dist/common/index.d.ts

@@ -24,5 +24,6 @@ export * from './error-response-service';
 export * from './relative-time-service';
 export * from './request-client-service';
 export * from './json-service';
+export * from './portable-text-link-service';
 export * from './portable-text-service';
 export * from './text-tidy-service';

package/dist/common/index.js

@@ -40,5 +40,6 @@ __exportStar(require("./error-response-service"), exports);
 __exportStar(require("./relative-time-service"), exports);
 __exportStar(require("./request-client-service"), exports);
 __exportStar(require("./json-service"), exports);
+__exportStar(require("./portable-text-link-service"), exports);
 __exportStar(require("./portable-text-service"), exports);
 __exportStar(require("./text-tidy-service"), exports);

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

@@ -0,0 +1,28 @@
+import type { PortableTextContentData } from '../models/portable-text-content-data';
+export declare class PortableTextHtmlService {
+    static fromHtml(html: string): PortableTextContentData[];
+    private static rootFrame;
+    private static consume;
+    private static isVoid;
+    private static isBlockTag;
+    private static isHidden;
+    private static attribute;
+    private static open;
+    private static closeOpenItem;
+    private static frame;
+    private static resolve;
+    private static close;
+    private static addText;
+    private static push;
+    private static lineBreak;
+    private static image;
+    private static isTiny;
+    private static key;
+    private static context;
+    private static trimmed;
+    private static flush;
+    private static styleOf;
+    private static headingOf;
+    private static merge;
+    private static marks;
+}