@jam-comments/server-utilities 4.0.2 → 4.2.0

package/dist/cjs/injectSchema.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.injectSchema = void 0;
+const utils_1 = require("./utils");
+function injectSchema(markup, schema) {
+    const commentSchema = markup.match(/<div jc-data="jcSchema" data-schema="(.*)"><\/div>/)?.[1];
+    if (!commentSchema) {
+        return markup;
+    }
+    const json = (0, utils_1.parseJson)((0, utils_1.unescapeHTML)(commentSchema));
+    if (!json) {
+        return markup;
+    }
+    schema.comment = json;
+    return markup
+        .replace("<!-- JC:SCHEMA -->", `<script type="application/ld+json">${JSON.stringify(schema)}</script>`)
+        .replace(/<div jc-data="jcSchema" data-schema=".*"><\/div>(?:\n+)?/, "");
+}
+exports.injectSchema = injectSchema;

package/dist/cjs/injectSchema.test.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const injectSchema_1 = require("./injectSchema");
+(0, vitest_1.it)("injects schema into markup", () => {
+    const markup = `
+<div id="jcComments">
+    <div jc-data="jcSchema" data-schema="[{&quot;@context&quot;:&quot;https:\/\/schema.org&quot;,&quot;@type&quot;:&quot;Comment&quot;,&quot;name&quot;:&quot;Alexis&quot;,&quot;dateCreated&quot;:&quot;2022-10-28T10:41:49+00:00&quot;,&quot;url&quot;:&quot;https:\/\/macarthur.me\/posts\/dynamic-routing#comment-133&quot;}]"></div>
+
+<!-- JC:SCHEMA -->
+</div>`;
+    const blogPostSchema = {
+        "@context": "http://schema.org",
+        "@type": "BlogPosting",
+    };
+    const result = (0, injectSchema_1.injectSchema)(markup, blogPostSchema);
+    (0, vitest_1.expect)(result).toEqual(`
+<div id="jcComments">
+    <script type="application/ld+json">{"@context":"http://schema.org","@type":"BlogPosting","comment":[{"@context":"https://schema.org","@type":"Comment","name":"Alexis","dateCreated":"2022-10-28T10:41:49+00:00","url":"https://macarthur.me/posts/dynamic-routing#comment-133"}]}</script>
+</div>`);
+});
+(0, vitest_1.it)("returns markup if schema is not found", () => {
+    const markup = `
+<div id="jcComments">
+<!-- JC:SCHEMA -->
+</div>`;
+    const blogPostSchema = {
+        "@context": "http://schema.org",
+        "@type": "BlogPosting",
+    };
+    const result = (0, injectSchema_1.injectSchema)(markup, blogPostSchema);
+    (0, vitest_1.expect)(result).toEqual(markup);
+});
+(0, vitest_1.it)("returns markup if schema is not valid JSON", () => {
+    const markup = `
+<div id="jcComments">
+    <div jc-data="jcSchema" data-schema="not-valid-json"></div>
+    <!-- JC:SCHEMA -->
+</div>`;
+    const blogPostSchema = {
+        "@context": "http://schema.org",
+        "@type": "BlogPosting",
+    };
+    const result = (0, injectSchema_1.injectSchema)(markup, blogPostSchema);
+    (0, vitest_1.expect)(result).toEqual(markup);
+});
+(0, vitest_1.it)("injects even when JSON is not HTML-encoded", () => {
+    const markup = `
+<div id="jcComments">
+    <div jc-data="jcSchema" data-schema="[{"@context":"https://schema.org","@type":"Comment","name":"Alexis","dateCreated":"2022-10-28T10:41:49+00:00","url":"https://macarthur.me/posts/dynamic-routing#comment-133"}]"></div>
+
+<!-- JC:SCHEMA -->
+</div>`;
+    const blogPostSchema = {
+        "@context": "http://schema.org",
+        "@type": "BlogPosting",
+    };
+    const result = (0, injectSchema_1.injectSchema)(markup, blogPostSchema);
+    (0, vitest_1.expect)(result).toEqual(`
+<div id="jcComments">
+    <script type="application/ld+json">{"@context":"http://schema.org","@type":"BlogPosting","comment":[{"@context":"https://schema.org","@type":"Comment","name":"Alexis","dateCreated":"2022-10-28T10:41:49+00:00","url":"https://macarthur.me/posts/dynamic-routing#comment-133"}]}</script>
+</div>`);
+});

