@pallasoft/ps-utilities 2.21.0 → 2.23.0

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

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

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

@@ -0,0 +1,35 @@
+import { PortableTextConfig } from './constants/portable-text-config.js';
+export class PortableTextLinkService {
+    static isSafe(href) {
+        try {
+            return PortableTextConfig.linkProtocols.includes(new URL(href).protocol);
+        }
+        catch {
+            return false;
+        }
+    }
+    static normalize(raw) {
+        if (typeof raw !== 'string')
+            return null;
+        const href = Array.from(raw)
+            .filter((character) => !PortableTextLinkService.isControl(character))
+            .join('')
+            .trim();
+        return href !== '' && PortableTextLinkService.isSafe(href) ? href : null;
+    }
+    static isSafeImage(src) {
+        return PortableTextLinkService.normalizeImage(src) === src;
+    }
+    static normalizeImage(raw) {
+        const src = PortableTextLinkService.normalize(raw);
+        return src !== null &&
+            PortableTextConfig.imageProtocolPattern.test(src) &&
+            src.length <= PortableTextConfig.maxImageSrcLength
+            ? src
+            : null;
+    }
+    static isControl(character) {
+        const code = character.charCodeAt(0);
+        return code <= PortableTextConfig.maxControlCode || code === PortableTextConfig.deleteCode;
+    }
+}

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

@@ -1,13 +1,15 @@
 import { Common } from '@pallasoft/ps-models';
 import { escapeHTML, toHTML } from '@portabletext/to-html';
 import { PortableTextConfig } from './constants/portable-text-config.js';
+import { PortableTextHtmlService } from './portable-text-html-service.js';
+import { PortableTextLinkService } from './portable-text-link-service.js';
 export class PortableTextService {
     static toPlainText(blocks) {
         const lines = [];
         const counters = {};
         let previousWasList = false;
         blocks.forEach((block) => {
-            if (block._type !== Common.PortableTextConfig.blockType)
+            if (!('children' in block) || block._type !== Common.PortableTextConfig.blockType)
                 return;
             const text = this.blockText(block);
             const level = typeof block.level === 'number' ? block.level : 1;
@@ -59,17 +61,22 @@ export class PortableTextService {
             ],
         }));
     }
