@matrixreq/htmldiff 1.5.0 → 2.0.0

package/js/tables/TableRedlining.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TableRedlining = void 0;
+const constants_1 = require("../constants");
+const constants_2 = require("./constants");
+const html_1 = require("./html");
+const Table_1 = require("./Table");
+const TableAligner_1 = require("./TableAligner");
+const TableMerger_1 = require("./TableMerger");
+class TableRedlining {
+    diffContent;
+    constructor(diffContent) {
+        this.diffContent = diffContent;
+    }
+    redline(before, after) {
+        const oldTables = Table_1.Table.findTopLevel(before);
+        const newTables = Table_1.Table.findTopLevel(after);
+        if (oldTables.length === 0 && newTables.length === 0) {
+            return { before, after };
+        }
+        const beforeReplacements = [];
+        const afterReplacements = [];
+        const oldOpenTags = oldTables.map((table) => table.openTag);
+        const newOpenTags = newTables.map((table) => table.openTag);
+        const openTagReplacement = (table, original) => ({
+            start: table.start,
+            end: table.start + original.length,
+            html: table.openTag,
+        });
+        new TableAligner_1.TableAligner(oldTables, newTables).align().forEach((alignment, index) => {
+            if (alignment.kind === "added") {
+                const addedTable = newTables[alignment.newIndex];
+                addedTable.ensureId(`${constants_2.TABLE_ID_PREFIX}added-${index}`);
+                afterReplacements.push(openTagReplacement(addedTable, newOpenTags[alignment.newIndex]));
+                return;
+            }
+            if (alignment.kind === "deleted") {
+                const deletedTable = oldTables[alignment.oldIndex];
+                deletedTable.ensureId(`${constants_2.TABLE_ID_PREFIX}deleted-${index}`);
+                beforeReplacements.push(openTagReplacement(deletedTable, oldOpenTags[alignment.oldIndex]));
+                return;
+            }
+            const oldTable = oldTables[alignment.oldIndex];
+            const newTable = newTables[alignment.newIndex];
+            if (newTable.ownId() !== undefined && !newTable.wantsInnerDiff()) {
+                return;
+            }
+            const mergedInner = new TableMerger_1.TableMerger(oldTable, newTable, this.diffContent).merge();
+            const id = newTable.ensureId(`${constants_2.TABLE_ID_PREFIX}${index}`);
+            oldTable.openTag = (0, html_1.setTagAttribute)(oldTable.openTag, constants_1.HTMLDIFF_ID_ATTRIBUTE, id);
+            newTable.openTag = (0, html_1.removeTagAttribute)(newTable.openTag, constants_1.INNER_DIFF_ATTRIBUTE);
+            beforeReplacements.push(openTagReplacement(oldTable, oldOpenTags[alignment.oldIndex]));
+            afterReplacements.push({
+                start: newTable.start,
+                end: newTable.end,
+                html: newTable.openTag + mergedInner + newTable.closeTag,
+            });
+        });
+        return {
+            before: (0, html_1.replaceRanges)(before, beforeReplacements),
+            after: (0, html_1.replaceRanges)(after, afterReplacements),
+        };
+    }
+}
+exports.TableRedlining = TableRedlining;

package/js/tables/TableVersion.d.ts

@@ -0,0 +1,32 @@
+import { Cell } from "./Cell";
+import { Row } from "./Row";
+import { ValueCounts } from "./similarity";
+import { Table } from "./Table";
+export declare class TableVersion {
+    readonly table: Table;
+    readonly rows: Row[];
+    readonly cells: Cell[][];
+    readonly signatures: string[][];
+    readonly shapes: string[];
+    readonly columnCount: number;
+    readonly hasSpans: boolean;
+    readonly hasRowKeys: boolean;
+    readonly mergedCells: Record<string, string>;
+    constructor(table: Table, rows: Row[], cells: Cell[][]);
+    static read(table: Table): TableVersion;
+    slice(start: number, end?: number): TableVersion;
+    signatureAt(rowIndex: number, columnIndex: number): string;
+    hasSameShapeAs(other: TableVersion): boolean;
+    hasSameSpanLayoutAs(other: TableVersion): boolean;
+    static isHeaderRow(cells: Cell[]): boolean;
+    headerRowCount(): number;
+    isSequenceColumn(columnIndex: number): boolean;
+    columnValueCounts(): ValueCounts[];
+    valueCounts(): ValueCounts;
+    ownerOf(cell: Cell): Cell | undefined;
+    rowKeys(rowIndex: number): string[];
+    rowKeysByRow(): string[][];
+    private static keysOf;
+    groupSignatures(rowIndex: number): string[];
+    isContinuationRow(rowIndex: number): boolean;
+}

package/js/tables/TableVersion.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TableVersion = void 0;
+const helpers_1 = require("./helpers");
+const similarity_1 = require("./similarity");
+class TableVersion {
+    table;
+    rows;
+    cells;
+    signatures;
+    shapes;
+    columnCount;
+    hasSpans;
+    hasRowKeys;
+    mergedCells;
+    constructor(table, rows, cells) {
+        this.table = table;
+        this.rows = rows;
+        this.cells = cells;
+        this.signatures = cells.map((rowCells) => rowCells.map((cell) => cell.signature()));
+        this.shapes = cells.map((rowCells) => rowCells.map((cell) => cell.shape()).join("|"));
+        this.columnCount = cells.reduce((max, rowCells) => Math.max(max, rowCells.length), 0);
+        this.hasSpans = (0, helpers_1.flatten)(cells).some((cell) => cell.span("colspan") > 1 || cell.span("rowspan") > 1);
+        this.hasRowKeys = (0, helpers_1.flatten)(cells).some((cell) => cell.ownId() !== null);
+        this.mergedCells = Object.create(null);
+        cells.forEach((rowCells, rowIndex) => {
+            rowCells.forEach((cell, cellIndex) => {
+                if (cell.mergedKey !== null) {
+                    this.mergedCells[cell.mergedKey] = this.signatures[rowIndex][cellIndex];
+                }
+            });
+        });
+    }
+    static read(table) {
+        const rows = table.rows();
+        return new TableVersion(table, rows, rows.map((row) => row.cells));
+    }
+    slice(start, end = this.rows.length) {
+        return new TableVersion(this.table, this.rows.slice(start, end), this.cells.slice(start, end));
+    }
+    signatureAt(rowIndex, columnIndex) {
+        const rowSignatures = this.signatures[rowIndex];
+        return rowSignatures && rowSignatures[columnIndex] !== undefined ? rowSignatures[columnIndex] : "";
+    }
+    hasSameShapeAs(other) {
+        return this.shapes.length === other.shapes.length && this.shapes.every((shape, index) => shape === other.shapes[index]);
+    }
+    hasSameSpanLayoutAs(other) {
+        const layout = (version) => {
+            const spans = [];
+            version.cells.forEach((rowCells) => {
+                rowCells.forEach((cell, cellIndex) => {
+                    if (cell.span("colspan") > 1 || cell.span("rowspan") > 1) {
+                        spans.push(`${cellIndex}:${cell.shape()}`);
+                    }
+                });
+            });
+            return spans.sort().join(",");
+        };
+        return layout(this) === layout(other);
+    }
+    static isHeaderRow(cells) {
+        return cells.length > 0 && cells.every((cell) => cell.tag === "th");
+    }
+    headerRowCount() {
+        for (let rowIndex = 0; rowIndex < this.rows.length; rowIndex++) {
+            if (this.rows[rowIndex].container !== "thead" && !TableVersion.isHeaderRow(this.cells[rowIndex])) {
+                return rowIndex;
+            }
+        }
+        return this.rows.length;
+    }
+    isSequenceColumn(columnIndex) {
+        const bodyRows = (0, helpers_1.range)(0, this.rows.length).filter((rowIndex) => !TableVersion.isHeaderRow(this.cells[rowIndex]));
+        return bodyRows.length > 0 && bodyRows.every((rowIndex, position) => this.signatureAt(rowIndex, columnIndex) === String(position + 1));
+    }
+    columnValueCounts() {
+        return (0, helpers_1.range)(0, this.columnCount).map((columnIndex) => (0, similarity_1.countValues)(this.signatures.map((rowSignatures) => (rowSignatures[columnIndex] === undefined ? "" : rowSignatures[columnIndex]))));
+    }
+    valueCounts() {
+        return (0, similarity_1.countValues)((0, helpers_1.flatten)(this.signatures));
+    }
+    ownerOf(cell) {
+        if (cell.partOf === null) {
+            return cell;
+        }
+        const partOf = cell.partOf;
+        return (0, helpers_1.flatten)(this.cells).filter((other) => other.mergedKey === partOf)[0];
+    }
+    rowKeys(rowIndex) {
+        return TableVersion.keysOf(this.cells[rowIndex], (cell) => this.ownerOf(cell));
+    }
+    rowKeysByRow() {
+        if (!this.hasRowKeys) {
+            return this.rows.map(() => []);
+        }
+        const owners = new Map();
+        (0, helpers_1.flatten)(this.cells).forEach((cell) => {
+            if (cell.mergedKey !== null && !owners.has(cell.mergedKey)) {
+                owners.set(cell.mergedKey, cell);
+            }
+        });
+        return this.cells.map((rowCells) => TableVersion.keysOf(rowCells, (cell) => (cell.partOf === null ? cell : owners.get(cell.partOf))));
+    }
+    static keysOf(rowCells, ownerOf) {
+        const keys = [];
+        (rowCells || []).forEach((cell) => {
+            const owner = ownerOf(cell);
+            const key = owner ? owner.ownId() : null;
+            if (key !== null) {
+                keys.push(key);
+            }
+        });
+        return keys;
+    }
+    groupSignatures(rowIndex) {
+        return (0, helpers_1.flatten)(this.cells[rowIndex].map((cell) => {
+            const key = cell.mergedKey !== null ? cell.mergedKey : cell.partOf;
+            const signature = key === null ? undefined : this.mergedCells[key];
+            return signature === undefined || signature === "" ? [] : [signature];
+        }));
+    }
+    isContinuationRow(rowIndex) {
+        const rowCells = this.cells[rowIndex];
+        return rowCells.some((cell) => cell.partOf !== null && !rowCells.some((other) => other.mergedKey === cell.partOf));
+    }
+}
+exports.TableVersion = TableVersion;

package/js/tables/constants.d.ts

@@ -0,0 +1,6 @@
+export declare const TABLE_ID_PREFIX = "redline-table-";
+export declare const ROW_ADDED_CLASS = "table-row-added";
+export declare const ROW_DELETED_CLASS = "table-row-deleted";
+export declare const CELL_ADDED_CLASS = "table-cell-added";
+export declare const CELL_DELETED_CLASS = "table-cell-deleted";
+export declare type CellDiff = (before: string, after: string) => string;

package/js/tables/constants.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CELL_DELETED_CLASS = exports.CELL_ADDED_CLASS = exports.ROW_DELETED_CLASS = exports.ROW_ADDED_CLASS = exports.TABLE_ID_PREFIX = void 0;
+exports.TABLE_ID_PREFIX = "redline-table-";
+exports.ROW_ADDED_CLASS = "table-row-added";
+exports.ROW_DELETED_CLASS = "table-row-deleted";
+exports.CELL_ADDED_CLASS = "table-cell-added";
+exports.CELL_DELETED_CLASS = "table-cell-deleted";

package/js/tables/helpers.d.ts

@@ -0,0 +1,4 @@
+export declare function range(start: number, end: number): number[];
+export declare function flatten<T>(arrays: T[][]): T[];
+export declare function last<T>(array: T[]): T | undefined;
+export declare function uniqueValues<T>(values: T[]): T[];

package/js/tables/helpers.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uniqueValues = exports.last = exports.flatten = exports.range = void 0;
+function range(start, end) {
+    const result = [];
+    for (let i = start; i < end; i++) {
+        result.push(i);
+    }
+    return result;
+}
+exports.range = range;
+function flatten(arrays) {
+    return [].concat(...arrays);
+}
+exports.flatten = flatten;
+function last(array) {
+    return array[array.length - 1];
+}
+exports.last = last;
+function uniqueValues(values) {
+    return Array.from(new Set(values));
+}
+exports.uniqueValues = uniqueValues;

package/js/tables/html.d.ts

@@ -0,0 +1,32 @@
+export interface Tag {
+    name: string;
+    isComment: boolean;
+    isClosing: boolean;
+    isSelfClosing: boolean;
+    attributes: string;
+    text: string;
+    start: number;
+    end: number;
+}
+export interface Element {
+    name: string;
+    start: number;
+    openTag: string;
+    innerStart: number;
+    inner: string;
+    closeTag: string;
+    end: number;
+}
+export interface Replacement {
+    start: number;
+    end: number;
+    html: string;
+}
+export declare function scanTags(html: string, callback: (tag: Tag) => void): void;
+export declare function findElements(html: string, tagNames: string[]): Element[];
+export declare function getTagAttribute(tag: string, name: string): string | null;
+export declare function setTagAttribute(tag: string, name: string, value: string | number): string;
+export declare function removeTagAttribute(tag: string, name: string): string;
+export declare function addTagClass(tag: string, className: string): string;
+export declare function decodeEntities(text: string): string;
+export declare function replaceRanges(html: string, replacements: Replacement[]): string;

package/js/tables/html.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.replaceRanges = exports.decodeEntities = exports.addTagClass = exports.removeTagAttribute = exports.setTagAttribute = exports.getTagAttribute = exports.findElements = exports.scanTags = void 0;
+const TAG_REGEXP = /<!--[\s\S]*?-->|<(\/?)([a-zA-Z][\w-]*)((?:[^>"']|"[^"]*"|'[^']*')*)>/g;
+const VOID_TAG_NAMES = ["area", "base", "br", "col", "embed", "hr", "img", "input", "link", "meta", "param", "source", "track", "wbr"];
+function scanTags(html, callback) {
+    const regExp = new RegExp(TAG_REGEXP.source, "g");
+    let match;
+    while ((match = regExp.exec(html))) {
+        const name = match[2] ? match[2].toLowerCase() : "";
+        callback({
+            name,
+            isComment: !match[2],
+            isClosing: match[1] === "/",
+            isSelfClosing: !match[2] || /\/\s*>$/.test(match[0]) || VOID_TAG_NAMES.indexOf(name) !== -1,
+            attributes: match[3],
+            text: match[0],
+            start: match.index,
+            end: match.index + match[0].length,
+        });
+    }
+}
+exports.scanTags = scanTags;
+function findElements(html, tagNames) {
+    const elements = [];
+    let tableDepth = 0;
+    let current = null;
+    scanTags(html, (tag) => {
+        if (!tag.isClosing && tableDepth === 0 && !current && tagNames.indexOf(tag.name) !== -1) {
+            current = { name: tag.name, start: tag.start, openTag: tag.text, innerStart: tag.end };
+        }
+        if (tag.name === "table") {
+            tableDepth += tag.isClosing ? -1 : 1;
+        }
+        if (tag.isClosing && tableDepth === 0 && current && tag.name === current.name) {
+            current.inner = html.slice(current.innerStart, tag.start);
+            current.closeTag = tag.text;
+            current.end = tag.end;
+            elements.push(current);
+            current = null;
+        }
+    });
+    return elements;
+}
+exports.findElements = findElements;
+const attributeRegExps = new Map();
+function attributeRegExp(name) {
+    let regExp = attributeRegExps.get(name);
+    if (!regExp) {
+        regExp = new RegExp("(\\s" + name + ")(\\s*=\\s*(\"[^\"]*\"|'[^']*'|[^\\s\"'>]+))?(?=[\\s/>])", "i");
+        attributeRegExps.set(name, regExp);
+    }
+    return regExp;
+}
+function unquote(value) {
+    return /^["']/.test(value) ? value.slice(1, -1) : value;
+}
+function getTagAttribute(tag, name) {
+    const match = attributeRegExp(name).exec(tag);
+    if (!match) {
+        return null;
+    }
+    return match[3] === undefined ? "" : unquote(match[3]);
+}
+exports.getTagAttribute = getTagAttribute;
+function setTagAttribute(tag, name, value) {
+    const match = attributeRegExp(name).exec(tag);
+    const attribute = " " + name + '="' + String(value).replace(/"/g, "&quot;") + '"';
+    if (match) {
+        return tag.slice(0, match.index) + attribute + tag.slice(match.index + match[0].length);
+    }
+    return tag.replace(/\s*\/?>$/, attribute + "$&");
+}
+exports.setTagAttribute = setTagAttribute;
+function removeTagAttribute(tag, name) {
+    const match = attributeRegExp(name).exec(tag);
+    return match ? tag.slice(0, match.index) + tag.slice(match.index + match[0].length) : tag;
+}
+exports.removeTagAttribute = removeTagAttribute;
+function addTagClass(tag, className) {
+    const current = getTagAttribute(tag, "class");
+    const tokens = current === null ? [] : current.split(/\s+/).filter((token) => token !== "");
+    if (tokens.indexOf(className) !== -1) {
+        return tag;
+    }
+    return setTagAttribute(tag, "class", tokens.concat(className).join(" "));
+}
+exports.addTagClass = addTagClass;
+const NAMED_ENTITIES = { amp: "&", lt: "<", gt: ">", quot: '"', apos: "'", nbsp: "\u00A0" };
+function decodeEntities(text) {
+    return text.replace(/&(#x[0-9a-f]+|#\d+|[a-z]+);/gi, (entity, body) => {
+        const lower = body.toLowerCase();
+        if (lower.charAt(0) === "#") {
+            const code = lower.charAt(1) === "x" ? parseInt(lower.slice(2), 16) : parseInt(lower.slice(1), 10);
+            return isNaN(code) ? entity : String.fromCharCode(code);
+        }
+        return Object.prototype.hasOwnProperty.call(NAMED_ENTITIES, lower) ? NAMED_ENTITIES[lower] : entity;
+    });
+}
+exports.decodeEntities = decodeEntities;
+function replaceRanges(html, replacements) {
+    return replacements
+        .slice()
+        .sort((first, second) => second.start - first.start)
+        .reduce((result, replacement) => result.slice(0, replacement.start) + replacement.html + result.slice(replacement.end), html);
+}
+exports.replaceRanges = replaceRanges;

package/js/tables/index.d.ts

@@ -0,0 +1,2 @@
+export { TableRedlining, PreparedHtml } from "./TableRedlining";
+export { CellDiff } from "./constants";

package/js/tables/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TableRedlining = void 0;
+var TableRedlining_1 = require("./TableRedlining");
+Object.defineProperty(exports, "TableRedlining", { enumerable: true, get: function () { return TableRedlining_1.TableRedlining; } });

package/js/tables/similarity.d.ts

@@ -0,0 +1,10 @@
+export declare type ValueCounts = Record<string, number>;
+export declare function countValues(values: string[]): ValueCounts;
+export declare function countsSize(counts: ValueCounts): number;
+export declare function retainedShare(oldCounts: ValueCounts, newCounts: ValueCounts): number;
+export declare function valueOverlap(oldCounts: ValueCounts, newCounts: ValueCounts): number;
+export declare function sharedShare(oldCounts: ValueCounts, newCounts: ValueCounts): number;
+export declare function distinctSharedShare(oldCounts: ValueCounts, newCounts: ValueCounts): number;
+export declare function cellSimilarity(oldSignature: string, newSignature: string): number;
+export declare function signatureWords(signature: string): string[];
+export declare function wordSimilarity(oldWords: string[], newWords: string[]): number;

package/js/tables/similarity.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wordSimilarity = exports.signatureWords = exports.cellSimilarity = exports.distinctSharedShare = exports.sharedShare = exports.valueOverlap = exports.retainedShare = exports.countsSize = exports.countValues = void 0;
+const helpers_1 = require("./helpers");
+function countValues(values) {
+    const counts = Object.create(null);
+    values.forEach((value) => {
+        if (value !== "") {
+            counts[value] = (counts[value] || 0) + 1;
+        }
+    });
+    return counts;
+}
+exports.countValues = countValues;
+function countsSize(counts) {
+    return Object.keys(counts).length;
+}
+exports.countsSize = countsSize;
+function retainedShare(oldCounts, newCounts) {
+    let shared = 0;
+    let total = 0;
+    Object.keys(oldCounts).forEach((value) => {
+        shared += Math.min(oldCounts[value], newCounts[value] || 0);
+        total += oldCounts[value];
+    });
+    return total === 0 ? 0 : shared / total;
+}
+exports.retainedShare = retainedShare;
+function valueOverlap(oldCounts, newCounts) {
+    if (countsSize(oldCounts) === 0 && countsSize(newCounts) === 0) {
+        return NaN;
+    }
+    let shared = 0;
+    let total = 0;
+    (0, helpers_1.uniqueValues)(Object.keys(oldCounts).concat(Object.keys(newCounts))).forEach((value) => {
+        const oldCount = oldCounts[value] || 0;
+        const newCount = newCounts[value] || 0;
+        shared += Math.min(oldCount, newCount);
+        total += Math.max(oldCount, newCount);
+    });
+    return shared / total;
+}
+exports.valueOverlap = valueOverlap;
+function sharedShare(oldCounts, newCounts) {
+    let oldTotal = 0;
+    let newTotal = 0;
+    let shared = 0;
+    Object.keys(oldCounts).forEach((value) => {
+        oldTotal += oldCounts[value];
+    });
+    Object.keys(newCounts).forEach((value) => {
+        newTotal += newCounts[value];
+    });
+    if (oldTotal === 0 && newTotal === 0) {
+        return NaN;
+    }
+    if (oldTotal === 0 || newTotal === 0) {
+        return 0;
+    }
+    Object.keys(oldCounts).forEach((value) => {
+        shared += Math.min(oldCounts[value], newCounts[value] || 0);
+    });
+    return shared / Math.min(oldTotal, newTotal);
+}
+exports.sharedShare = sharedShare;
+function distinctSharedShare(oldCounts, newCounts) {
+    let oldTotal = 0;
+    let newTotal = 0;
+    Object.keys(oldCounts).forEach((value) => {
+        oldTotal += oldCounts[value];
+    });
+    Object.keys(newCounts).forEach((value) => {
+        newTotal += newCounts[value];
+    });
+    if (oldTotal === 0 && newTotal === 0) {
+        return NaN;
+    }
+    if (oldTotal === 0 || newTotal === 0) {
+        return 0;
+    }
+    const shared = Object.keys(oldCounts).filter((value) => newCounts[value] !== undefined).length;
+    return shared / Math.min(oldTotal, newTotal);
+}
+exports.distinctSharedShare = distinctSharedShare;
+function cellSimilarity(oldSignature, newSignature) {
+    if (oldSignature === newSignature) {
+        return 1;
+    }
+    return wordSimilarity(signatureWords(oldSignature), signatureWords(newSignature));
+}
+exports.cellSimilarity = cellSimilarity;
+function signatureWords(signature) {
+    return (0, helpers_1.uniqueValues)(signature.split(/[\s|]+/).filter((word) => word !== ""));
+}
+exports.signatureWords = signatureWords;
+function wordSimilarity(oldWords, newWords) {
+    const newSet = new Set(newWords);
+    let shared = 0;
+    oldWords.forEach((word) => {
+        if (newSet.has(word)) {
+            shared++;
+        }
+    });
+    const total = oldWords.length + newWords.length - shared;
+    return total === 0 ? 1 : shared / total;
+}
+exports.wordSimilarity = wordSimilarity;

package/package.json

@@ -2,7 +2,7 @@
     "name": "@matrixreq/htmldiff",
     "description": "Diff and markup HTML with <ins> and <del> tags",
     "companyname": "Matrix Requirements",
-    "version": "1.5.0",
+    "version": "2.0.0",
     "keywords": [
         "diff",
         "html",
@@ -13,7 +13,7 @@
     "homepage": "https://github.com/MatrixRequirements/htmldiff.js",
     "repository": {
         "type": "git",
-        "url": "git+https://github.com/MatrixRequirements/htmldiff.js"
+        "url": "git+https://github.com/MatrixRequirements/htmldiff.js.git"
     },
     "readme": "README.md",
     "bugs": {
@@ -22,34 +22,41 @@
     "license": "MIT",
     "main": "js/htmldiff.js",
     "bin": {
-        "htmldiff": "./htmldiff-cli.js"
+        "htmldiff": "htmldiff-cli.js"
     },
     "files": [
-        "js/htmldiff.js",
-        "js/htmldiff.d.ts",
+        "js/**/*.js",
+        "js/**/*.d.ts",
         "sample/*",
-        "test/*",
         "htmldiff-cli.js"
     ],
     "types": "js/htmldiff.d.ts",
-    "dependencies": {},
     "devDependencies": {
+        "@types/chai": "^4.3.20",
+        "@types/mocha": "^10.0.10",
         "@types/node": "18.7.11",
         "@typescript-eslint/eslint-plugin": "5.34.0",
         "@typescript-eslint/parser": "5.34.0",
         "chai": "*",
         "eslint": "8.22.0",
         "eslint-plugin-jsdoc": "39.3.6",
+        "mocha": "*",
         "pkg": "5.8.0",
-        "typescript": "4.7.4",
-        "mocha": "*"
+        "ts-node": "^10.9.2",
+        "typescript": "4.7.4"
     },
     "scripts": {
-        "test": "mocha -R min",
-        "testsample": "node htmldiff-cli.js sample/before.html sample/after.html - -c myDiffClass -p myPrefix",
-        "lint": "eslint -c eslintrc.json --parser-options=project:./tsconfig.json --ext .ts ./",
+        "prebuild": "node -e \"require('fs').rmSync('js',{recursive:true,force:true})\"",
+        "build": "tsc -p tsconfig.build.json",
+        "build:cli": "tsc -p tsconfig.cli.json",
+        "prepare": "npm run build",
+        "test": "npm run build && tsc -p tsconfig.json && mocha -R min",
+        "lint": "npm run build && eslint -c eslintrc.json --ext .ts ./",
+        "verify": "npm run build && tsc -p tsconfig.json && mocha -R min && eslint -c eslintrc.json --ext .ts ./ && npm run build:cli",
+        "prepublishOnly": "npm run verify",
         "premake": "npm run lint",
-        "make": "tsc -p tsconfig.json && node -e \"require('fs').unlinkSync('./htmldiff-cli.d.ts')\"",
+        "make": "npm run build && npm run build:cli",
+        "testsample": "node htmldiff-cli.js sample/before.html sample/after.html - -c myDiffClass -p myPrefix",
         "pack-macos-aarch64": "pkg -t node18-macos-arm64       -C GZip --output ./bin/macos-aarch64/htmldiff-cli htmldiff-cli.js -c ./pkg.json",
         "pack-macos-x64": "    pkg -t node18-macos-x64         -C GZip --output ./bin/macos-x64/htmldiff-cli     htmldiff-cli.js -c ./pkg.json",
         "pack-win32-x64": "    pkg -t node18-win32-x64         -C GZip --output ./bin/win32-x64/htmldiff-cli     htmldiff-cli.js -c ./pkg.json",
@@ -57,4 +64,4 @@
         "pack-linux-aarch64": "pkg -t node18-linuxstatic-arm64 -C GZip --output ./bin/linux-aarch64/htmldiff-cli htmldiff-cli.js -c ./pkg.json",
         "pack-all": "npm run pack-macos-aarch64 && npm run pack-macos-x64 && npm run pack-win32-x64 && npm run pack-linux-x64 && npm run pack-linux-aarch64"
     }
-}
+}