package/dist/cjs/markupFetcher.js

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.markupFetcher = void 0;
+const injectSchema_1 = require("./injectSchema");
 const utils_1 = require("./utils");
 const markupFetcher = (platform, fetchImplementation = fetch) => {
-    return async ({ tz = undefined, path, domain, apiKey, baseUrl = "https://go.jamcomments.com", environment = (0, utils_1.getEnvironment)(), }) => {
+    return async ({ tz = undefined, path, domain, apiKey, schema, baseUrl = "https://go.jamcomments.com", environment = (0, utils_1.getEnvironment)(), }) => {
         const trimmedTimezone = tz?.trim();
         if (trimmedTimezone && !(0, utils_1.isValidTimezone)(trimmedTimezone)) {
             throw new Error(`The timezone passed to JamComments is invalid: ${trimmedTimezone}`);
@@ -33,7 +34,16 @@ const markupFetcher = (platform, fetchImplementation = fetch) => {
         if (!response.ok) {
             throw new Error(`JamComments request failed! Status code: ${response.status}, message: ${response.statusText}, request URL: ${requestUrl}`);
         }
-        return await response.text();
+        const markup = await response.text();
+        if (schema) {
+            const preparedSchema = typeof schema !== "string" ? JSON.stringify(schema) : schema;
+            const parsedSchema = (0, utils_1.parseJson)(preparedSchema);
+            if (!parsedSchema) {
+                return markup;
+            }
+            return (0, injectSchema_1.injectSchema)(markup, parsedSchema);
+        }
+        return markup;
     };
 };
 exports.markupFetcher = markupFetcher;

package/dist/cjs/markupFetcher.test.js

@@ -1,9 +1,34 @@
 "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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 const vitest_1 = require("vitest");
+const injectSchema = __importStar(require("./injectSchema"));
 const markupFetcher_1 = require("./markupFetcher");
 (0, vitest_1.describe)("markupFetcher", () => {
     (0, vitest_1.it)("constructs fetch request correctly", async () => {
+        const injectSchemaSpy = vitest_1.vi.spyOn(injectSchema, "injectSchema");
         const fetchMock = vitest_1.vi.fn().mockImplementation(() => {
             return {
                 status: 200,
@@ -18,6 +43,7 @@ const markupFetcher_1 = require("./markupFetcher");
             apiKey: "123abc",
             environment: "production",
         });
+        (0, vitest_1.expect)(injectSchemaSpy).not.toHaveBeenCalled();
         (0, vitest_1.expect)(fetchMock).toHaveBeenCalledWith("https://go.jamcomments.com/api/v3/markup?path=%2Ftest&domain=test.com", vitest_1.expect.objectContaining({
             headers: vitest_1.expect.objectContaining({
                 Accept: "application/json",
@@ -185,3 +211,68 @@ const markupFetcher_1 = require("./markupFetcher");
         });
     });
 });
+(0, vitest_1.describe)("passing schema", function () {
+    (0, vitest_1.it)("first stringifies schema if given an object", async () => {
+        const injectSchemaSpy = vitest_1.vi.spyOn(injectSchema, "injectSchema");
+        const fetchMock = vitest_1.vi.fn().mockImplementation(() => {
+            return {
+                status: 200,
+                ok: true,
+                text: () => "results!",
+            };
+        });
+        const fetcher = (0, markupFetcher_1.markupFetcher)("test", fetchMock);
+        const result = await fetcher({
+            path: "/test",
+            domain: "test.com",
+            apiKey: "123abc",
+            schema: { foo: "bar" },
+            environment: "production",
+        });
+        (0, vitest_1.expect)(injectSchemaSpy).toHaveBeenCalledWith("results!", { foo: "bar" });
+        (0, vitest_1.expect)(fetchMock).toHaveBeenCalledWith("https://go.jamcomments.com/api/v3/markup?path=%2Ftest&domain=test.com", vitest_1.expect.anything());
+        (0, vitest_1.expect)(result).toEqual("results!");
+    });
+    (0, vitest_1.it)("does not stringify schema if given a string", async () => {
+        const injectSchemaSpy = vitest_1.vi.spyOn(injectSchema, "injectSchema");
+        const fetchMock = vitest_1.vi.fn().mockImplementation(() => {
+            return {
+                status: 200,
+                ok: true,
+                text: () => "results!",
+            };
+        });
+        const fetcher = (0, markupFetcher_1.markupFetcher)("test", fetchMock);
+        const result = await fetcher({
+            path: "/test",
+            domain: "test.com",
+            apiKey: "123abc",
+            schema: '{"foo":"bar"}',
+            environment: "production",
+        });
+        (0, vitest_1.expect)(injectSchemaSpy).toHaveBeenCalledWith("results!", { foo: "bar" });
+        (0, vitest_1.expect)(fetchMock).toHaveBeenCalledWith("https://go.jamcomments.com/api/v3/markup?path=%2Ftest&domain=test.com", vitest_1.expect.anything());
+        (0, vitest_1.expect)(result).toEqual("results!");
+    });
+    (0, vitest_1.it)("returns markup if invalid json is provided", async () => {
+        const injectSchemaSpy = vitest_1.vi.spyOn(injectSchema, "injectSchema");
+        const fetchMock = vitest_1.vi.fn().mockImplementation(() => {
+            return {
+                status: 200,
+                ok: true,
+                text: () => "results!",
+            };
+        });
+        const fetcher = (0, markupFetcher_1.markupFetcher)("test", fetchMock);
+        const result = await fetcher({
+            path: "/test",
+            domain: "test.com",
+            apiKey: "123abc",
+            schema: "not-valid-json",
+            environment: "production",
+        });
+        (0, vitest_1.expect)(injectSchemaSpy).not.toHaveBeenCalled();
+        (0, vitest_1.expect)(fetchMock).toHaveBeenCalledWith("https://go.jamcomments.com/api/v3/markup?path=%2Ftest&domain=test.com", vitest_1.expect.anything());
+        (0, vitest_1.expect)(result).toEqual("results!");
+    });
+});

package/dist/cjs/utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.reAppendMarkup = exports.getEnvironment = exports.isValidTimezone = void 0;
+exports.unescapeHTML = exports.parseJson = exports.reAppendMarkup = exports.getEnvironment = exports.isValidTimezone = void 0;
 function isValidTimezone(tz) {
     try {
         Intl.DateTimeFormat(undefined, { timeZone: tz });
@@ -28,3 +28,44 @@ function reAppendMarkup(element, markup) {
     element.append(documentFragment);
 }
 exports.reAppendMarkup = reAppendMarkup;
+function parseJson(json) {
+    try {
+        return JSON.parse(json);
+    }
+    catch (ex) {
+        return null;
+    }
+}
+exports.parseJson = parseJson;
+var htmlEntities = {
+    nbsp: " ",
+    cent: "¢",
+    pound: "£",
+    yen: "¥",
+    euro: "€",
+    copy: "©",
+    reg: "®",
+    lt: "<",
+    gt: ">",
+    quot: '"',
+    amp: "&",
+    apos: "'",
+};
+function unescapeHTML(str) {
+    return str.replace(/\&([^;]+);/g, function (entity, entityCode) {
+        var match;
+        if (entityCode in htmlEntities) {
+            return htmlEntities[entityCode];
+        }
+        else if ((match = entityCode.match(/^#x([\da-fA-F]+)$/))) {
+            return String.fromCharCode(parseInt(match[1], 16));
+        }
+        else if ((match = entityCode.match(/^#(\d+)$/))) {
+            return String.fromCharCode(~~match[1]);
+        }
+        else {
+            return entity;
+        }
+    });
+}
+exports.unescapeHTML = unescapeHTML;

package/dist/esm/injectSchema.js

@@ -0,0 +1,15 @@
+import { parseJson, unescapeHTML } from "./utils";
+export function injectSchema(markup, schema) {
+    const commentSchema = markup.match(/<div jc-data="jcSchema" data-schema="(.*)"><\/div>/)?.[1];
+    if (!commentSchema) {
+        return markup;
+    }
+    const json = parseJson(unescapeHTML(commentSchema));
+    if (!json) {
+        return markup;
+    }
+    schema.comment = json;
+    return markup
+        .replace("<!-- JC:SCHEMA -->", `<script type="application/ld+json">${JSON.stringify(schema)}</script>`)
+        .replace(/<div jc-data="jcSchema" data-schema=".*"><\/div>(?:\n+)?/, "");
+}

package/dist/esm/injectSchema.test.js

@@ -0,0 +1,61 @@
+import { expect, it } from "vitest";
+import { injectSchema } from "./injectSchema";
+it("injects schema into markup", () => {
+    const markup = `
+<div id="jcComments">
+    <div jc-data="jcSchema" data-schema="[{&quot;@context&quot;:&quot;https:\/\/schema.org&quot;,&quot;@type&quot;:&quot;Comment&quot;,&quot;name&quot;:&quot;Alexis&quot;,&quot;dateCreated&quot;:&quot;2022-10-28T10:41:49+00:00&quot;,&quot;url&quot;:&quot;https:\/\/macarthur.me\/posts\/dynamic-routing#comment-133&quot;}]"></div>
+
+<!-- JC:SCHEMA -->
+</div>`;
+    const blogPostSchema = {
+        "@context": "http://schema.org",
+        "@type": "BlogPosting",
+    };
+    const result = injectSchema(markup, blogPostSchema);
+    expect(result).toEqual(`
+<div id="jcComments">
+    <script type="application/ld+json">{"@context":"http://schema.org","@type":"BlogPosting","comment":[{"@context":"https://schema.org","@type":"Comment","name":"Alexis","dateCreated":"2022-10-28T10:41:49+00:00","url":"https://macarthur.me/posts/dynamic-routing#comment-133"}]}</script>
+</div>`);
+});
+it("returns markup if schema is not found", () => {
+    const markup = `
+<div id="jcComments">
+<!-- JC:SCHEMA -->
+</div>`;
+    const blogPostSchema = {
+        "@context": "http://schema.org",
+        "@type": "BlogPosting",
+    };
+    const result = injectSchema(markup, blogPostSchema);
+    expect(result).toEqual(markup);
+});
+it("returns markup if schema is not valid JSON", () => {
+    const markup = `
+<div id="jcComments">
+    <div jc-data="jcSchema" data-schema="not-valid-json"></div>
+    <!-- JC:SCHEMA -->
+</div>`;
+    const blogPostSchema = {
+        "@context": "http://schema.org",
+        "@type": "BlogPosting",
+    };
+    const result = injectSchema(markup, blogPostSchema);
+    expect(result).toEqual(markup);
+});
+it("injects even when JSON is not HTML-encoded", () => {
+    const markup = `
+<div id="jcComments">
+    <div jc-data="jcSchema" data-schema="[{"@context":"https://schema.org","@type":"Comment","name":"Alexis","dateCreated":"2022-10-28T10:41:49+00:00","url":"https://macarthur.me/posts/dynamic-routing#comment-133"}]"></div>
+
+<!-- JC:SCHEMA -->
+</div>`;
+    const blogPostSchema = {
+        "@context": "http://schema.org",
+        "@type": "BlogPosting",
+    };
+    const result = injectSchema(markup, blogPostSchema);
+    expect(result).toEqual(`
+<div id="jcComments">
+    <script type="application/ld+json">{"@context":"http://schema.org","@type":"BlogPosting","comment":[{"@context":"https://schema.org","@type":"Comment","name":"Alexis","dateCreated":"2022-10-28T10:41:49+00:00","url":"https://macarthur.me/posts/dynamic-routing#comment-133"}]}</script>
+</div>`);
+});

package/dist/esm/markupFetcher.js

@@ -1,6 +1,7 @@
-import { getEnvironment, isValidTimezone } from "./utils";
+import { injectSchema } from "./injectSchema";
+import { getEnvironment, isValidTimezone, parseJson } from "./utils";
 export const markupFetcher = (platform, fetchImplementation = fetch) => {
-    return async ({ tz = undefined, path, domain, apiKey, baseUrl = "https://go.jamcomments.com", environment = getEnvironment(), }) => {
+    return async ({ tz = undefined, path, domain, apiKey, schema, baseUrl = "https://go.jamcomments.com", environment = getEnvironment(), }) => {
         const trimmedTimezone = tz?.trim();
         if (trimmedTimezone && !isValidTimezone(trimmedTimezone)) {
             throw new Error(`The timezone passed to JamComments is invalid: ${trimmedTimezone}`);
@@ -30,6 +31,15 @@ export const markupFetcher = (platform, fetchImplementation = fetch) => {
         if (!response.ok) {
             throw new Error(`JamComments request failed! Status code: ${response.status}, message: ${response.statusText}, request URL: ${requestUrl}`);
         }
-        return await response.text();
+        const markup = await response.text();
+        if (schema) {
+            const preparedSchema = typeof schema !== "string" ? JSON.stringify(schema) : schema;
+            const parsedSchema = parseJson(preparedSchema);
+            if (!parsedSchema) {
+                return markup;
+            }
+            return injectSchema(markup, parsedSchema);
+        }
+        return markup;
     };
 };

package/dist/esm/markupFetcher.test.js

@@ -1,7 +1,9 @@
 import { describe, expect, it, vi } from "vitest";
+import * as injectSchema from "./injectSchema";
 import { markupFetcher } from "./markupFetcher";
 describe("markupFetcher", () => {
     it("constructs fetch request correctly", async () => {
+        const injectSchemaSpy = vi.spyOn(injectSchema, "injectSchema");
         const fetchMock = vi.fn().mockImplementation(() => {
             return {
                 status: 200,
@@ -16,6 +18,7 @@ describe("markupFetcher", () => {
             apiKey: "123abc",
             environment: "production",
         });
+        expect(injectSchemaSpy).not.toHaveBeenCalled();
         expect(fetchMock).toHaveBeenCalledWith("https://go.jamcomments.com/api/v3/markup?path=%2Ftest&domain=test.com", expect.objectContaining({
             headers: expect.objectContaining({
                 Accept: "application/json",
@@ -183,3 +186,68 @@ describe("markupFetcher", () => {
         });
     });
 });
+describe("passing schema", function () {
+    it("first stringifies schema if given an object", async () => {
+        const injectSchemaSpy = vi.spyOn(injectSchema, "injectSchema");
+        const fetchMock = vi.fn().mockImplementation(() => {
+            return {
+                status: 200,
+                ok: true,
+                text: () => "results!",
+            };
+        });
+        const fetcher = markupFetcher("test", fetchMock);
+        const result = await fetcher({
+            path: "/test",
+            domain: "test.com",
+            apiKey: "123abc",
+            schema: { foo: "bar" },
+            environment: "production",
+        });
+        expect(injectSchemaSpy).toHaveBeenCalledWith("results!", { foo: "bar" });
+        expect(fetchMock).toHaveBeenCalledWith("https://go.jamcomments.com/api/v3/markup?path=%2Ftest&domain=test.com", expect.anything());
+        expect(result).toEqual("results!");
+    });
+    it("does not stringify schema if given a string", async () => {
+        const injectSchemaSpy = vi.spyOn(injectSchema, "injectSchema");
+        const fetchMock = vi.fn().mockImplementation(() => {
+            return {
+                status: 200,
+                ok: true,
+                text: () => "results!",
+            };
+        });
+        const fetcher = markupFetcher("test", fetchMock);
+        const result = await fetcher({
+            path: "/test",
+            domain: "test.com",
+            apiKey: "123abc",
+            schema: '{"foo":"bar"}',
+            environment: "production",
+        });
+        expect(injectSchemaSpy).toHaveBeenCalledWith("results!", { foo: "bar" });
+        expect(fetchMock).toHaveBeenCalledWith("https://go.jamcomments.com/api/v3/markup?path=%2Ftest&domain=test.com", expect.anything());
+        expect(result).toEqual("results!");
+    });
+    it("returns markup if invalid json is provided", async () => {
+        const injectSchemaSpy = vi.spyOn(injectSchema, "injectSchema");
+        const fetchMock = vi.fn().mockImplementation(() => {
+            return {
+                status: 200,
+                ok: true,
+                text: () => "results!",
+            };
+        });
+        const fetcher = markupFetcher("test", fetchMock);
+        const result = await fetcher({
+            path: "/test",
+            domain: "test.com",
+            apiKey: "123abc",
+            schema: "not-valid-json",
+            environment: "production",
+        });
+        expect(injectSchemaSpy).not.toHaveBeenCalled();
+        expect(fetchMock).toHaveBeenCalledWith("https://go.jamcomments.com/api/v3/markup?path=%2Ftest&domain=test.com", expect.anything());
+        expect(result).toEqual("results!");
+    });
+});

package/dist/esm/utils.js

@@ -22,3 +22,42 @@ export function reAppendMarkup(element, markup) {
     element.innerHTML = "";
     element.append(documentFragment);
 }
+export function parseJson(json) {
+    try {
+        return JSON.parse(json);
+    }
+    catch (ex) {
+        return null;
+    }
+}
+var htmlEntities = {
+    nbsp: " ",
+    cent: "¢",
+    pound: "£",
+    yen: "¥",
+    euro: "€",
+    copy: "©",
+    reg: "®",
+    lt: "<",
+    gt: ">",
+    quot: '"',
+    amp: "&",
+    apos: "'",
+};
+export function unescapeHTML(str) {
+    return str.replace(/\&([^;]+);/g, function (entity, entityCode) {
+        var match;
+        if (entityCode in htmlEntities) {
+            return htmlEntities[entityCode];
+        }
+        else if ((match = entityCode.match(/^#x([\da-fA-F]+)$/))) {
+            return String.fromCharCode(parseInt(match[1], 16));
+        }
+        else if ((match = entityCode.match(/^#(\d+)$/))) {
+            return String.fromCharCode(~~match[1]);
+        }
+        else {
+            return entity;
+        }
+    });
+}

package/dist/types/injectSchema.d.ts

@@ -0,0 +1 @@
+export declare function injectSchema(markup: string, schema: Record<string, any>): string;

package/dist/types/injectSchema.test.d.ts

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

package/dist/types/markupFetcher.d.ts

@@ -2,8 +2,9 @@ export interface IFetchData {
     path: string;
     domain: string;
     apiKey: string;
+    schema?: string | object;
     tz?: string;
     baseUrl?: string;
     environment?: string;
 }
-export declare const markupFetcher: (platform: string, fetchImplementation?: typeof fetch) => (args: IFetchData) => Promise<string>;
+export declare const markupFetcher: (platform: string, fetchImplementation?: typeof fetch) => ((args: IFetchData) => Promise<string>);

package/dist/types/utils.d.ts

@@ -1,3 +1,5 @@
 export declare function isValidTimezone(tz: string): boolean;
 export declare function getEnvironment(): string;
 export declare function reAppendMarkup(element: HTMLElement, markup: string): void;
+export declare function parseJson(json: string): any;
+export declare function unescapeHTML(str: any): any;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jam-comments/server-utilities",
-  "version": "4.0.2",
+  "version": "4.2.0",
   "description": "Various JavaScript utilities for JamComments.",
   "main": "dist/cjs/index.js",
   "types": "dist/types/index.d.ts",
@@ -21,11 +21,11 @@
   "homepage": "https://jamcomments.com",
   "license": "GPL-2.0",
   "devDependencies": {
-    "@types/node": "^20.9.0",
-    "prettier": "^3.0.3",
-    "typescript": "^5.2.2",
-    "vite": "^4.5.0",
-    "vitest": "^0.34.6"
+    "@types/node": "^20.12.11",
+    "prettier": "^3.2.5",
+    "typescript": "^5.4.5",
+    "vite": "^5.2.11",
+    "vitest": "^1.6.0"
   },
   "publishConfig": {
     "access": "public"