+    static fromHtml(html) {
+        return PortableTextHtmlService.fromHtml(html);
+    }
     static isEmpty(blocks) {
-        return (!Array.isArray(blocks) || blocks.every((block) => this.blockText(block).trim().length === 0));
+        return (!Array.isArray(blocks) ||
+            blocks.every((block) => !('children' in block) || this.blockText(block).trim().length === 0));
     }
     static toHtml(blocks) {
         return toHTML(blocks, {
             onMissingComponent: false,
             components: {
+                types: { [PortableTextConfig.imageType]: () => '' },
                 marks: {
                     link: ({ children, value }) => {
                         const href = typeof value?.href === 'string' ? value.href : '';
-                        return this.isSafeLink(href)
+                        return PortableTextService.isSafeLink(href)
                             ? `<a href="${escapeHTML(href)}" rel="${PortableTextConfig.linkRel}" target="${PortableTextConfig.linkTarget}">${children}</a>`
                             : children;
                     },
@@ -87,11 +94,9 @@ export class PortableTextService {
             : '';
     }
     static isSafeLink(href) {
-        try {
-            return Common.PortableTextConfig.linkProtocols.includes(new URL(href).protocol);
-        }
-        catch {
-            return false;
-        }
+        return PortableTextLinkService.isSafe(href);
+    }
+    static isSafeImage(src) {
+        return PortableTextLinkService.isSafeImage(src);
     }
 }

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

@@ -0,0 +1,34 @@
+import { HtmlTextConfig } from './constants/html-text-config.js';
+import { PortableTextConfig } from './constants/portable-text-config.js';
+export class PortableTextTrackingService {
+    static stripUrlLines(blocks) {
+        const hrefs = PortableTextTrackingService.hrefs(blocks);
+        return blocks.filter((block) => !PortableTextTrackingService.isDuplicate(block, hrefs));
+    }
+    static hrefs(blocks) {
+        return blocks.flatMap((block) => 'children' in block && Array.isArray(block.markDefs)
+            ? block.markDefs.flatMap((definition) => typeof definition.href === 'string' ? [definition.href] : [])
+            : []);
+    }
+    static isDuplicate(block, hrefs) {
+        if (!('children' in block) || !Array.isArray(block.children))
+            return false;
+        if (block.style !== PortableTextConfig.normalStyle || typeof block.listItem === 'string')
+            return false;
+        const text = block.children
+            .map((child) => (typeof child.text === 'string' ? child.text : ''))
+            .join('')
+            .trim();
+        const match = HtmlTextConfig.trackingLinePattern.exec(text);
+        return (match !== null && hrefs.some((href) => PortableTextTrackingService.matches(href, match[1])));
+    }
+    static matches(href, shown) {
+        const ascii = shown.indexOf(HtmlTextConfig.trackingEllipsis);
+        const unicode = shown.indexOf(HtmlTextConfig.trackingEllipsisCharacter);
+        const index = ascii !== -1 ? ascii : unicode;
+        if (index === -1)
+            return href === shown || href.startsWith(shown);
+        const width = ascii !== -1 ? HtmlTextConfig.trackingEllipsis.length : 1;
+        return href.startsWith(shown.slice(0, index)) && href.endsWith(shown.slice(index + width));
+    }
+}

package/dist/esm/models/html-attributes-data.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/models/html-close-token-data.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/models/html-context-data.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/models/html-conversion-data.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/models/html-declarations-data.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/models/html-frame-data.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/models/html-open-token-data.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/models/html-run-data.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/models/html-text-token-data.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/models/html-token-data.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/models/portable-text-block-link.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/models/portable-text-content-data.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/models/portable-text-image-data.js

@@ -0,0 +1 @@
+export {};

package/dist/index.d.ts

@@ -5,6 +5,9 @@ export { HttpMethod } from './common/constants/http-method';
 export type { CodedErrorData } from './models/coded-error-data';
 export type { DeviceData } from './models/device-data';
 export type { EmailPreviewInput } from './models/email-preview-input';
+export type { PortableTextBlockLink } from './models/portable-text-block-link';
+export type { PortableTextContentData } from './models/portable-text-content-data';
+export type { PortableTextImageData } from './models/portable-text-image-data';
 export type { JsonValueGuard } from './models/json-value-guard';
 export type { SignedTokenHeader } from './models/signed-token-header';
 export type { SignedTokenKeyPair } from './models/signed-token-key-pair';

package/dist/models/html-attributes-data.d.ts

@@ -0,0 +1 @@
+export type HtmlAttributesData = Record<string, string>;

package/dist/models/html-attributes-data.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/models/html-close-token-data.d.ts

@@ -0,0 +1,5 @@
+import type { HtmlTokenKind } from '../common/constants/html-token-kind';
+export interface HtmlCloseTokenData {
+    kind: typeof HtmlTokenKind.Close;
+    name: string;
+}

package/dist/models/html-close-token-data.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/models/html-context-data.d.ts

@@ -0,0 +1,6 @@
+export interface HtmlContextData {
+    heading: string | null;
+    isQuote: boolean;
+    listLevel: number | null;
+    ordered: boolean;
+}

package/dist/models/html-context-data.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/models/html-conversion-data.d.ts

@@ -0,0 +1,12 @@
+import type { HtmlFrameData } from './html-frame-data';
+import type { HtmlRunData } from './html-run-data';
+import type { PortableTextContentData } from './portable-text-content-data';
+export interface HtmlConversionData {
+    blocks: PortableTextContentData[];
+    counter: number;
+    lists: boolean[];
+    pending: HtmlRunData[];
+    skipDepth: number;
+    skipName: string | null;
+    stack: HtmlFrameData[];
+}

package/dist/models/html-conversion-data.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/models/html-declarations-data.d.ts

@@ -0,0 +1 @@
+export type HtmlDeclarationsData = Record<string, string>;

package/dist/models/html-declarations-data.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/models/html-frame-data.d.ts

@@ -0,0 +1,13 @@
+export interface HtmlFrameData {
+    code: boolean;
+    em: boolean;
+    heading: string | null;
+    href: string | null;
+    isQuote: boolean;
+    listLevel: number | null;
+    name: string;
+    ordered: boolean;
+    size: number | null;
+    strong: boolean;
+    underline: boolean;
+}

package/dist/models/html-frame-data.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/models/html-open-token-data.d.ts

@@ -0,0 +1,8 @@
+import type { HtmlTokenKind } from '../common/constants/html-token-kind';
+import type { HtmlAttributesData } from './html-attributes-data';
+export interface HtmlOpenTokenData {
+    attributes: HtmlAttributesData;
+    kind: typeof HtmlTokenKind.Open;
+    name: string;
+    selfClosing: boolean;
+}

package/dist/models/html-open-token-data.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/models/html-run-data.d.ts

@@ -0,0 +1,9 @@
+export interface HtmlRunData {
+    code: boolean;
+    em: boolean;
+    href: string | null;
+    size: number | null;
+    strong: boolean;
+    text: string;
+    underline: boolean;
+}

package/dist/models/html-run-data.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });