@pallasoft/ps-file-components 2.2.0 → 2.4.0

package/dist/models/ps-normalized-text.d.ts

@@ -0,0 +1,5 @@
+export interface PsNormalizedText {
+    ends: number[];
+    starts: number[];
+    text: string;
+}

package/dist/models/ps-normalized-text.js

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

package/dist/models/ps-pdf-match.d.ts

@@ -1,6 +1,7 @@
 export interface PsPdfMatch {
     height: number;
     left: number;
+    matchIndex: number;
     pageNumber: number;
     top: number;
     width: number;

package/dist/models/ps-pdf-text-item.d.ts

@@ -0,0 +1,7 @@
+export interface PsPdfTextItem {
+    hasEOL: boolean;
+    height: number;
+    str: string;
+    transform: number[];
+    width: number;
+}

package/dist/models/ps-pdf-text-item.js

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

package/dist/models/ps-pdf-viewport-like.d.ts

@@ -0,0 +1,5 @@
+export interface PsPdfViewportLike {
+    convertToViewportPoint: (x: number, y: number) => number[];
+    height: number;
+    width: number;
+}

package/dist/models/ps-pdf-viewport-like.js

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

package/dist/models/ps-search-item.d.ts

@@ -0,0 +1,4 @@
+export interface PsSearchItem {
+    isBreakAfter: boolean;
+    text: string;
+}

package/dist/models/ps-search-item.js

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

package/dist/models/ps-sheet-data.d.ts

@@ -0,0 +1,4 @@
+export interface PsSheetData {
+    name: string;
+    rows: string[][];
+}

package/dist/models/ps-sheet-data.js

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

package/dist/models/ps-viewer-file.d.ts

@@ -1,3 +1,4 @@
+import type { PsImageTextLayer } from './ps-image-text-layer';
 export interface PsViewerFile {
     contentType: string;
     createdAt?: string;
@@ -5,5 +6,6 @@ export interface PsViewerFile {
     id: string;
     name: string;
     sizeBytes?: number;
+    textLayer?: PsImageTextLayer;
     url: string;
 }

package/dist/services/ps-file-fetch-service.d.ts

@@ -0,0 +1,5 @@
+export declare class PsFileFetchService {
+    static response(url: string, signal: AbortSignal): Promise<Response>;
+    static text(url: string, signal: AbortSignal): Promise<string>;
+    static buffer(url: string, signal: AbortSignal): Promise<ArrayBuffer>;
+}

package/dist/services/ps-file-fetch-service.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PsFileFetchService = void 0;
+class PsFileFetchService {
+    static async response(url, signal) {
+        const response = await fetch(url, { credentials: 'include', signal });
+        if (!response.ok)
+            throw new Error(response.statusText);
+        return response;
+    }
+    static async text(url, signal) {
+        return (await PsFileFetchService.response(url, signal)).text();
+    }
+    static async buffer(url, signal) {
+        return (await PsFileFetchService.response(url, signal)).arrayBuffer();
+    }
+}
+exports.PsFileFetchService = PsFileFetchService;

package/dist/services/ps-file-search-service.d.ts

@@ -0,0 +1,5 @@
+import { PsFileKind } from '../constants/ps-file-kind';
+export declare class PsFileSearchService {
+    static canSearch(kind: PsFileKind, hasTextLayer: boolean): boolean;
+    static isFindShortcut(event: KeyboardEvent): boolean;
+}

package/dist/services/ps-file-search-service.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PsFileSearchService = void 0;
+const ps_file_kind_1 = require("../constants/ps-file-kind");
+const ps_file_viewer_kinds_1 = require("../constants/ps-file-viewer-kinds");
+class PsFileSearchService {
+    static canSearch(kind, hasTextLayer) {
+        if (ps_file_viewer_kinds_1.PsFileViewerKinds.searchable.includes(kind))
+            return true;
+        return kind === ps_file_kind_1.PsFileKind.image && hasTextLayer;
+    }
+    static isFindShortcut(event) {
+        return ((event.metaKey || event.ctrlKey) &&
+            !event.altKey &&
+            !event.shiftKey &&
+            event.key.toLowerCase() === 'f');
+    }
+}
+exports.PsFileSearchService = PsFileSearchService;

package/dist/services/ps-file-type-service.js

@@ -10,10 +10,21 @@ class PsFileTypeService {
     }
     static kindOf(contentType, name) {
         const type = contentType.toLowerCase();
+        const extension = PsFileTypeService.extension(name);
         if (type === 'application/pdf')
             return ps_file_kind_1.PsFileKind.pdf;
         if (ps_file_type_config_1.PsFileTypeConfig.csvTypes.includes(type))
             return ps_file_kind_1.PsFileKind.csv;
+        if (type === ps_file_type_config_1.PsFileTypeConfig.excelLegacyType)
+            return extension === 'xls' || extension === 'xlsb' ? ps_file_kind_1.PsFileKind.other : ps_file_kind_1.PsFileKind.csv;
+        if (ps_file_type_config_1.PsFileTypeConfig.sheetTypes.includes(type))
+            return ps_file_kind_1.PsFileKind.sheet;
+        if (ps_file_type_config_1.PsFileTypeConfig.wordTypes.includes(type))
+            return ps_file_kind_1.PsFileKind.word;
+        if (ps_file_type_config_1.PsFileTypeConfig.htmlTypes.includes(type))
+            return ps_file_kind_1.PsFileKind.html;
+        if (ps_file_type_config_1.PsFileTypeConfig.unsupportedImageTypes.includes(type))
+            return ps_file_kind_1.PsFileKind.other;
         if (type.startsWith('image/'))
             return ps_file_kind_1.PsFileKind.image;
         if (type.startsWith('video/'))
@@ -23,7 +34,7 @@ class PsFileTypeService {
         if (type.startsWith('text/') ||
             ps_file_type_config_1.PsFileTypeConfig.textTypes.includes(type))
             return ps_file_kind_1.PsFileKind.text;
-        const byExtension = ps_file_type_config_1.PsFileTypeConfig.extensionKinds[PsFileTypeService.extension(name)];
+        const byExtension = ps_file_type_config_1.PsFileTypeConfig.extensionKinds[extension];
         return byExtension === undefined ? ps_file_kind_1.PsFileKind.other : byExtension;
     }
     static isAccepted(file, accept) {

package/dist/services/ps-html-file-service.d.ts

@@ -0,0 +1,3 @@
+export declare class PsHtmlFileService {
+    static load(url: string, signal: AbortSignal): Promise<string>;
+}

package/dist/services/ps-html-file-service.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PsHtmlFileService = void 0;
+const ps_file_fetch_service_1 = require("./ps-file-fetch-service");
+const ps_html_service_1 = require("./ps-html-service");
+class PsHtmlFileService {
+    static async load(url, signal) {
+        return ps_html_service_1.PsHtmlService.sanitize(await ps_file_fetch_service_1.PsFileFetchService.text(url, signal), false);
+    }
+}
+exports.PsHtmlFileService = PsHtmlFileService;

package/dist/services/ps-html-service.d.ts

@@ -0,0 +1,7 @@
+import type { PsHtmlHighlightResult } from '../models/ps-html-highlight-result';
+export declare class PsHtmlService {
+    static sanitize(html: string, allowImages: boolean): Promise<string>;
+    static harden(html: string): string;
+    static highlight(html: string, query: string): PsHtmlHighlightResult;
+    private static wrap;
+}

package/dist/services/ps-html-service.js

@@ -0,0 +1,120 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PsHtmlService = void 0;
+const ps_html_sanitize_config_1 = require("../constants/ps-html-sanitize-config");
+const ps_text_search_service_1 = require("./ps-text-search-service");
+class PsHtmlService {
+    static async sanitize(html, allowImages) {
+        const library = await Promise.resolve().then(() => __importStar(require('dompurify')));
+        const forbidden = [...ps_html_sanitize_config_1.PsHtmlSanitizeConfig.forbiddenTags];
+        if (!allowImages)
+            forbidden.push(...ps_html_sanitize_config_1.PsHtmlSanitizeConfig.mediaTags);
+        const clean = library.default.sanitize(html, {
+            FORBID_ATTR: [...ps_html_sanitize_config_1.PsHtmlSanitizeConfig.forbiddenAttributes],
+            FORBID_TAGS: forbidden,
+            USE_PROFILES: { html: true },
+        });
+        return PsHtmlService.harden(clean);
+    }
+    static harden(html) {
+        const template = document.createElement('template');
+        template.innerHTML = html;
+        template.content.querySelectorAll('a').forEach((anchor) => {
+            anchor.setAttribute('target', ps_html_sanitize_config_1.PsHtmlSanitizeConfig.anchorTarget);
+            anchor.setAttribute('rel', ps_html_sanitize_config_1.PsHtmlSanitizeConfig.anchorRel);
+        });
+        template.content.querySelectorAll('img').forEach((image) => {
+            const source = image.getAttribute('src');
+            if (source === null || !source.startsWith('data:'))
+                image.remove();
+        });
+        return template.innerHTML;
+    }
+    static highlight(html, query) {
+        if (query.trim().length === 0)
+            return { count: 0, html };
+        const template = document.createElement('template');
+        template.innerHTML = html;
+        const nodes = [];
+        const walker = document.createTreeWalker(template.content, NodeFilter.SHOW_TEXT);
+        let full = '';
+        let previousBlock = null;
+        let current = walker.nextNode();
+        while (current !== null) {
+            const node = current;
+            const block = node.parentElement === null
+                ? null
+                : node.parentElement.closest(ps_html_sanitize_config_1.PsHtmlSanitizeConfig.blockSelector);
+            if (nodes.length > 0 && block !== previousBlock)
+                full += '\n';
+            nodes.push({ node, offset: full.length });
+            full += node.data;
+            previousBlock = block;
+            current = walker.nextNode();
+        }
+        const matches = ps_text_search_service_1.PsTextSearchService.find(full, query);
+        if (matches.length === 0)
+            return { count: 0, html };
+        nodes.forEach(({ node, offset }) => PsHtmlService.wrap(node, offset, matches));
+        return { count: matches.length, html: template.innerHTML };
+    }
+    static wrap(node, offset, matches) {
+        const end = offset + node.data.length;
+        const fragment = document.createDocumentFragment();
+        let cursor = 0;
+        let hasMark = false;
+        matches.forEach((match, matchIndex) => {
+            const start = Math.max(match.start, offset) - offset;
+            const stop = Math.min(match.end, end) - offset;
+            if (stop <= start || match.start >= end || match.end <= offset)
+                return;
+            if (start > cursor)
+                fragment.append(node.data.slice(cursor, start));
+            const mark = document.createElement('mark');
+            mark.setAttribute('data-ps-match', String(matchIndex));
+            mark.textContent = node.data.slice(start, stop);
+            fragment.append(mark);
+            cursor = stop;
+            hasMark = true;
+        });
+        if (!hasMark)
+            return;
+        if (cursor < node.data.length)
+            fragment.append(node.data.slice(cursor));
+        node.replaceWith(fragment);
+    }
+}
+exports.PsHtmlService = PsHtmlService;

package/dist/services/ps-image-text-service.d.ts

@@ -0,0 +1,5 @@
+import type { PsImageMatch } from '../models/ps-image-match';
+import type { PsImageTextLayer } from '../models/ps-image-text-layer';
+export declare class PsImageTextService {
+    static matches(layer: PsImageTextLayer, query: string): PsImageMatch[];
+}

package/dist/services/ps-image-text-service.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PsImageTextService = void 0;
+const ps_text_search_service_1 = require("./ps-text-search-service");
+class PsImageTextService {
+    static matches(layer, query) {
+        if (layer.width <= 0 || layer.height <= 0)
+            return [];
+        const items = layer.words.map((word, index) => ({
+            isBreakAfter: index < layer.words.length - 1,
+            text: word.text,
+        }));
+        const rects = [];
+        ps_text_search_service_1.PsTextSearchService.findInItems(items, query).forEach((match, matchIndex) => {
+            match.parts.forEach((part) => {
+                const word = layer.words[part.itemIndex];
+                const length = word.text.length;
+                const left = word.box.left + (word.box.width * part.start) / length;
+                const width = (word.box.width * (part.end - part.start)) / length;
+                rects.push({
+                    height: word.box.height / layer.height,
+                    left: left / layer.width,
+                    matchIndex,
+                    top: word.box.top / layer.height,
+                    width: width / layer.width,
+                });
+            });
+        });
+        return rects;
+    }
+}
+exports.PsImageTextService = PsImageTextService;

package/dist/services/ps-label-service.d.ts

@@ -0,0 +1,3 @@
+export declare class PsLabelService {
+    static fill(template: string, values: Record<string, string | number>): string;
+}

package/dist/services/ps-label-service.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PsLabelService = void 0;
+class PsLabelService {
+    static fill(template, values) {
+        return Object.keys(values).reduce((text, key) => text.split(`{${key}}`).join(String(values[key])), template);
+    }
+}
+exports.PsLabelService = PsLabelService;

package/dist/services/ps-pdf-service.d.ts

@@ -1,11 +1,14 @@
 import type { PDFDocumentProxy, PDFPageProxy, RenderTask } from 'pdfjs-dist';
 import type { PsPdfMatch } from '../models/ps-pdf-match';
+import type { PsPdfTextItem } from '../models/ps-pdf-text-item';
+import type { PsPdfViewportLike } from '../models/ps-pdf-viewport-like';
 type PdfLibrary = typeof import('pdfjs-dist');
 export declare class PsPdfService {
     private static library;
     static load(workerSrc?: string): Promise<PdfLibrary>;
     static open(url: string, workerSrc?: string): Promise<PDFDocumentProxy>;
     static render(page: PDFPageProxy, canvas: HTMLCanvasElement, scale: number, rotation: number): RenderTask;
+    static pageMatches(items: PsPdfTextItem[], viewport: PsPdfViewportLike, query: string, pageNumber: number, firstIndex: number): PsPdfMatch[];
     static search(document: PDFDocumentProxy, query: string, rotation: number): Promise<PsPdfMatch[]>;
 }
 export {};

package/dist/services/ps-pdf-service.js

@@ -66,31 +66,54 @@ class PsPdfService {
         task.promise.catch(() => undefined);
         return task;
     }
+    static pageMatches(items, viewport, query, pageNumber, firstIndex) {
+        const found = ps_text_search_service_1.PsTextSearchService.findInItems(items.map((item) => ({ isBreakAfter: item.hasEOL, text: item.str })), query);
+        const rects = [];
+        found.forEach((match, offset) => {
+            match.parts.forEach((part) => {
+                const item = items[part.itemIndex];
+                const [x, y] = [item.transform[4], item.transform[5]];
+                const height = item.height > 0 ? item.height : Math.hypot(item.transform[2], item.transform[3]);
+                const start = x + (item.width * part.start) / item.str.length;
+                const end = x + (item.width * part.end) / item.str.length;
+                const [x1, y1] = viewport.convertToViewportPoint(start, y);
+                const [x2, y2] = viewport.convertToViewportPoint(end, y + height);
+                rects.push({
+                    height: Math.abs(y2 - y1) / viewport.height,
+                    left: Math.min(x1, x2) / viewport.width,
+                    matchIndex: firstIndex + offset,
+                    pageNumber,
+                    top: Math.min(y1, y2) / viewport.height,
+                    width: Math.abs(x2 - x1) / viewport.width,
+                });
+            });
+        });
+        return rects;
+    }
     static async search(document, query, rotation) {
         const matches = [];
+        let count = 0;
+        if (query.trim().length === 0)
+            return matches;
         for (let pageNumber = 1; pageNumber <= document.numPages; pageNumber += 1) {
             const page = await document.getPage(pageNumber);
             const viewport = page.getViewport({ rotation: page.rotate + rotation, scale: 1 });
             const content = await page.getTextContent();
+            const items = [];
             content.items.forEach((item) => {
-                if (!('str' in item) || item.str.length === 0)
-                    return;
-                ps_text_search_service_1.PsTextSearchService.find(item.str, query).forEach((found) => {
-                    const [x, y] = [item.transform[4], item.transform[5]];
-                    const height = item.height > 0 ? item.height : Math.hypot(item.transform[2], item.transform[3]);
-                    const start = x + (item.width * found.start) / item.str.length;
-                    const end = x + (item.width * found.end) / item.str.length;
-                    const [x1, y1] = viewport.convertToViewportPoint(start, y);
-                    const [x2, y2] = viewport.convertToViewportPoint(end, y + height);
-                    matches.push({
-                        height: Math.abs(y2 - y1) / viewport.height,
-                        left: Math.min(x1, x2) / viewport.width,
-                        pageNumber,
-                        top: Math.min(y1, y2) / viewport.height,
-                        width: Math.abs(x2 - x1) / viewport.width,
+                if ('str' in item)
+                    items.push({
+                        hasEOL: item.hasEOL,
+                        height: item.height,
+                        str: item.str,
+                        transform: item.transform,
+                        width: item.width,
                     });
-                });
             });
+            const found = PsPdfService.pageMatches(items, viewport, query, pageNumber, count);
+            if (found.length > 0)
+                count = found[found.length - 1].matchIndex + 1;
+            matches.push(...found);
         }
         return matches;
     }

package/dist/services/ps-sheet-service.d.ts

@@ -0,0 +1,5 @@
+import type { PsSheetData } from '../models/ps-sheet-data';
+export declare class PsSheetService {
+    static load(url: string, signal: AbortSignal): Promise<PsSheetData[]>;
+    static cellText(value: unknown): string;
+}

package/dist/services/ps-sheet-service.js

@@ -0,0 +1,60 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PsSheetService = void 0;
+const ps_file_fetch_service_1 = require("./ps-file-fetch-service");
+class PsSheetService {
+    static async load(url, signal) {
+        const [buffer, library] = await Promise.all([
+            ps_file_fetch_service_1.PsFileFetchService.buffer(url, signal),
+            Promise.resolve().then(() => __importStar(require('read-excel-file/browser'))),
+        ]);
+        const sheets = await library.default(buffer);
+        return sheets.map((sheet) => ({
+            name: sheet.sheet,
+            rows: sheet.data.map((row) => row.map((cell) => PsSheetService.cellText(cell))),
+        }));
+    }
+    static cellText(value) {
+        if (typeof value === 'string')
+            return value;
+        if (typeof value === 'number' || typeof value === 'boolean')
+            return String(value);
+        if (value instanceof Date)
+            return Number.isNaN(value.getTime()) ? '' : value.toISOString().slice(0, 10);
+        return '';
+    }
+}
+exports.PsSheetService = PsSheetService;

package/dist/services/ps-text-search-service.d.ts

@@ -1,6 +1,13 @@
+import type { PsItemMatch } from '../models/ps-item-match';
+import type { PsNormalizedText } from '../models/ps-normalized-text';
+import type { PsSearchItem } from '../models/ps-search-item';
 import type { PsTextMatch } from '../models/ps-text-match';
 import type { PsTextSegment } from '../models/ps-text-segment';
 export declare class PsTextSearchService {
+    static normalize(text: string): PsNormalizedText;
     static find(text: string, query: string): PsTextMatch[];
+    static findInItems(items: PsSearchItem[], query: string): PsItemMatch[];
     static segments(text: string, matches: PsTextMatch[], firstIndex?: number): PsTextSegment[];
+    static tableSegments(rows: string[][], query: string): PsTextSegment[][][];
+    static countSegments(table: PsTextSegment[][][]): number;
 }

package/dist/services/ps-text-search-service.js

@@ -1,20 +1,73 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PsTextSearchService = void 0;
+const whitespace = /\s/u;
+const marks = /\p{M}/gu;
 class PsTextSearchService {
+    static normalize(text) {
+        const starts = [];
+        const ends = [];
+        let folded = '';
+        let isAfterSpace = false;
+        let index = 0;
+        while (index < text.length) {
+            const char = String.fromCodePoint(text.codePointAt(index));
+            const next = index + char.length;
+            if (whitespace.test(char)) {
+                if (!isAfterSpace) {
+                    folded += ' ';
+                    starts.push(index);
+                    ends.push(next);
+                }
+                isAfterSpace = true;
+            }
+            else {
+                const plain = char.toLowerCase().normalize('NFD').replace(marks, '');
+                for (let at = 0; at < plain.length; at += 1) {
+                    folded += plain[at];
+                    starts.push(index);
+                    ends.push(next);
+                }
+                isAfterSpace = false;
+            }
+            index = next;
+        }
+        return { ends, starts, text: folded };
+    }
     static find(text, query) {
-        const needle = query.trim().toLowerCase();
+        const needle = PsTextSearchService.normalize(query.trim()).text;
         if (needle.length === 0)
             return [];
-        const haystack = text.toLowerCase();
+        const haystack = PsTextSearchService.normalize(text);
         const matches = [];
-        let from = haystack.indexOf(needle);
+        let from = haystack.text.indexOf(needle);
         while (from !== -1) {
-            matches.push({ end: from + needle.length, start: from });
-            from = haystack.indexOf(needle, from + needle.length);
+            matches.push({
+                end: haystack.ends[from + needle.length - 1],
+                start: haystack.starts[from],
+            });
+            from = haystack.text.indexOf(needle, from + needle.length);
         }
         return matches;
     }
+    static findInItems(items, query) {
+        const offsets = [];
+        let joined = '';
+        items.forEach((item) => {
+            offsets.push(joined.length);
+            joined += item.isBreakAfter ? `${item.text} ` : item.text;
+        });
+        return PsTextSearchService.find(joined, query).map((match) => {
+            const parts = [];
+            items.forEach((item, itemIndex) => {
+                const start = Math.max(match.start, offsets[itemIndex]) - offsets[itemIndex];
+                const end = Math.min(match.end, offsets[itemIndex] + item.text.length) - offsets[itemIndex];
+                if (end > start)
+                    parts.push({ end, itemIndex, start });
+            });
+            return { parts };
+        });
+    }
     static segments(text, matches, firstIndex = 0) {
         const segments = [];
         let cursor = 0;
@@ -32,5 +85,17 @@ class PsTextSearchService {
             segments.push({ isMatch: false, matchIndex: null, text: text.slice(cursor) });
         return segments;
     }
+    static tableSegments(rows, query) {
+        let offset = 0;
+        return rows.map((row) => row.map((cell) => {
+            const matches = PsTextSearchService.find(cell, query);
+            const segments = PsTextSearchService.segments(cell, matches, offset);
+            offset += matches.length;
+            return segments;
+        }));
+    }
+    static countSegments(table) {
+        return table.reduce((total, row) => total + row.reduce((sum, cell) => sum + cell.filter((part) => part.isMatch).length, 0), 0);
+    }
 }
 exports.PsTextSearchService = PsTextSearchService;

package/dist/services/ps-word-service.d.ts

@@ -0,0 +1,3 @@
+export declare class PsWordService {
+    static load(url: string, signal: AbortSignal): Promise<string>;
+}